Add files using upload-large-folder tool

llava_next/lib/python3.10/site-packages/numpy/ma/API_CHANGES.txt

@@ -0,0 +1,135 @@
+.. -*- rest -*-
+
+==================================================
+API changes in the new masked array implementation
+==================================================
+
+Masked arrays are subclasses of ndarray
+---------------------------------------
+
+Contrary to the original implementation, masked arrays are now regular
+ndarrays::
+
+  >>> x = masked_array([1,2,3],mask=[0,0,1])
+  >>> print isinstance(x, numpy.ndarray)
+  True
+
+
+``_data`` returns a view of the masked array
+--------------------------------------------
+
+Masked arrays are composed of a ``_data`` part and a ``_mask``. Accessing the
+``_data`` part will return a regular ndarray or any of its subclass, depending
+on the initial data::
+
+  >>> x = masked_array(numpy.matrix([[1,2],[3,4]]),mask=[[0,0],[0,1]])
+  >>> print x._data
+  [[1 2]
+   [3 4]]
+  >>> print type(x._data)
+  <class 'numpy.matrixlib.defmatrix.matrix'>
+
+
+In practice, ``_data`` is implemented as a property, not as an attribute.
+Therefore, you cannot access it directly, and some simple tests such as the
+following one will fail::
+
+  >>>x._data is x._data
+  False
+
+
+``filled(x)`` can return a subclass of ndarray
+----------------------------------------------
+The function ``filled(a)`` returns an array of the same type as ``a._data``::
+
+  >>> x = masked_array(numpy.matrix([[1,2],[3,4]]),mask=[[0,0],[0,1]])
+  >>> y = filled(x)
+  >>> print type(y)
+  <class 'numpy.matrixlib.defmatrix.matrix'>
+  >>> print y
+  matrix([[     1,      2],
+          [     3, 999999]])
+
+
+``put``, ``putmask`` behave like their ndarray counterparts
+-----------------------------------------------------------
+
+Previously, ``putmask`` was used like this::
+
+  mask = [False,True,True]
+  x = array([1,4,7],mask=mask)
+  putmask(x,mask,[3])
+
+which translated to::
+
+  x[~mask] = [3]
+
+(Note that a ``True``-value in a mask suppresses a value.)
+
+In other words, the mask had the same length as ``x``, whereas
+``values`` had ``sum(~mask)`` elements.
+
+Now, the behaviour is similar to that of ``ndarray.putmask``, where
+the mask and the values are both the same length as ``x``, i.e.
+
+::
+
+  putmask(x,mask,[3,0,0])
+
+
+``fill_value`` is a property
+----------------------------
+
+``fill_value`` is no longer a method, but a property::
+
+  >>> print x.fill_value
+  999999
+
+``cumsum`` and ``cumprod`` ignore missing values
+------------------------------------------------
+
+Missing values are assumed to be the identity element, i.e. 0 for
+``cumsum`` and 1 for ``cumprod``::
+
+  >>> x = N.ma.array([1,2,3,4],mask=[False,True,False,False])
+  >>> print x
+  [1 -- 3 4]
+  >>> print x.cumsum()
+  [1 -- 4 8]
+  >> print x.cumprod()
+  [1 -- 3 12]
+
+``bool(x)`` raises a ValueError
+-------------------------------
+
+Masked arrays now behave like regular ``ndarrays``, in that they cannot be
+converted to booleans:
+
+::
+
+  >>> x = N.ma.array([1,2,3])
+  >>> bool(x)
+  Traceback (most recent call last):
+    File "<stdin>", line 1, in <module>
+  ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
+
+
+==================================
+New features (non exhaustive list)
+==================================
+
+``mr_``
+-------
+
+``mr_`` mimics the behavior of ``r_`` for masked arrays::
+
+  >>> np.ma.mr_[3,4,5]
+  masked_array(data = [3 4 5],
+        mask = False,
+        fill_value=999999)
+
+
+``anom``
+--------
+
+The ``anom`` method returns the deviations from the average (anomalies).

llava_next/lib/python3.10/site-packages/numpy/ma/LICENSE

@@ -0,0 +1,24 @@
+* Copyright (c) 2006, University of Georgia and Pierre G.F. Gerard-Marchant
+* All rights reserved.
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+*
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above copyright
+*       notice, this list of conditions and the following disclaimer in the
+*       documentation and/or other materials provided with the distribution.
+*     * Neither the name of the University of Georgia nor the
+*       names of its contributors may be used to endorse or promote products
+*       derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

llava_next/lib/python3.10/site-packages/numpy/ma/README.rst

@@ -0,0 +1,236 @@
+==================================
+A Guide to Masked Arrays in NumPy
+==================================
+
+.. Contents::
+
+See http://www.scipy.org/scipy/numpy/wiki/MaskedArray (dead link)
+for updates of this document.
+
+
+History
+-------
+
+As a regular user of MaskedArray, I (Pierre G.F. Gerard-Marchant) became
+increasingly frustrated with the subclassing of masked arrays (even if
+I can only blame my inexperience). I needed to develop a class of arrays
+that could store some additional information along with numerical values,
+while keeping the possibility for missing data (picture storing a series
+of dates along with measurements, what would later become the `TimeSeries
+Scikit <http://projects.scipy.org/scipy/scikits/wiki/TimeSeries>`__
+(dead link).
+
+I started to implement such a class, but then quickly realized that
+any additional information disappeared when processing these subarrays
+(for example, adding a constant value to a subarray would erase its
+dates). I ended up writing the equivalent of *numpy.core.ma* for my
+particular class, ufuncs included. Everything went fine until I needed to
+subclass my new class, when more problems showed up: some attributes of
+the new subclass were lost during processing. I identified the culprit as
+MaskedArray, which returns masked ndarrays when I expected masked
+arrays of my class. I was preparing myself to rewrite *numpy.core.ma*
+when I forced myself to learn how to subclass ndarrays. As I became more
+familiar with the *__new__* and *__array_finalize__* methods,
+I started to wonder why masked arrays were objects, and not ndarrays,
+and whether it wouldn't be more convenient for subclassing if they did
+behave like regular ndarrays.
+
+The new *maskedarray* is what I eventually come up with. The
+main differences with the initial *numpy.core.ma* package are
+that MaskedArray is now a subclass of *ndarray* and that the
+*_data* section can now be any subclass of *ndarray*. Apart from a
+couple of issues listed below, the behavior of the new MaskedArray
+class reproduces the old one. Initially the *maskedarray*
+implementation was marginally slower than *numpy.ma* in some areas,
+but work is underway to speed it up; the expectation is that it can be
+made substantially faster than the present *numpy.ma*.
+
+
+Note that if the subclass has some special methods and
+attributes, they are not propagated to the masked version:
+this would require a modification of the *__getattribute__*
+method (first trying *ndarray.__getattribute__*, then trying
+*self._data.__getattribute__* if an exception is raised in the first
+place), which really slows things down.
+
+Main differences
+----------------
+
+ * The *_data* part of the masked array can be any subclass of ndarray (but not recarray, cf below).
+ * *fill_value* is now a property, not a function.
+ * in the majority of cases, the mask is forced to *nomask* when no value is actually masked. A notable exception is when a masked array (with no masked values) has just been unpickled.
+ * I got rid of the *share_mask* flag, I never understood its purpose.
+ * *put*, *putmask* and *take* now mimic the ndarray methods, to avoid unpleasant surprises. Moreover, *put* and *putmask* both update the mask when needed.  * if *a* is a masked array, *bool(a)* raises a *ValueError*, as it does with ndarrays.
+ * in the same way, the comparison of two masked arrays is a masked array, not a boolean
+ * *filled(a)* returns an array of the same subclass as *a._data*, and no test is performed on whether it is contiguous or not.
+ * the mask is always printed, even if it's *nomask*, which makes things easy (for me at least) to remember that a masked array is used.
+ * *cumsum* works as if the *_data* array was filled with 0. The mask is preserved, but not updated.
+ * *cumprod* works as if the *_data* array was filled with 1. The mask is preserved, but not updated.
+
+New features
+------------
+
+This list is non-exhaustive...
+
+ * the *mr_* function mimics *r_* for masked arrays.
+ * the *anom* method returns the anomalies (deviations from the average)
+
+Using the new package with numpy.core.ma
+----------------------------------------
+
+I tried to make sure that the new package can understand old masked
+arrays. Unfortunately, there's no upward compatibility.
+
+For example:
+
+>>> import numpy.core.ma as old_ma
+>>> import maskedarray as new_ma
+>>> x = old_ma.array([1,2,3,4,5], mask=[0,0,1,0,0])
+>>> x
+array(data =
+ [     1      2 999999      4      5],
+      mask =
+ [False False True False False],
+      fill_value=999999)
+>>> y = new_ma.array([1,2,3,4,5], mask=[0,0,1,0,0])
+>>> y
+array(data = [1 2 -- 4 5],
+      mask = [False False True False False],
+      fill_value=999999)
+>>> x==y
+array(data =
+ [True True True True True],
+      mask =
+ [False False True False False],
+      fill_value=?)
+>>> old_ma.getmask(x) == new_ma.getmask(x)
+array([True, True, True, True, True])
+>>> old_ma.getmask(y) == new_ma.getmask(y)
+array([True, True, False, True, True])
+>>> old_ma.getmask(y)
+False
+
+
+Using maskedarray with matplotlib
+---------------------------------
+
+Starting with matplotlib 0.91.2, the masked array importing will work with
+the maskedarray branch) as well as with earlier versions.
+
+By default matplotlib still uses numpy.ma, but there is an rcParams setting
+that you can use to select maskedarray instead.  In the matplotlibrc file
+you will find::
+
+  #maskedarray : False       # True to use external maskedarray module
+                             # instead of numpy.ma; this is a temporary #
+                             setting for testing maskedarray.
+
+
+Uncomment and set to True to select maskedarray everywhere.
+Alternatively, you can test a script with maskedarray by using a
+command-line option, e.g.::
+
+  python simple_plot.py --maskedarray
+
+
+Masked records
+--------------
+
+Like *numpy.core.ma*, the *ndarray*-based implementation
+of MaskedArray is limited when working with records: you can
+mask any record of the array, but not a field in a record. If you
+need this feature, you may want to give the *mrecords* package
+a try (available in the *maskedarray* directory in the scipy
+sandbox). This module defines a new class, *MaskedRecord*. An
+instance of this class accepts a *recarray* as data, and uses two
+masks: the *fieldmask* has as many entries as records in the array,
+each entry with the same fields as a record, but of boolean types:
+they indicate whether the field is masked or not; a record entry
+is flagged as masked in the *mask* array if all the fields are
+masked. A few examples in the file should give you an idea of what
+can be done. Note that *mrecords* is still experimental...
+
+Optimizing maskedarray
+----------------------
+
+Should masked arrays be filled before processing or not?
+--------------------------------------------------------
+
+In the current implementation, most operations on masked arrays involve
+the following steps:
+
+ * the input arrays are filled
+ * the operation is performed on the filled arrays
+ * the mask is set for the results, from the combination of the input masks and the mask corresponding to the domain of the operation.
+
+For example, consider the division of two masked arrays::
+
+  import numpy
+  import maskedarray as ma
+  x = ma.array([1,2,3,4],mask=[1,0,0,0], dtype=numpy.float_)
+  y = ma.array([-1,0,1,2], mask=[0,0,0,1], dtype=numpy.float_)
+
+The division of x by y is then computed as::
+
+  d1 = x.filled(0) # d1 = array([0., 2., 3., 4.])
+  d2 = y.filled(1) # array([-1.,  0.,  1.,  1.])
+  m = ma.mask_or(ma.getmask(x), ma.getmask(y)) # m =
+  array([True,False,False,True])
+  dm = ma.divide.domain(d1,d2) # array([False,  True, False, False])
+  result = (d1/d2).view(MaskedArray) # masked_array([-0. inf, 3., 4.])
+  result._mask = logical_or(m, dm)
+
+Note that a division by zero takes place. To avoid it, we can consider
+to fill the input arrays, taking the domain mask into account, so that::
+
+  d1 = x._data.copy() # d1 = array([1., 2., 3., 4.])
+  d2 = y._data.copy() # array([-1.,  0.,  1.,  2.])
+  dm = ma.divide.domain(d1,d2) # array([False,  True, False, False])
+  numpy.putmask(d2, dm, 1) # d2 = array([-1.,  1.,  1.,  2.])
+  m = ma.mask_or(ma.getmask(x), ma.getmask(y)) # m =
+  array([True,False,False,True])
+  result = (d1/d2).view(MaskedArray) # masked_array([-1. 0., 3., 2.])
+  result._mask = logical_or(m, dm)
+
+Note that the *.copy()* is required to avoid updating the inputs with
+*putmask*.  The *.filled()* method also involves a *.copy()*.
+
+A third possibility consists in avoid filling the arrays::
+
+  d1 = x._data # d1 = array([1., 2., 3., 4.])
+  d2 = y._data # array([-1.,  0.,  1.,  2.])
+  dm = ma.divide.domain(d1,d2) # array([False,  True, False, False])
+  m = ma.mask_or(ma.getmask(x), ma.getmask(y)) # m =
+  array([True,False,False,True])
+  result = (d1/d2).view(MaskedArray) # masked_array([-1. inf, 3., 2.])
+  result._mask = logical_or(m, dm)
+
+Note that here again the division by zero takes place.
+
+A quick benchmark gives the following results:
+
+ * *numpy.ma.divide*  : 2.69 ms per loop
+ * classical division     : 2.21 ms per loop
+ * division w/ prefilling : 2.34 ms per loop
+ * division w/o filling   : 1.55 ms per loop
+
+So, is it worth filling the arrays beforehand ? Yes, if we are interested
+in avoiding floating-point exceptions that may fill the result with infs
+and nans. No, if we are only interested into speed...
+
+
+Thanks
+------
+
+I'd like to thank Paul Dubois, Travis Oliphant and Sasha for the
+original masked array package: without you, I would never have started
+that (it might be argued that I shouldn't have anyway, but that's
+another story...).  I also wish to extend these thanks to Reggie Dugard
+and Eric Firing for their suggestions and numerous improvements.
+
+
+Revision notes
+--------------
+
+  * 08/25/2007 : Creation of this page
+  * 01/23/2007 : The package has been moved to the SciPy sandbox, and is regularly updated: please check out your SVN version!

llava_next/lib/python3.10/site-packages/numpy/ma/__init__.py

@@ -0,0 +1,54 @@
+"""
+=============
+Masked Arrays
+=============
+
+Arrays sometimes contain invalid or missing data.  When doing operations
+on such arrays, we wish to suppress invalid values, which is the purpose masked
+arrays fulfill (an example of typical use is given below).
+
+For example, examine the following array:
+
+>>> x = np.array([2, 1, 3, np.nan, 5, 2, 3, np.nan])
+
+When we try to calculate the mean of the data, the result is undetermined:
+
+>>> np.mean(x)
+nan
+
+The mean is calculated using roughly ``np.sum(x)/len(x)``, but since
+any number added to ``NaN`` [1]_ produces ``NaN``, this doesn't work.  Enter
+masked arrays:
+
+>>> m = np.ma.masked_array(x, np.isnan(x))
+>>> m
+masked_array(data = [2.0 1.0 3.0 -- 5.0 2.0 3.0 --],
+      mask = [False False False  True False False False  True],
+      fill_value=1e+20)
+
+Here, we construct a masked array that suppress all ``NaN`` values.  We
+may now proceed to calculate the mean of the other values:
+
+>>> np.mean(m)
+2.6666666666666665
+
+.. [1] Not-a-Number, a floating point value that is the result of an
+       invalid operation.
+
+.. moduleauthor:: Pierre Gerard-Marchant
+.. moduleauthor:: Jarrod Millman
+
+"""
+from . import core
+from .core import *
+
+from . import extras
+from .extras import *
+
+__all__ = ['core', 'extras']
+__all__ += core.__all__
+__all__ += extras.__all__
+
+from numpy._pytesttester import PytestTester
+test = PytestTester(__name__)
+del PytestTester

llava_next/lib/python3.10/site-packages/numpy/ma/__init__.pyi

@@ -0,0 +1,234 @@
+from numpy._pytesttester import PytestTester
+
+from numpy.ma import extras as extras
+
+from numpy.ma.core import (
+    MAError as MAError,
+    MaskError as MaskError,
+    MaskType as MaskType,
+    MaskedArray as MaskedArray,
+    abs as abs,
+    absolute as absolute,
+    add as add,
+    all as all,
+    allclose as allclose,
+    allequal as allequal,
+    alltrue as alltrue,
+    amax as amax,
+    amin as amin,
+    angle as angle,
+    anom as anom,
+    anomalies as anomalies,
+    any as any,
+    append as append,
+    arange as arange,
+    arccos as arccos,
+    arccosh as arccosh,
+    arcsin as arcsin,
+    arcsinh as arcsinh,
+    arctan as arctan,
+    arctan2 as arctan2,
+    arctanh as arctanh,
+    argmax as argmax,
+    argmin as argmin,
+    argsort as argsort,
+    around as around,
+    array as array,
+    asanyarray as asanyarray,
+    asarray as asarray,
+    bitwise_and as bitwise_and,
+    bitwise_or as bitwise_or,
+    bitwise_xor as bitwise_xor,
+    bool_ as bool_,
+    ceil as ceil,
+    choose as choose,
+    clip as clip,
+    common_fill_value as common_fill_value,
+    compress as compress,
+    compressed as compressed,
+    concatenate as concatenate,
+    conjugate as conjugate,
+    convolve as convolve,
+    copy as copy,
+    correlate as correlate,
+    cos as cos,
+    cosh as cosh,
+    count as count,
+    cumprod as cumprod,
+    cumsum as cumsum,
+    default_fill_value as default_fill_value,
+    diag as diag,
+    diagonal as diagonal,
+    diff as diff,
+    divide as divide,
+    empty as empty,
+    empty_like as empty_like,
+    equal as equal,
+    exp as exp,
+    expand_dims as expand_dims,
+    fabs as fabs,
+    filled as filled,
+    fix_invalid as fix_invalid,
+    flatten_mask as flatten_mask,
+    flatten_structured_array as flatten_structured_array,
+    floor as floor,
+    floor_divide as floor_divide,
+    fmod as fmod,
+    frombuffer as frombuffer,
+    fromflex as fromflex,
+    fromfunction as fromfunction,
+    getdata as getdata,
+    getmask as getmask,
+    getmaskarray as getmaskarray,
+    greater as greater,
+    greater_equal as greater_equal,
+    harden_mask as harden_mask,
+    hypot as hypot,
+    identity as identity,
+    ids as ids,
+    indices as indices,
+    inner as inner,
+    innerproduct as innerproduct,
+    isMA as isMA,
+    isMaskedArray as isMaskedArray,
+    is_mask as is_mask,
+    is_masked as is_masked,
+    isarray as isarray,
+    left_shift as left_shift,
+    less as less,
+    less_equal as less_equal,
+    log as log,
+    log10 as log10,
+    log2 as log2,
+    logical_and as logical_and,
+    logical_not as logical_not,
+    logical_or as logical_or,
+    logical_xor as logical_xor,
+    make_mask as make_mask,
+    make_mask_descr as make_mask_descr,
+    make_mask_none as make_mask_none,
+    mask_or as mask_or,
+    masked as masked,
+    masked_array as masked_array,
+    masked_equal as masked_equal,
+    masked_greater as masked_greater,
+    masked_greater_equal as masked_greater_equal,
+    masked_inside as masked_inside,
+    masked_invalid as masked_invalid,
+    masked_less as masked_less,
+    masked_less_equal as masked_less_equal,
+    masked_not_equal as masked_not_equal,
+    masked_object as masked_object,
+    masked_outside as masked_outside,
+    masked_print_option as masked_print_option,
+    masked_singleton as masked_singleton,
+    masked_values as masked_values,
+    masked_where as masked_where,
+    max as max,
+    maximum as maximum,
+    maximum_fill_value as maximum_fill_value,
+    mean as mean,
+    min as min,
+    minimum as minimum,
+    minimum_fill_value as minimum_fill_value,
+    mod as mod,
+    multiply as multiply,
+    mvoid as mvoid,
+    ndim as ndim,
+    negative as negative,
+    nomask as nomask,
+    nonzero as nonzero,
+    not_equal as not_equal,
+    ones as ones,
+    outer as outer,
+    outerproduct as outerproduct,
+    power as power,
+    prod as prod,
+    product as product,
+    ptp as ptp,
+    put as put,
+    putmask as putmask,
+    ravel as ravel,
+    remainder as remainder,
+    repeat as repeat,
+    reshape as reshape,
+    resize as resize,
+    right_shift as right_shift,
+    round as round,
+    set_fill_value as set_fill_value,
+    shape as shape,
+    sin as sin,
+    sinh as sinh,
+    size as size,
+    soften_mask as soften_mask,
+    sometrue as sometrue,
+    sort as sort,
+    sqrt as sqrt,
+    squeeze as squeeze,
+    std as std,
+    subtract as subtract,
+    sum as sum,
+    swapaxes as swapaxes,
+    take as take,
+    tan as tan,
+    tanh as tanh,
+    trace as trace,
+    transpose as transpose,
+    true_divide as true_divide,
+    var as var,
+    where as where,
+    zeros as zeros,
+)
+
+from numpy.ma.extras import (
+    apply_along_axis as apply_along_axis,
+    apply_over_axes as apply_over_axes,
+    atleast_1d as atleast_1d,
+    atleast_2d as atleast_2d,
+    atleast_3d as atleast_3d,
+    average as average,
+    clump_masked as clump_masked,
+    clump_unmasked as clump_unmasked,
+    column_stack as column_stack,
+    compress_cols as compress_cols,
+    compress_nd as compress_nd,
+    compress_rowcols as compress_rowcols,
+    compress_rows as compress_rows,
+    count_masked as count_masked,
+    corrcoef as corrcoef,
+    cov as cov,
+    diagflat as diagflat,
+    dot as dot,
+    dstack as dstack,
+    ediff1d as ediff1d,
+    flatnotmasked_contiguous as flatnotmasked_contiguous,
+    flatnotmasked_edges as flatnotmasked_edges,
+    hsplit as hsplit,
+    hstack as hstack,
+    isin as isin,
+    in1d as in1d,
+    intersect1d as intersect1d,
+    mask_cols as mask_cols,
+    mask_rowcols as mask_rowcols,
+    mask_rows as mask_rows,
+    masked_all as masked_all,
+    masked_all_like as masked_all_like,
+    median as median,
+    mr_ as mr_,
+    ndenumerate as ndenumerate,
+    notmasked_contiguous as notmasked_contiguous,
+    notmasked_edges as notmasked_edges,
+    polyfit as polyfit,
+    row_stack as row_stack,
+    setdiff1d as setdiff1d,
+    setxor1d as setxor1d,
+    stack as stack,
+    unique as unique,
+    union1d as union1d,
+    vander as vander,
+    vstack as vstack,
+)
+
+__all__: list[str]
+__path__: list[str]
+test: PytestTester

llava_next/lib/python3.10/site-packages/numpy/ma/core.pyi

@@ -0,0 +1,471 @@
+from collections.abc import Callable
+from typing import Any, TypeVar
+from numpy import ndarray, dtype, float64
+
+from numpy import (
+    amax as amax,
+    amin as amin,
+    bool_ as bool_,
+    expand_dims as expand_dims,
+    clip as clip,
+    indices as indices,
+    ones_like as ones_like,
+    squeeze as squeeze,
+    zeros_like as zeros_like,
+)
+
+from numpy.lib.function_base import (
+    angle as angle,
+)
+
+# TODO: Set the `bound` to something more suitable once we
+# have proper shape support
+_ShapeType = TypeVar("_ShapeType", bound=Any)
+_DType_co = TypeVar("_DType_co", bound=dtype[Any], covariant=True)
+
+__all__: list[str]
+
+MaskType = bool_
+nomask: bool_
+
+class MaskedArrayFutureWarning(FutureWarning): ...
+class MAError(Exception): ...
+class MaskError(MAError): ...
+
+def default_fill_value(obj): ...
+def minimum_fill_value(obj): ...
+def maximum_fill_value(obj): ...
+def set_fill_value(a, fill_value): ...
+def common_fill_value(a, b): ...
+def filled(a, fill_value=...): ...
+def getdata(a, subok=...): ...
+get_data = getdata
+
+def fix_invalid(a, mask=..., copy=..., fill_value=...): ...
+
+class _MaskedUFunc:
+    f: Any
+    __doc__: Any
+    __name__: Any
+    def __init__(self, ufunc): ...
+
+class _MaskedUnaryOperation(_MaskedUFunc):
+    fill: Any
+    domain: Any
+    def __init__(self, mufunc, fill=..., domain=...): ...
+    def __call__(self, a, *args, **kwargs): ...
+
+class _MaskedBinaryOperation(_MaskedUFunc):
+    fillx: Any
+    filly: Any
+    def __init__(self, mbfunc, fillx=..., filly=...): ...
+    def __call__(self, a, b, *args, **kwargs): ...
+    def reduce(self, target, axis=..., dtype=...): ...
+    def outer(self, a, b): ...
+    def accumulate(self, target, axis=...): ...
+
+class _DomainedBinaryOperation(_MaskedUFunc):
+    domain: Any
+    fillx: Any
+    filly: Any
+    def __init__(self, dbfunc, domain, fillx=..., filly=...): ...
+    def __call__(self, a, b, *args, **kwargs): ...
+
+exp: _MaskedUnaryOperation
+conjugate: _MaskedUnaryOperation
+sin: _MaskedUnaryOperation
+cos: _MaskedUnaryOperation
+arctan: _MaskedUnaryOperation
+arcsinh: _MaskedUnaryOperation
+sinh: _MaskedUnaryOperation
+cosh: _MaskedUnaryOperation
+tanh: _MaskedUnaryOperation
+abs: _MaskedUnaryOperation
+absolute: _MaskedUnaryOperation
+fabs: _MaskedUnaryOperation
+negative: _MaskedUnaryOperation
+floor: _MaskedUnaryOperation
+ceil: _MaskedUnaryOperation
+around: _MaskedUnaryOperation
+logical_not: _MaskedUnaryOperation
+sqrt: _MaskedUnaryOperation
+log: _MaskedUnaryOperation
+log2: _MaskedUnaryOperation
+log10: _MaskedUnaryOperation
+tan: _MaskedUnaryOperation
+arcsin: _MaskedUnaryOperation
+arccos: _MaskedUnaryOperation
+arccosh: _MaskedUnaryOperation
+arctanh: _MaskedUnaryOperation
+
+add: _MaskedBinaryOperation
+subtract: _MaskedBinaryOperation
+multiply: _MaskedBinaryOperation
+arctan2: _MaskedBinaryOperation
+equal: _MaskedBinaryOperation
+not_equal: _MaskedBinaryOperation
+less_equal: _MaskedBinaryOperation
+greater_equal: _MaskedBinaryOperation
+less: _MaskedBinaryOperation
+greater: _MaskedBinaryOperation
+logical_and: _MaskedBinaryOperation
+alltrue: _MaskedBinaryOperation
+logical_or: _MaskedBinaryOperation
+sometrue: Callable[..., Any]
+logical_xor: _MaskedBinaryOperation
+bitwise_and: _MaskedBinaryOperation
+bitwise_or: _MaskedBinaryOperation
+bitwise_xor: _MaskedBinaryOperation
+hypot: _MaskedBinaryOperation
+divide: _MaskedBinaryOperation
+true_divide: _MaskedBinaryOperation
+floor_divide: _MaskedBinaryOperation
+remainder: _MaskedBinaryOperation
+fmod: _MaskedBinaryOperation
+mod: _MaskedBinaryOperation
+
+def make_mask_descr(ndtype): ...
+def getmask(a): ...
+get_mask = getmask
+
+def getmaskarray(arr): ...
+def is_mask(m): ...
+def make_mask(m, copy=..., shrink=..., dtype=...): ...
+def make_mask_none(newshape, dtype=...): ...
+def mask_or(m1, m2, copy=..., shrink=...): ...
+def flatten_mask(mask): ...
+def masked_where(condition, a, copy=...): ...
+def masked_greater(x, value, copy=...): ...
+def masked_greater_equal(x, value, copy=...): ...
+def masked_less(x, value, copy=...): ...
+def masked_less_equal(x, value, copy=...): ...
+def masked_not_equal(x, value, copy=...): ...
+def masked_equal(x, value, copy=...): ...
+def masked_inside(x, v1, v2, copy=...): ...
+def masked_outside(x, v1, v2, copy=...): ...
+def masked_object(x, value, copy=..., shrink=...): ...
+def masked_values(x, value, rtol=..., atol=..., copy=..., shrink=...): ...
+def masked_invalid(a, copy=...): ...
+
+class _MaskedPrintOption:
+    def __init__(self, display): ...
+    def display(self): ...
+    def set_display(self, s): ...
+    def enabled(self): ...
+    def enable(self, shrink=...): ...
+
+masked_print_option: _MaskedPrintOption
+
+def flatten_structured_array(a): ...
+
+class MaskedIterator:
+    ma: Any
+    dataiter: Any
+    maskiter: Any
+    def __init__(self, ma): ...
+    def __iter__(self): ...
+    def __getitem__(self, indx): ...
+    def __setitem__(self, index, value): ...
+    def __next__(self): ...
+
+class MaskedArray(ndarray[_ShapeType, _DType_co]):
+    __array_priority__: Any
+    def __new__(cls, data=..., mask=..., dtype=..., copy=..., subok=..., ndmin=..., fill_value=..., keep_mask=..., hard_mask=..., shrink=..., order=...): ...
+    def __array_finalize__(self, obj): ...
+    def __array_wrap__(self, obj, context=...): ...
+    def view(self, dtype=..., type=..., fill_value=...): ...
+    def __getitem__(self, indx): ...
+    def __setitem__(self, indx, value): ...
+    @property
+    def dtype(self): ...
+    @dtype.setter
+    def dtype(self, dtype): ...
+    @property
+    def shape(self): ...
+    @shape.setter
+    def shape(self, shape): ...
+    def __setmask__(self, mask, copy=...): ...
+    @property
+    def mask(self): ...
+    @mask.setter
+    def mask(self, value): ...
+    @property
+    def recordmask(self): ...
+    @recordmask.setter
+    def recordmask(self, mask): ...
+    def harden_mask(self): ...
+    def soften_mask(self): ...
+    @property
+    def hardmask(self): ...
+    def unshare_mask(self): ...
+    @property
+    def sharedmask(self): ...
+    def shrink_mask(self): ...
+    @property
+    def baseclass(self): ...
+    data: Any
+    @property
+    def flat(self): ...
+    @flat.setter
+    def flat(self, value): ...
+    @property
+    def fill_value(self): ...
+    @fill_value.setter
+    def fill_value(self, value=...): ...
+    get_fill_value: Any
+    set_fill_value: Any
+    def filled(self, fill_value=...): ...
+    def compressed(self): ...
+    def compress(self, condition, axis=..., out=...): ...
+    def __eq__(self, other): ...
+    def __ne__(self, other): ...
+    def __ge__(self, other): ...
+    def __gt__(self, other): ...
+    def __le__(self, other): ...
+    def __lt__(self, other): ...
+    def __add__(self, other): ...
+    def __radd__(self, other): ...
+    def __sub__(self, other): ...
+    def __rsub__(self, other): ...
+    def __mul__(self, other): ...
+    def __rmul__(self, other): ...
+    def __div__(self, other): ...
+    def __truediv__(self, other): ...
+    def __rtruediv__(self, other): ...
+    def __floordiv__(self, other): ...
+    def __rfloordiv__(self, other): ...
+    def __pow__(self, other): ...
+    def __rpow__(self, other): ...
+    def __iadd__(self, other): ...
+    def __isub__(self, other): ...
+    def __imul__(self, other): ...
+    def __idiv__(self, other): ...
+    def __ifloordiv__(self, other): ...
+    def __itruediv__(self, other): ...
+    def __ipow__(self, other): ...
+    def __float__(self): ...
+    def __int__(self): ...
+    @property  # type: ignore[misc]
+    def imag(self): ...
+    get_imag: Any
+    @property  # type: ignore[misc]
+    def real(self): ...
+    get_real: Any
+    def count(self, axis=..., keepdims=...): ...
+    def ravel(self, order=...): ...
+    def reshape(self, *s, **kwargs): ...
+    def resize(self, newshape, refcheck=..., order=...): ...
+    def put(self, indices, values, mode=...): ...
+    def ids(self): ...
+    def iscontiguous(self): ...
+    def all(self, axis=..., out=..., keepdims=...): ...
+    def any(self, axis=..., out=..., keepdims=...): ...
+    def nonzero(self): ...
+    def trace(self, offset=..., axis1=..., axis2=..., dtype=..., out=...): ...
+    def dot(self, b, out=..., strict=...): ...
+    def sum(self, axis=..., dtype=..., out=..., keepdims=...): ...
+    def cumsum(self, axis=..., dtype=..., out=...): ...
+    def prod(self, axis=..., dtype=..., out=..., keepdims=...): ...
+    product: Any
+    def cumprod(self, axis=..., dtype=..., out=...): ...
+    def mean(self, axis=..., dtype=..., out=..., keepdims=...): ...
+    def anom(self, axis=..., dtype=...): ...
+    def var(self, axis=..., dtype=..., out=..., ddof=..., keepdims=...): ...
+    def std(self, axis=..., dtype=..., out=..., ddof=..., keepdims=...): ...
+    def round(self, decimals=..., out=...): ...
+    def argsort(self, axis=..., kind=..., order=..., endwith=..., fill_value=...): ...
+    def argmin(self, axis=..., fill_value=..., out=..., *, keepdims=...): ...
+    def argmax(self, axis=..., fill_value=..., out=..., *, keepdims=...): ...
+    def sort(self, axis=..., kind=..., order=..., endwith=..., fill_value=...): ...
+    def min(self, axis=..., out=..., fill_value=..., keepdims=...): ...
+    # NOTE: deprecated
+    # def tostring(self, fill_value=..., order=...): ...
+    def max(self, axis=..., out=..., fill_value=..., keepdims=...): ...
+    def ptp(self, axis=..., out=..., fill_value=..., keepdims=...): ...
+    def partition(self, *args, **kwargs): ...
+    def argpartition(self, *args, **kwargs): ...
+    def take(self, indices, axis=..., out=..., mode=...): ...
+    copy: Any
+    diagonal: Any
+    flatten: Any
+    repeat: Any
+    squeeze: Any
+    swapaxes: Any
+    T: Any
+    transpose: Any
+    def tolist(self, fill_value=...): ...
+    def tobytes(self, fill_value=..., order=...): ...
+    def tofile(self, fid, sep=..., format=...): ...
+    def toflex(self): ...
+    torecords: Any
+    def __reduce__(self): ...
+    def __deepcopy__(self, memo=...): ...
+
+class mvoid(MaskedArray[_ShapeType, _DType_co]):
+    def __new__(
+        self,
+        data,
+        mask=...,
+        dtype=...,
+        fill_value=...,
+        hardmask=...,
+        copy=...,
+        subok=...,
+    ): ...
+    def __getitem__(self, indx): ...
+    def __setitem__(self, indx, value): ...
+    def __iter__(self): ...
+    def __len__(self): ...
+    def filled(self, fill_value=...): ...
+    def tolist(self): ...
+
+def isMaskedArray(x): ...
+isarray = isMaskedArray
+isMA = isMaskedArray
+
+# 0D float64 array
+class MaskedConstant(MaskedArray[Any, dtype[float64]]):
+    def __new__(cls): ...
+    __class__: Any
+    def __array_finalize__(self, obj): ...
+    def __array_prepare__(self, obj, context=...): ...
+    def __array_wrap__(self, obj, context=...): ...
+    def __format__(self, format_spec): ...
+    def __reduce__(self): ...
+    def __iop__(self, other): ...
+    __iadd__: Any
+    __isub__: Any
+    __imul__: Any
+    __ifloordiv__: Any
+    __itruediv__: Any
+    __ipow__: Any
+    def copy(self, *args, **kwargs): ...
+    def __copy__(self): ...
+    def __deepcopy__(self, memo): ...
+    def __setattr__(self, attr, value): ...
+
+masked: MaskedConstant
+masked_singleton: MaskedConstant
+masked_array = MaskedArray
+
+def array(
+    data,
+    dtype=...,
+    copy=...,
+    order=...,
+    mask=...,
+    fill_value=...,
+    keep_mask=...,
+    hard_mask=...,
+    shrink=...,
+    subok=...,
+    ndmin=...,
+): ...
+def is_masked(x): ...
+
+class _extrema_operation(_MaskedUFunc):
+    compare: Any
+    fill_value_func: Any
+    def __init__(self, ufunc, compare, fill_value): ...
+    # NOTE: in practice `b` has a default value, but users should
+    # explicitly provide a value here as the default is deprecated
+    def __call__(self, a, b): ...
+    def reduce(self, target, axis=...): ...
+    def outer(self, a, b): ...
+
+def min(obj, axis=..., out=..., fill_value=..., keepdims=...): ...
+def max(obj, axis=..., out=..., fill_value=..., keepdims=...): ...
+def ptp(obj, axis=..., out=..., fill_value=..., keepdims=...): ...
+
+class _frommethod:
+    __name__: Any
+    __doc__: Any
+    reversed: Any
+    def __init__(self, methodname, reversed=...): ...
+    def getdoc(self): ...
+    def __call__(self, a, *args, **params): ...
+
+all: _frommethod
+anomalies: _frommethod
+anom: _frommethod
+any: _frommethod
+compress: _frommethod
+cumprod: _frommethod
+cumsum: _frommethod
+copy: _frommethod
+diagonal: _frommethod
+harden_mask: _frommethod
+ids: _frommethod
+mean: _frommethod
+nonzero: _frommethod
+prod: _frommethod
+product: _frommethod
+ravel: _frommethod
+repeat: _frommethod
+soften_mask: _frommethod
+std: _frommethod
+sum: _frommethod
+swapaxes: _frommethod
+trace: _frommethod
+var: _frommethod
+count: _frommethod
+argmin: _frommethod
+argmax: _frommethod
+
+minimum: _extrema_operation
+maximum: _extrema_operation
+
+def take(a, indices, axis=..., out=..., mode=...): ...
+def power(a, b, third=...): ...
+def argsort(a, axis=..., kind=..., order=..., endwith=..., fill_value=...): ...
+def sort(a, axis=..., kind=..., order=..., endwith=..., fill_value=...): ...
+def compressed(x): ...
+def concatenate(arrays, axis=...): ...
+def diag(v, k=...): ...
+def left_shift(a, n): ...
+def right_shift(a, n): ...
+def put(a, indices, values, mode=...): ...
+def putmask(a, mask, values): ...
+def transpose(a, axes=...): ...
+def reshape(a, new_shape, order=...): ...
+def resize(x, new_shape): ...
+def ndim(obj): ...
+def shape(obj): ...
+def size(obj, axis=...): ...
+def diff(a, /, n=..., axis=..., prepend=..., append=...): ...
+def where(condition, x=..., y=...): ...
+def choose(indices, choices, out=..., mode=...): ...
+def round(a, decimals=..., out=...): ...
+
+def inner(a, b): ...
+innerproduct = inner
+
+def outer(a, b): ...
+outerproduct = outer
+
+def correlate(a, v, mode=..., propagate_mask=...): ...
+def convolve(a, v, mode=..., propagate_mask=...): ...
+def allequal(a, b, fill_value=...): ...
+def allclose(a, b, masked_equal=..., rtol=..., atol=...): ...
+def asarray(a, dtype=..., order=...): ...
+def asanyarray(a, dtype=...): ...
+def fromflex(fxarray): ...
+
+class _convert2ma:
+    __doc__: Any
+    def __init__(self, funcname, params=...): ...
+    def getdoc(self): ...
+    def __call__(self, *args, **params): ...
+
+arange: _convert2ma
+empty: _convert2ma
+empty_like: _convert2ma
+frombuffer: _convert2ma
+fromfunction: _convert2ma
+identity: _convert2ma
+ones: _convert2ma
+zeros: _convert2ma
+
+def append(a, b, axis=...): ...
+def dot(a, b, strict=..., out=...): ...
+def mask_rowcols(a, axis=...): ...

llava_next/lib/python3.10/site-packages/numpy/ma/extras.py

@@ -0,0 +1,2133 @@
+"""
+Masked arrays add-ons.
+
+A collection of utilities for `numpy.ma`.
+
+:author: Pierre Gerard-Marchant
+:contact: pierregm_at_uga_dot_edu
+:version: $Id: extras.py 3473 2007-10-29 15:18:13Z jarrod.millman $
+
+"""
+__all__ = [
+    'apply_along_axis', 'apply_over_axes', 'atleast_1d', 'atleast_2d',
+    'atleast_3d', 'average', 'clump_masked', 'clump_unmasked', 'column_stack',
+    'compress_cols', 'compress_nd', 'compress_rowcols', 'compress_rows',
+    'count_masked', 'corrcoef', 'cov', 'diagflat', 'dot', 'dstack', 'ediff1d',
+    'flatnotmasked_contiguous', 'flatnotmasked_edges', 'hsplit', 'hstack',
+    'isin', 'in1d', 'intersect1d', 'mask_cols', 'mask_rowcols', 'mask_rows',
+    'masked_all', 'masked_all_like', 'median', 'mr_', 'ndenumerate',
+    'notmasked_contiguous', 'notmasked_edges', 'polyfit', 'row_stack',
+    'setdiff1d', 'setxor1d', 'stack', 'unique', 'union1d', 'vander', 'vstack',
+    ]
+
+import itertools
+import warnings
+
+from . import core as ma
+from .core import (
+    MaskedArray, MAError, add, array, asarray, concatenate, filled, count,
+    getmask, getmaskarray, make_mask_descr, masked, masked_array, mask_or,
+    nomask, ones, sort, zeros, getdata, get_masked_subclass, dot
+    )
+
+import numpy as np
+from numpy import ndarray, array as nxarray
+from numpy.core.multiarray import normalize_axis_index
+from numpy.core.numeric import normalize_axis_tuple
+from numpy.lib.function_base import _ureduce
+from numpy.lib.index_tricks import AxisConcatenator
+
+
+def issequence(seq):
+    """
+    Is seq a sequence (ndarray, list or tuple)?
+
+    """
+    return isinstance(seq, (ndarray, tuple, list))
+
+
+def count_masked(arr, axis=None):
+    """
+    Count the number of masked elements along the given axis.
+
+    Parameters
+    ----------
+    arr : array_like
+        An array with (possibly) masked elements.
+    axis : int, optional
+        Axis along which to count. If None (default), a flattened
+        version of the array is used.
+
+    Returns
+    -------
+    count : int, ndarray
+        The total number of masked elements (axis=None) or the number
+        of masked elements along each slice of the given axis.
+
+    See Also
+    --------
+    MaskedArray.count : Count non-masked elements.
+
+    Examples
+    --------
+    >>> import numpy.ma as ma
+    >>> a = np.arange(9).reshape((3,3))
+    >>> a = ma.array(a)
+    >>> a[1, 0] = ma.masked
+    >>> a[1, 2] = ma.masked
+    >>> a[2, 1] = ma.masked
+    >>> a
+    masked_array(
+      data=[[0, 1, 2],
+            [--, 4, --],
+            [6, --, 8]],
+      mask=[[False, False, False],
+            [ True, False,  True],
+            [False,  True, False]],
+      fill_value=999999)
+    >>> ma.count_masked(a)
+    3
+
+    When the `axis` keyword is used an array is returned.
+
+    >>> ma.count_masked(a, axis=0)
+    array([1, 1, 1])
+    >>> ma.count_masked(a, axis=1)
+    array([0, 2, 1])
+
+    """
+    m = getmaskarray(arr)
+    return m.sum(axis)
+
+
+def masked_all(shape, dtype=float):
+    """
+    Empty masked array with all elements masked.
+
+    Return an empty masked array of the given shape and dtype, where all the
+    data are masked.
+
+    Parameters
+    ----------
+    shape : int or tuple of ints
+        Shape of the required MaskedArray, e.g., ``(2, 3)`` or ``2``.
+    dtype : dtype, optional
+        Data type of the output.
+
+    Returns
+    -------
+    a : MaskedArray
+        A masked array with all data masked.
+
+    See Also
+    --------
+    masked_all_like : Empty masked array modelled on an existing array.
+
+    Examples
+    --------
+    >>> import numpy.ma as ma
+    >>> ma.masked_all((3, 3))
+    masked_array(
+      data=[[--, --, --],
+            [--, --, --],
+            [--, --, --]],
+      mask=[[ True,  True,  True],
+            [ True,  True,  True],
+            [ True,  True,  True]],
+      fill_value=1e+20,
+      dtype=float64)
+
+    The `dtype` parameter defines the underlying data type.
+
+    >>> a = ma.masked_all((3, 3))
+    >>> a.dtype
+    dtype('float64')
+    >>> a = ma.masked_all((3, 3), dtype=np.int32)
+    >>> a.dtype
+    dtype('int32')
+
+    """
+    a = masked_array(np.empty(shape, dtype),
+                     mask=np.ones(shape, make_mask_descr(dtype)))
+    return a
+
+
+def masked_all_like(arr):
+    """
+    Empty masked array with the properties of an existing array.
+
+    Return an empty masked array of the same shape and dtype as
+    the array `arr`, where all the data are masked.
+
+    Parameters
+    ----------
+    arr : ndarray
+        An array describing the shape and dtype of the required MaskedArray.
+
+    Returns
+    -------
+    a : MaskedArray
+        A masked array with all data masked.
+
+    Raises
+    ------
+    AttributeError
+        If `arr` doesn't have a shape attribute (i.e. not an ndarray)
+
+    See Also
+    --------
+    masked_all : Empty masked array with all elements masked.
+
+    Examples
+    --------
+    >>> import numpy.ma as ma
+    >>> arr = np.zeros((2, 3), dtype=np.float32)
+    >>> arr
+    array([[0., 0., 0.],
+           [0., 0., 0.]], dtype=float32)
+    >>> ma.masked_all_like(arr)
+    masked_array(
+      data=[[--, --, --],
+            [--, --, --]],
+      mask=[[ True,  True,  True],
+            [ True,  True,  True]],
+      fill_value=1e+20,
+      dtype=float32)
+
+    The dtype of the masked array matches the dtype of `arr`.
+
+    >>> arr.dtype
+    dtype('float32')
+    >>> ma.masked_all_like(arr).dtype
+    dtype('float32')
+
+    """
+    a = np.empty_like(arr).view(MaskedArray)
+    a._mask = np.ones(a.shape, dtype=make_mask_descr(a.dtype))
+    return a
+
+
+#####--------------------------------------------------------------------------
+#---- --- Standard functions ---
+#####--------------------------------------------------------------------------
+class _fromnxfunction:
+    """
+    Defines a wrapper to adapt NumPy functions to masked arrays.
+
+
+    An instance of `_fromnxfunction` can be called with the same parameters
+    as the wrapped NumPy function. The docstring of `newfunc` is adapted from
+    the wrapped function as well, see `getdoc`.
+
+    This class should not be used directly. Instead, one of its extensions that
+    provides support for a specific type of input should be used.
+
+    Parameters
+    ----------
+    funcname : str
+        The name of the function to be adapted. The function should be
+        in the NumPy namespace (i.e. ``np.funcname``).
+
+    """
+
+    def __init__(self, funcname):
+        self.__name__ = funcname
+        self.__doc__ = self.getdoc()
+
+    def getdoc(self):
+        """
+        Retrieve the docstring and signature from the function.
+
+        The ``__doc__`` attribute of the function is used as the docstring for
+        the new masked array version of the function. A note on application
+        of the function to the mask is appended.
+
+        Parameters
+        ----------
+        None
+
+        """
+        npfunc = getattr(np, self.__name__, None)
+        doc = getattr(npfunc, '__doc__', None)
+        if doc:
+            sig = self.__name__ + ma.get_object_signature(npfunc)
+            doc = ma.doc_note(doc, "The function is applied to both the _data "
+                                   "and the _mask, if any.")
+            return '\n\n'.join((sig, doc))
+        return
+
+    def __call__(self, *args, **params):
+        pass
+
+
+class _fromnxfunction_single(_fromnxfunction):
+    """
+    A version of `_fromnxfunction` that is called with a single array
+    argument followed by auxiliary args that are passed verbatim for
+    both the data and mask calls.
+    """
+    def __call__(self, x, *args, **params):
+        func = getattr(np, self.__name__)
+        if isinstance(x, ndarray):
+            _d = func(x.__array__(), *args, **params)
+            _m = func(getmaskarray(x), *args, **params)
+            return masked_array(_d, mask=_m)
+        else:
+            _d = func(np.asarray(x), *args, **params)
+            _m = func(getmaskarray(x), *args, **params)
+            return masked_array(_d, mask=_m)
+
+
+class _fromnxfunction_seq(_fromnxfunction):
+    """
+    A version of `_fromnxfunction` that is called with a single sequence
+    of arrays followed by auxiliary args that are passed verbatim for
+    both the data and mask calls.
+    """
+    def __call__(self, x, *args, **params):
+        func = getattr(np, self.__name__)
+        _d = func(tuple([np.asarray(a) for a in x]), *args, **params)
+        _m = func(tuple([getmaskarray(a) for a in x]), *args, **params)
+        return masked_array(_d, mask=_m)
+
+
+class _fromnxfunction_args(_fromnxfunction):
+    """
+    A version of `_fromnxfunction` that is called with multiple array
+    arguments. The first non-array-like input marks the beginning of the
+    arguments that are passed verbatim for both the data and mask calls.
+    Array arguments are processed independently and the results are
+    returned in a list. If only one array is found, the return value is
+    just the processed array instead of a list.
+    """
+    def __call__(self, *args, **params):
+        func = getattr(np, self.__name__)
+        arrays = []
+        args = list(args)
+        while len(args) > 0 and issequence(args[0]):
+            arrays.append(args.pop(0))
+        res = []
+        for x in arrays:
+            _d = func(np.asarray(x), *args, **params)
+            _m = func(getmaskarray(x), *args, **params)
+            res.append(masked_array(_d, mask=_m))
+        if len(arrays) == 1:
+            return res[0]
+        return res
+
+
+class _fromnxfunction_allargs(_fromnxfunction):
+    """
+    A version of `_fromnxfunction` that is called with multiple array
+    arguments. Similar to `_fromnxfunction_args` except that all args
+    are converted to arrays even if they are not so already. This makes
+    it possible to process scalars as 1-D arrays. Only keyword arguments
+    are passed through verbatim for the data and mask calls. Arrays
+    arguments are processed independently and the results are returned
+    in a list. If only one arg is present, the return value is just the
+    processed array instead of a list.
+    """
+    def __call__(self, *args, **params):
+        func = getattr(np, self.__name__)
+        res = []
+        for x in args:
+            _d = func(np.asarray(x), **params)
+            _m = func(getmaskarray(x), **params)
+            res.append(masked_array(_d, mask=_m))
+        if len(args) == 1:
+            return res[0]
+        return res
+
+
+atleast_1d = _fromnxfunction_allargs('atleast_1d')
+atleast_2d = _fromnxfunction_allargs('atleast_2d')
+atleast_3d = _fromnxfunction_allargs('atleast_3d')
+
+vstack = row_stack = _fromnxfunction_seq('vstack')
+hstack = _fromnxfunction_seq('hstack')
+column_stack = _fromnxfunction_seq('column_stack')
+dstack = _fromnxfunction_seq('dstack')
+stack = _fromnxfunction_seq('stack')
+
+hsplit = _fromnxfunction_single('hsplit')
+
+diagflat = _fromnxfunction_single('diagflat')
+
+
+#####--------------------------------------------------------------------------
+#----
+#####--------------------------------------------------------------------------
+def flatten_inplace(seq):
+    """Flatten a sequence in place."""
+    k = 0
+    while (k != len(seq)):
+        while hasattr(seq[k], '__iter__'):
+            seq[k:(k + 1)] = seq[k]
+        k += 1
+    return seq
+
+
+def apply_along_axis(func1d, axis, arr, *args, **kwargs):
+    """
+    (This docstring should be overwritten)
+    """
+    arr = array(arr, copy=False, subok=True)
+    nd = arr.ndim
+    axis = normalize_axis_index(axis, nd)
+    ind = [0] * (nd - 1)
+    i = np.zeros(nd, 'O')
+    indlist = list(range(nd))
+    indlist.remove(axis)
+    i[axis] = slice(None, None)
+    outshape = np.asarray(arr.shape).take(indlist)
+    i.put(indlist, ind)
+    res = func1d(arr[tuple(i.tolist())], *args, **kwargs)
+    #  if res is a number, then we have a smaller output array
+    asscalar = np.isscalar(res)
+    if not asscalar:
+        try:
+            len(res)
+        except TypeError:
+            asscalar = True
+    # Note: we shouldn't set the dtype of the output from the first result
+    # so we force the type to object, and build a list of dtypes.  We'll
+    # just take the largest, to avoid some downcasting
+    dtypes = []
+    if asscalar:
+        dtypes.append(np.asarray(res).dtype)
+        outarr = zeros(outshape, object)
+        outarr[tuple(ind)] = res
+        Ntot = np.prod(outshape)
+        k = 1
+        while k < Ntot:
+            # increment the index
+            ind[-1] += 1
+            n = -1
+            while (ind[n] >= outshape[n]) and (n > (1 - nd)):
+                ind[n - 1] += 1
+                ind[n] = 0
+                n -= 1
+            i.put(indlist, ind)
+            res = func1d(arr[tuple(i.tolist())], *args, **kwargs)
+            outarr[tuple(ind)] = res
+            dtypes.append(asarray(res).dtype)
+            k += 1
+    else:
+        res = array(res, copy=False, subok=True)
+        j = i.copy()
+        j[axis] = ([slice(None, None)] * res.ndim)
+        j.put(indlist, ind)
+        Ntot = np.prod(outshape)
+        holdshape = outshape
+        outshape = list(arr.shape)
+        outshape[axis] = res.shape
+        dtypes.append(asarray(res).dtype)
+        outshape = flatten_inplace(outshape)
+        outarr = zeros(outshape, object)
+        outarr[tuple(flatten_inplace(j.tolist()))] = res
+        k = 1
+        while k < Ntot:
+            # increment the index
+            ind[-1] += 1
+            n = -1
+            while (ind[n] >= holdshape[n]) and (n > (1 - nd)):
+                ind[n - 1] += 1
+                ind[n] = 0
+                n -= 1
+            i.put(indlist, ind)
+            j.put(indlist, ind)
+            res = func1d(arr[tuple(i.tolist())], *args, **kwargs)
+            outarr[tuple(flatten_inplace(j.tolist()))] = res
+            dtypes.append(asarray(res).dtype)
+            k += 1
+    max_dtypes = np.dtype(np.asarray(dtypes).max())
+    if not hasattr(arr, '_mask'):
+        result = np.asarray(outarr, dtype=max_dtypes)
+    else:
+        result = asarray(outarr, dtype=max_dtypes)
+        result.fill_value = ma.default_fill_value(result)
+    return result
+apply_along_axis.__doc__ = np.apply_along_axis.__doc__
+
+
+def apply_over_axes(func, a, axes):
+    """
+    (This docstring will be overwritten)
+    """
+    val = asarray(a)
+    N = a.ndim
+    if array(axes).ndim == 0:
+        axes = (axes,)
+    for axis in axes:
+        if axis < 0:
+            axis = N + axis
+        args = (val, axis)
+        res = func(*args)
+        if res.ndim == val.ndim:
+            val = res
+        else:
+            res = ma.expand_dims(res, axis)
+            if res.ndim == val.ndim:
+                val = res
+            else:
+                raise ValueError("function is not returning "
+                        "an array of the correct shape")
+    return val
+
+
+if apply_over_axes.__doc__ is not None:
+    apply_over_axes.__doc__ = np.apply_over_axes.__doc__[
+        :np.apply_over_axes.__doc__.find('Notes')].rstrip() + \
+    """
+
+    Examples
+    --------
+    >>> a = np.ma.arange(24).reshape(2,3,4)
+    >>> a[:,0,1] = np.ma.masked
+    >>> a[:,1,:] = np.ma.masked
+    >>> a
+    masked_array(
+      data=[[[0, --, 2, 3],
+             [--, --, --, --],
+             [8, 9, 10, 11]],
+            [[12, --, 14, 15],
+             [--, --, --, --],
+             [20, 21, 22, 23]]],
+      mask=[[[False,  True, False, False],
+             [ True,  True,  True,  True],
+             [False, False, False, False]],
+            [[False,  True, False, False],
+             [ True,  True,  True,  True],
+             [False, False, False, False]]],
+      fill_value=999999)
+    >>> np.ma.apply_over_axes(np.ma.sum, a, [0,2])
+    masked_array(
+      data=[[[46],
+             [--],
+             [124]]],
+      mask=[[[False],
+             [ True],
+             [False]]],
+      fill_value=999999)
+
+    Tuple axis arguments to ufuncs are equivalent:
+
+    >>> np.ma.sum(a, axis=(0,2)).reshape((1,-1,1))
+    masked_array(
+      data=[[[46],
+             [--],
+             [124]]],
+      mask=[[[False],
+             [ True],
+             [False]]],
+      fill_value=999999)
+    """
+
+
+def average(a, axis=None, weights=None, returned=False, *,
+            keepdims=np._NoValue):
+    """
+    Return the weighted average of array over the given axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Data to be averaged.
+        Masked entries are not taken into account in the computation.
+    axis : int, optional
+        Axis along which to average `a`. If None, averaging is done over
+        the flattened array.
+    weights : array_like, optional
+        The importance that each element has in the computation of the average.
+        The weights array can either be 1-D (in which case its length must be
+        the size of `a` along the given axis) or of the same shape as `a`.
+        If ``weights=None``, then all data in `a` are assumed to have a
+        weight equal to one.  The 1-D calculation is::
+
+            avg = sum(a * weights) / sum(weights)
+
+        The only constraint on `weights` is that `sum(weights)` must not be 0.
+    returned : bool, optional
+        Flag indicating whether a tuple ``(result, sum of weights)``
+        should be returned as output (True), or just the result (False).
+        Default is False.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+        *Note:* `keepdims` will not work with instances of `numpy.matrix`
+        or other classes whose methods do not support `keepdims`.
+
+        .. versionadded:: 1.23.0
+
+    Returns
+    -------
+    average, [sum_of_weights] : (tuple of) scalar or MaskedArray
+        The average along the specified axis. When returned is `True`,
+        return a tuple with the average as the first element and the sum
+        of the weights as the second element. The return type is `np.float64`
+        if `a` is of integer type and floats smaller than `float64`, or the
+        input data-type, otherwise. If returned, `sum_of_weights` is always
+        `float64`.
+
+    Examples
+    --------
+    >>> a = np.ma.array([1., 2., 3., 4.], mask=[False, False, True, True])
+    >>> np.ma.average(a, weights=[3, 1, 0, 0])
+    1.25
+
+    >>> x = np.ma.arange(6.).reshape(3, 2)
+    >>> x
+    masked_array(
+      data=[[0., 1.],
+            [2., 3.],
+            [4., 5.]],
+      mask=False,
+      fill_value=1e+20)
+    >>> avg, sumweights = np.ma.average(x, axis=0, weights=[1, 2, 3],
+    ...                                 returned=True)
+    >>> avg
+    masked_array(data=[2.6666666666666665, 3.6666666666666665],
+                 mask=[False, False],
+           fill_value=1e+20)
+
+    With ``keepdims=True``, the following result has shape (3, 1).
+
+    >>> np.ma.average(x, axis=1, keepdims=True)
+    masked_array(
+      data=[[0.5],
+            [2.5],
+            [4.5]],
+      mask=False,
+      fill_value=1e+20)
+    """
+    a = asarray(a)
+    m = getmask(a)
+
+    # inspired by 'average' in numpy/lib/function_base.py
+
+    if keepdims is np._NoValue:
+        # Don't pass on the keepdims argument if one wasn't given.
+        keepdims_kw = {}
+    else:
+        keepdims_kw = {'keepdims': keepdims}
+
+    if weights is None:
+        avg = a.mean(axis, **keepdims_kw)
+        scl = avg.dtype.type(a.count(axis))
+    else:
+        wgt = asarray(weights)
+
+        if issubclass(a.dtype.type, (np.integer, np.bool_)):
+            result_dtype = np.result_type(a.dtype, wgt.dtype, 'f8')
+        else:
+            result_dtype = np.result_type(a.dtype, wgt.dtype)
+
+        # Sanity checks
+        if a.shape != wgt.shape:
+            if axis is None:
+                raise TypeError(
+                    "Axis must be specified when shapes of a and weights "
+                    "differ.")
+            if wgt.ndim != 1:
+                raise TypeError(
+                    "1D weights expected when shapes of a and weights differ.")
+            if wgt.shape[0] != a.shape[axis]:
+                raise ValueError(
+                    "Length of weights not compatible with specified axis.")
+
+            # setup wgt to broadcast along axis
+            wgt = np.broadcast_to(wgt, (a.ndim-1)*(1,) + wgt.shape, subok=True)
+            wgt = wgt.swapaxes(-1, axis)
+
+        if m is not nomask:
+            wgt = wgt*(~a.mask)
+            wgt.mask |= a.mask
+
+        scl = wgt.sum(axis=axis, dtype=result_dtype, **keepdims_kw)
+        avg = np.multiply(a, wgt,
+                          dtype=result_dtype).sum(axis, **keepdims_kw) / scl
+
+    if returned:
+        if scl.shape != avg.shape:
+            scl = np.broadcast_to(scl, avg.shape).copy()
+        return avg, scl
+    else:
+        return avg
+
+
+def median(a, axis=None, out=None, overwrite_input=False, keepdims=False):
+    """
+    Compute the median along the specified axis.
+
+    Returns the median of the array elements.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array.
+    axis : int, optional
+        Axis along which the medians are computed. The default (None) is
+        to compute the median along a flattened version of the array.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output
+        but the type will be cast if necessary.
+    overwrite_input : bool, optional
+        If True, then allow use of memory of input array (a) for
+        calculations. The input array will be modified by the call to
+        median. This will save memory when you do not need to preserve
+        the contents of the input array. Treat the input as undefined,
+        but it will probably be fully or partially sorted. Default is
+        False. Note that, if `overwrite_input` is True, and the input
+        is not already an `ndarray`, an error will be raised.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        .. versionadded:: 1.10.0
+
+    Returns
+    -------
+    median : ndarray
+        A new array holding the result is returned unless out is
+        specified, in which case a reference to out is returned.
+        Return data-type is `float64` for integers and floats smaller than
+        `float64`, or the input data-type, otherwise.
+
+    See Also
+    --------
+    mean
+
+    Notes
+    -----
+    Given a vector ``V`` with ``N`` non masked values, the median of ``V``
+    is the middle value of a sorted copy of ``V`` (``Vs``) - i.e.
+    ``Vs[(N-1)/2]``, when ``N`` is odd, or ``{Vs[N/2 - 1] + Vs[N/2]}/2``
+    when ``N`` is even.
+
+    Examples
+    --------
+    >>> x = np.ma.array(np.arange(8), mask=[0]*4 + [1]*4)
+    >>> np.ma.median(x)
+    1.5
+
+    >>> x = np.ma.array(np.arange(10).reshape(2, 5), mask=[0]*6 + [1]*4)
+    >>> np.ma.median(x)
+    2.5
+    >>> np.ma.median(x, axis=-1, overwrite_input=True)
+    masked_array(data=[2.0, 5.0],
+                 mask=[False, False],
+           fill_value=1e+20)
+
+    """
+    if not hasattr(a, 'mask'):
+        m = np.median(getdata(a, subok=True), axis=axis,
+                      out=out, overwrite_input=overwrite_input,
+                      keepdims=keepdims)
+        if isinstance(m, np.ndarray) and 1 <= m.ndim:
+            return masked_array(m, copy=False)
+        else:
+            return m
+
+    return _ureduce(a, func=_median, keepdims=keepdims, axis=axis, out=out,
+                    overwrite_input=overwrite_input)
+
+
+def _median(a, axis=None, out=None, overwrite_input=False):
+    # when an unmasked NaN is present return it, so we need to sort the NaN
+    # values behind the mask
+    if np.issubdtype(a.dtype, np.inexact):
+        fill_value = np.inf
+    else:
+        fill_value = None
+    if overwrite_input:
+        if axis is None:
+            asorted = a.ravel()
+            asorted.sort(fill_value=fill_value)
+        else:
+            a.sort(axis=axis, fill_value=fill_value)
+            asorted = a
+    else:
+        asorted = sort(a, axis=axis, fill_value=fill_value)
+
+    if axis is None:
+        axis = 0
+    else:
+        axis = normalize_axis_index(axis, asorted.ndim)
+
+    if asorted.shape[axis] == 0:
+        # for empty axis integer indices fail so use slicing to get same result
+        # as median (which is mean of empty slice = nan)
+        indexer = [slice(None)] * asorted.ndim
+        indexer[axis] = slice(0, 0)
+        indexer = tuple(indexer)
+        return np.ma.mean(asorted[indexer], axis=axis, out=out)
+
+    if asorted.ndim == 1:
+        idx, odd = divmod(count(asorted), 2)
+        mid = asorted[idx + odd - 1:idx + 1]
+        if np.issubdtype(asorted.dtype, np.inexact) and asorted.size > 0:
+            # avoid inf / x = masked
+            s = mid.sum(out=out)
+            if not odd:
+                s = np.true_divide(s, 2., casting='safe', out=out)
+            s = np.lib.utils._median_nancheck(asorted, s, axis)
+        else:
+            s = mid.mean(out=out)
+
+        # if result is masked either the input contained enough
+        # minimum_fill_value so that it would be the median or all values
+        # masked
+        if np.ma.is_masked(s) and not np.all(asorted.mask):
+            return np.ma.minimum_fill_value(asorted)
+        return s
+
+    counts = count(asorted, axis=axis, keepdims=True)
+    h = counts // 2
+
+    # duplicate high if odd number of elements so mean does nothing
+    odd = counts % 2 == 1
+    l = np.where(odd, h, h-1)
+
+    lh = np.concatenate([l,h], axis=axis)
+
+    # get low and high median
+    low_high = np.take_along_axis(asorted, lh, axis=axis)
+
+    def replace_masked(s):
+        # Replace masked entries with minimum_full_value unless it all values
+        # are masked. This is required as the sort order of values equal or
+        # larger than the fill value is undefined and a valid value placed
+        # elsewhere, e.g. [4, --, inf].
+        if np.ma.is_masked(s):
+            rep = (~np.all(asorted.mask, axis=axis, keepdims=True)) & s.mask
+            s.data[rep] = np.ma.minimum_fill_value(asorted)
+            s.mask[rep] = False
+
+    replace_masked(low_high)
+
+    if np.issubdtype(asorted.dtype, np.inexact):
+        # avoid inf / x = masked
+        s = np.ma.sum(low_high, axis=axis, out=out)
+        np.true_divide(s.data, 2., casting='unsafe', out=s.data)
+
+        s = np.lib.utils._median_nancheck(asorted, s, axis)
+    else:
+        s = np.ma.mean(low_high, axis=axis, out=out)
+
+    return s
+
+
+def compress_nd(x, axis=None):
+    """Suppress slices from multiple dimensions which contain masked values.
+
+    Parameters
+    ----------
+    x : array_like, MaskedArray
+        The array to operate on. If not a MaskedArray instance (or if no array
+        elements are masked), `x` is interpreted as a MaskedArray with `mask`
+        set to `nomask`.
+    axis : tuple of ints or int, optional
+        Which dimensions to suppress slices from can be configured with this
+        parameter.
+        - If axis is a tuple of ints, those are the axes to suppress slices from.
+        - If axis is an int, then that is the only axis to suppress slices from.
+        - If axis is None, all axis are selected.
+
+    Returns
+    -------
+    compress_array : ndarray
+        The compressed array.
+    """
+    x = asarray(x)
+    m = getmask(x)
+    # Set axis to tuple of ints
+    if axis is None:
+        axis = tuple(range(x.ndim))
+    else:
+        axis = normalize_axis_tuple(axis, x.ndim)
+
+    # Nothing is masked: return x
+    if m is nomask or not m.any():
+        return x._data
+    # All is masked: return empty
+    if m.all():
+        return nxarray([])
+    # Filter elements through boolean indexing
+    data = x._data
+    for ax in axis:
+        axes = tuple(list(range(ax)) + list(range(ax + 1, x.ndim)))
+        data = data[(slice(None),)*ax + (~m.any(axis=axes),)]
+    return data
+
+
+def compress_rowcols(x, axis=None):
+    """
+    Suppress the rows and/or columns of a 2-D array that contain
+    masked values.
+
+    The suppression behavior is selected with the `axis` parameter.
+
+    - If axis is None, both rows and columns are suppressed.
+    - If axis is 0, only rows are suppressed.
+    - If axis is 1 or -1, only columns are suppressed.
+
+    Parameters
+    ----------
+    x : array_like, MaskedArray
+        The array to operate on.  If not a MaskedArray instance (or if no array
+        elements are masked), `x` is interpreted as a MaskedArray with
+        `mask` set to `nomask`. Must be a 2D array.
+    axis : int, optional
+        Axis along which to perform the operation. Default is None.
+
+    Returns
+    -------
+    compressed_array : ndarray
+        The compressed array.
+
+    Examples
+    --------
+    >>> x = np.ma.array(np.arange(9).reshape(3, 3), mask=[[1, 0, 0],
+    ...                                                   [1, 0, 0],
+    ...                                                   [0, 0, 0]])
+    >>> x
+    masked_array(
+      data=[[--, 1, 2],
+            [--, 4, 5],
+            [6, 7, 8]],
+      mask=[[ True, False, False],
+            [ True, False, False],
+            [False, False, False]],
+      fill_value=999999)
+
+    >>> np.ma.compress_rowcols(x)
+    array([[7, 8]])
+    >>> np.ma.compress_rowcols(x, 0)
+    array([[6, 7, 8]])
+    >>> np.ma.compress_rowcols(x, 1)
+    array([[1, 2],
+           [4, 5],
+           [7, 8]])
+
+    """
+    if asarray(x).ndim != 2:
+        raise NotImplementedError("compress_rowcols works for 2D arrays only.")
+    return compress_nd(x, axis=axis)
+
+
+def compress_rows(a):
+    """
+    Suppress whole rows of a 2-D array that contain masked values.
+
+    This is equivalent to ``np.ma.compress_rowcols(a, 0)``, see
+    `compress_rowcols` for details.
+
+    See Also
+    --------
+    compress_rowcols
+
+    """
+    a = asarray(a)
+    if a.ndim != 2:
+        raise NotImplementedError("compress_rows works for 2D arrays only.")
+    return compress_rowcols(a, 0)
+
+
+def compress_cols(a):
+    """
+    Suppress whole columns of a 2-D array that contain masked values.
+
+    This is equivalent to ``np.ma.compress_rowcols(a, 1)``, see
+    `compress_rowcols` for details.
+
+    See Also
+    --------
+    compress_rowcols
+
+    """
+    a = asarray(a)
+    if a.ndim != 2:
+        raise NotImplementedError("compress_cols works for 2D arrays only.")
+    return compress_rowcols(a, 1)
+
+
+def mask_rowcols(a, axis=None):
+    """
+    Mask rows and/or columns of a 2D array that contain masked values.
+
+    Mask whole rows and/or columns of a 2D array that contain
+    masked values.  The masking behavior is selected using the
+    `axis` parameter.
+
+      - If `axis` is None, rows *and* columns are masked.
+      - If `axis` is 0, only rows are masked.
+      - If `axis` is 1 or -1, only columns are masked.
+
+    Parameters
+    ----------
+    a : array_like, MaskedArray
+        The array to mask.  If not a MaskedArray instance (or if no array
+        elements are masked), the result is a MaskedArray with `mask` set
+        to `nomask` (False). Must be a 2D array.
+    axis : int, optional
+        Axis along which to perform the operation. If None, applies to a
+        flattened version of the array.
+
+    Returns
+    -------
+    a : MaskedArray
+        A modified version of the input array, masked depending on the value
+        of the `axis` parameter.
+
+    Raises
+    ------
+    NotImplementedError
+        If input array `a` is not 2D.
+
+    See Also
+    --------
+    mask_rows : Mask rows of a 2D array that contain masked values.
+    mask_cols : Mask cols of a 2D array that contain masked values.
+    masked_where : Mask where a condition is met.
+
+    Notes
+    -----
+    The input array's mask is modified by this function.
+
+    Examples
+    --------
+    >>> import numpy.ma as ma
+    >>> a = np.zeros((3, 3), dtype=int)
+    >>> a[1, 1] = 1
+    >>> a
+    array([[0, 0, 0],
+           [0, 1, 0],
+           [0, 0, 0]])
+    >>> a = ma.masked_equal(a, 1)
+    >>> a
+    masked_array(
+      data=[[0, 0, 0],
+            [0, --, 0],
+            [0, 0, 0]],
+      mask=[[False, False, False],
+            [False,  True, False],
+            [False, False, False]],
+      fill_value=1)
+    >>> ma.mask_rowcols(a)
+    masked_array(
+      data=[[0, --, 0],
+            [--, --, --],
+            [0, --, 0]],
+      mask=[[False,  True, False],
+            [ True,  True,  True],
+            [False,  True, False]],
+      fill_value=1)
+
+    """
+    a = array(a, subok=False)
+    if a.ndim != 2:
+        raise NotImplementedError("mask_rowcols works for 2D arrays only.")
+    m = getmask(a)
+    # Nothing is masked: return a
+    if m is nomask or not m.any():
+        return a
+    maskedval = m.nonzero()
+    a._mask = a._mask.copy()
+    if not axis:
+        a[np.unique(maskedval[0])] = masked
+    if axis in [None, 1, -1]:
+        a[:, np.unique(maskedval[1])] = masked
+    return a
+
+
+def mask_rows(a, axis=np._NoValue):
+    """
+    Mask rows of a 2D array that contain masked values.
+
+    This function is a shortcut to ``mask_rowcols`` with `axis` equal to 0.
+
+    See Also
+    --------
+    mask_rowcols : Mask rows and/or columns of a 2D array.
+    masked_where : Mask where a condition is met.
+
+    Examples
+    --------
+    >>> import numpy.ma as ma
+    >>> a = np.zeros((3, 3), dtype=int)
+    >>> a[1, 1] = 1
+    >>> a
+    array([[0, 0, 0],
+           [0, 1, 0],
+           [0, 0, 0]])
+    >>> a = ma.masked_equal(a, 1)
+    >>> a
+    masked_array(
+      data=[[0, 0, 0],
+            [0, --, 0],
+            [0, 0, 0]],
+      mask=[[False, False, False],
+            [False,  True, False],
+            [False, False, False]],
+      fill_value=1)
+
+    >>> ma.mask_rows(a)
+    masked_array(
+      data=[[0, 0, 0],
+            [--, --, --],
+            [0, 0, 0]],
+      mask=[[False, False, False],
+            [ True,  True,  True],
+            [False, False, False]],
+      fill_value=1)
+
+    """
+    if axis is not np._NoValue:
+        # remove the axis argument when this deprecation expires
+        # NumPy 1.18.0, 2019-11-28
+        warnings.warn(
+            "The axis argument has always been ignored, in future passing it "
+            "will raise TypeError", DeprecationWarning, stacklevel=2)
+    return mask_rowcols(a, 0)
+
+
+def mask_cols(a, axis=np._NoValue):
+    """
+    Mask columns of a 2D array that contain masked values.
+
+    This function is a shortcut to ``mask_rowcols`` with `axis` equal to 1.
+
+    See Also
+    --------
+    mask_rowcols : Mask rows and/or columns of a 2D array.
+    masked_where : Mask where a condition is met.
+
+    Examples
+    --------
+    >>> import numpy.ma as ma
+    >>> a = np.zeros((3, 3), dtype=int)
+    >>> a[1, 1] = 1
+    >>> a
+    array([[0, 0, 0],
+           [0, 1, 0],
+           [0, 0, 0]])
+    >>> a = ma.masked_equal(a, 1)
+    >>> a
+    masked_array(
+      data=[[0, 0, 0],
+            [0, --, 0],
+            [0, 0, 0]],
+      mask=[[False, False, False],
+            [False,  True, False],
+            [False, False, False]],
+      fill_value=1)
+    >>> ma.mask_cols(a)
+    masked_array(
+      data=[[0, --, 0],
+            [0, --, 0],
+            [0, --, 0]],
+      mask=[[False,  True, False],
+            [False,  True, False],
+            [False,  True, False]],
+      fill_value=1)
+
+    """
+    if axis is not np._NoValue:
+        # remove the axis argument when this deprecation expires
+        # NumPy 1.18.0, 2019-11-28
+        warnings.warn(
+            "The axis argument has always been ignored, in future passing it "
+            "will raise TypeError", DeprecationWarning, stacklevel=2)
+    return mask_rowcols(a, 1)
+
+
+#####--------------------------------------------------------------------------
+#---- --- arraysetops ---
+#####--------------------------------------------------------------------------
+
+def ediff1d(arr, to_end=None, to_begin=None):
+    """
+    Compute the differences between consecutive elements of an array.
+
+    This function is the equivalent of `numpy.ediff1d` that takes masked
+    values into account, see `numpy.ediff1d` for details.
+
+    See Also
+    --------
+    numpy.ediff1d : Equivalent function for ndarrays.
+
+    """
+    arr = ma.asanyarray(arr).flat
+    ed = arr[1:] - arr[:-1]
+    arrays = [ed]
+    #
+    if to_begin is not None:
+        arrays.insert(0, to_begin)
+    if to_end is not None:
+        arrays.append(to_end)
+    #
+    if len(arrays) != 1:
+        # We'll save ourselves a copy of a potentially large array in the common
+        # case where neither to_begin or to_end was given.
+        ed = hstack(arrays)
+    #
+    return ed
+
+
+def unique(ar1, return_index=False, return_inverse=False):
+    """
+    Finds the unique elements of an array.
+
+    Masked values are considered the same element (masked). The output array
+    is always a masked array. See `numpy.unique` for more details.
+
+    See Also
+    --------
+    numpy.unique : Equivalent function for ndarrays.
+
+    Examples
+    --------
+    >>> import numpy.ma as ma
+    >>> a = [1, 2, 1000, 2, 3]
+    >>> mask = [0, 0, 1, 0, 0]
+    >>> masked_a = ma.masked_array(a, mask)
+    >>> masked_a
+    masked_array(data=[1, 2, --, 2, 3],
+                mask=[False, False,  True, False, False],
+        fill_value=999999)
+    >>> ma.unique(masked_a)
+    masked_array(data=[1, 2, 3, --],
+                mask=[False, False, False,  True],
+        fill_value=999999)
+    >>> ma.unique(masked_a, return_index=True)
+    (masked_array(data=[1, 2, 3, --],
+                mask=[False, False, False,  True],
+        fill_value=999999), array([0, 1, 4, 2]))
+    >>> ma.unique(masked_a, return_inverse=True)
+    (masked_array(data=[1, 2, 3, --],
+                mask=[False, False, False,  True],
+        fill_value=999999), array([0, 1, 3, 1, 2]))
+    >>> ma.unique(masked_a, return_index=True, return_inverse=True)
+    (masked_array(data=[1, 2, 3, --],
+                mask=[False, False, False,  True],
+        fill_value=999999), array([0, 1, 4, 2]), array([0, 1, 3, 1, 2]))
+    """
+    output = np.unique(ar1,
+                       return_index=return_index,
+                       return_inverse=return_inverse)
+    if isinstance(output, tuple):
+        output = list(output)
+        output[0] = output[0].view(MaskedArray)
+        output = tuple(output)
+    else:
+        output = output.view(MaskedArray)
+    return output
+
+
+def intersect1d(ar1, ar2, assume_unique=False):
+    """
+    Returns the unique elements common to both arrays.
+
+    Masked values are considered equal one to the other.
+    The output is always a masked array.
+
+    See `numpy.intersect1d` for more details.
+
+    See Also
+    --------
+    numpy.intersect1d : Equivalent function for ndarrays.
+
+    Examples
+    --------
+    >>> x = np.ma.array([1, 3, 3, 3], mask=[0, 0, 0, 1])
+    >>> y = np.ma.array([3, 1, 1, 1], mask=[0, 0, 0, 1])
+    >>> np.ma.intersect1d(x, y)
+    masked_array(data=[1, 3, --],
+                 mask=[False, False,  True],
+           fill_value=999999)
+
+    """
+    if assume_unique:
+        aux = ma.concatenate((ar1, ar2))
+    else:
+        # Might be faster than unique( intersect1d( ar1, ar2 ) )?
+        aux = ma.concatenate((unique(ar1), unique(ar2)))
+    aux.sort()
+    return aux[:-1][aux[1:] == aux[:-1]]
+
+
+def setxor1d(ar1, ar2, assume_unique=False):
+    """
+    Set exclusive-or of 1-D arrays with unique elements.
+
+    The output is always a masked array. See `numpy.setxor1d` for more details.
+
+    See Also
+    --------
+    numpy.setxor1d : Equivalent function for ndarrays.
+
+    """
+    if not assume_unique:
+        ar1 = unique(ar1)
+        ar2 = unique(ar2)
+
+    aux = ma.concatenate((ar1, ar2))
+    if aux.size == 0:
+        return aux
+    aux.sort()
+    auxf = aux.filled()
+#    flag = ediff1d( aux, to_end = 1, to_begin = 1 ) == 0
+    flag = ma.concatenate(([True], (auxf[1:] != auxf[:-1]), [True]))
+#    flag2 = ediff1d( flag ) == 0
+    flag2 = (flag[1:] == flag[:-1])
+    return aux[flag2]
+
+
+def in1d(ar1, ar2, assume_unique=False, invert=False):
+    """
+    Test whether each element of an array is also present in a second
+    array.
+
+    The output is always a masked array. See `numpy.in1d` for more details.
+
+    We recommend using :func:`isin` instead of `in1d` for new code.
+
+    See Also
+    --------
+    isin       : Version of this function that preserves the shape of ar1.
+    numpy.in1d : Equivalent function for ndarrays.
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    """
+    if not assume_unique:
+        ar1, rev_idx = unique(ar1, return_inverse=True)
+        ar2 = unique(ar2)
+
+    ar = ma.concatenate((ar1, ar2))
+    # We need this to be a stable sort, so always use 'mergesort'
+    # here. The values from the first array should always come before
+    # the values from the second array.
+    order = ar.argsort(kind='mergesort')
+    sar = ar[order]
+    if invert:
+        bool_ar = (sar[1:] != sar[:-1])
+    else:
+        bool_ar = (sar[1:] == sar[:-1])
+    flag = ma.concatenate((bool_ar, [invert]))
+    indx = order.argsort(kind='mergesort')[:len(ar1)]
+
+    if assume_unique:
+        return flag[indx]
+    else:
+        return flag[indx][rev_idx]
+
+
+def isin(element, test_elements, assume_unique=False, invert=False):
+    """
+    Calculates `element in test_elements`, broadcasting over
+    `element` only.
+
+    The output is always a masked array of the same shape as `element`.
+    See `numpy.isin` for more details.
+
+    See Also
+    --------
+    in1d       : Flattened version of this function.
+    numpy.isin : Equivalent function for ndarrays.
+
+    Notes
+    -----
+    .. versionadded:: 1.13.0
+
+    """
+    element = ma.asarray(element)
+    return in1d(element, test_elements, assume_unique=assume_unique,
+                invert=invert).reshape(element.shape)
+
+
+def union1d(ar1, ar2):
+    """
+    Union of two arrays.
+
+    The output is always a masked array. See `numpy.union1d` for more details.
+
+    See Also
+    --------
+    numpy.union1d : Equivalent function for ndarrays.
+
+    """
+    return unique(ma.concatenate((ar1, ar2), axis=None))
+
+
+def setdiff1d(ar1, ar2, assume_unique=False):
+    """
+    Set difference of 1D arrays with unique elements.
+
+    The output is always a masked array. See `numpy.setdiff1d` for more
+    details.
+
+    See Also
+    --------
+    numpy.setdiff1d : Equivalent function for ndarrays.
+
+    Examples
+    --------
+    >>> x = np.ma.array([1, 2, 3, 4], mask=[0, 1, 0, 1])
+    >>> np.ma.setdiff1d(x, [1, 2])
+    masked_array(data=[3, --],
+                 mask=[False,  True],
+           fill_value=999999)
+
+    """
+    if assume_unique:
+        ar1 = ma.asarray(ar1).ravel()
+    else:
+        ar1 = unique(ar1)
+        ar2 = unique(ar2)
+    return ar1[in1d(ar1, ar2, assume_unique=True, invert=True)]
+
+
+###############################################################################
+#                                Covariance                                   #
+###############################################################################
+
+
+def _covhelper(x, y=None, rowvar=True, allow_masked=True):
+    """
+    Private function for the computation of covariance and correlation
+    coefficients.
+
+    """
+    x = ma.array(x, ndmin=2, copy=True, dtype=float)
+    xmask = ma.getmaskarray(x)
+    # Quick exit if we can't process masked data
+    if not allow_masked and xmask.any():
+        raise ValueError("Cannot process masked data.")
+    #
+    if x.shape[0] == 1:
+        rowvar = True
+    # Make sure that rowvar is either 0 or 1
+    rowvar = int(bool(rowvar))
+    axis = 1 - rowvar
+    if rowvar:
+        tup = (slice(None), None)
+    else:
+        tup = (None, slice(None))
+    #
+    if y is None:
+        xnotmask = np.logical_not(xmask).astype(int)
+    else:
+        y = array(y, copy=False, ndmin=2, dtype=float)
+        ymask = ma.getmaskarray(y)
+        if not allow_masked and ymask.any():
+            raise ValueError("Cannot process masked data.")
+        if xmask.any() or ymask.any():
+            if y.shape == x.shape:
+                # Define some common mask
+                common_mask = np.logical_or(xmask, ymask)
+                if common_mask is not nomask:
+                    xmask = x._mask = y._mask = ymask = common_mask
+                    x._sharedmask = False
+                    y._sharedmask = False
+        x = ma.concatenate((x, y), axis)
+        xnotmask = np.logical_not(np.concatenate((xmask, ymask), axis)).astype(int)
+    x -= x.mean(axis=rowvar)[tup]
+    return (x, xnotmask, rowvar)
+
+
+def cov(x, y=None, rowvar=True, bias=False, allow_masked=True, ddof=None):
+    """
+    Estimate the covariance matrix.
+
+    Except for the handling of missing data this function does the same as
+    `numpy.cov`. For more details and examples, see `numpy.cov`.
+
+    By default, masked values are recognized as such. If `x` and `y` have the
+    same shape, a common mask is allocated: if ``x[i,j]`` is masked, then
+    ``y[i,j]`` will also be masked.
+    Setting `allow_masked` to False will raise an exception if values are
+    missing in either of the input arrays.
+
+    Parameters
+    ----------
+    x : array_like
+        A 1-D or 2-D array containing multiple variables and observations.
+        Each row of `x` represents a variable, and each column a single
+        observation of all those variables. Also see `rowvar` below.
+    y : array_like, optional
+        An additional set of variables and observations. `y` has the same
+        shape as `x`.
+    rowvar : bool, optional
+        If `rowvar` is True (default), then each row represents a
+        variable, with observations in the columns. Otherwise, the relationship
+        is transposed: each column represents a variable, while the rows
+        contain observations.
+    bias : bool, optional
+        Default normalization (False) is by ``(N-1)``, where ``N`` is the
+        number of observations given (unbiased estimate). If `bias` is True,
+        then normalization is by ``N``. This keyword can be overridden by
+        the keyword ``ddof`` in numpy versions >= 1.5.
+    allow_masked : bool, optional
+        If True, masked values are propagated pair-wise: if a value is masked
+        in `x`, the corresponding value is masked in `y`.
+        If False, raises a `ValueError` exception when some values are missing.
+    ddof : {None, int}, optional
+        If not ``None`` normalization is by ``(N - ddof)``, where ``N`` is
+        the number of observations; this overrides the value implied by
+        ``bias``. The default value is ``None``.
+
+        .. versionadded:: 1.5
+
+    Raises
+    ------
+    ValueError
+        Raised if some values are missing and `allow_masked` is False.
+
+    See Also
+    --------
+    numpy.cov
+
+    """
+    # Check inputs
+    if ddof is not None and ddof != int(ddof):
+        raise ValueError("ddof must be an integer")
+    # Set up ddof
+    if ddof is None:
+        if bias:
+            ddof = 0
+        else:
+            ddof = 1
+
+    (x, xnotmask, rowvar) = _covhelper(x, y, rowvar, allow_masked)
+    if not rowvar:
+        fact = np.dot(xnotmask.T, xnotmask) * 1. - ddof
+        result = (dot(x.T, x.conj(), strict=False) / fact).squeeze()
+    else:
+        fact = np.dot(xnotmask, xnotmask.T) * 1. - ddof
+        result = (dot(x, x.T.conj(), strict=False) / fact).squeeze()
+    return result
+
+
+def corrcoef(x, y=None, rowvar=True, bias=np._NoValue, allow_masked=True,
+             ddof=np._NoValue):
+    """
+    Return Pearson product-moment correlation coefficients.
+
+    Except for the handling of missing data this function does the same as
+    `numpy.corrcoef`. For more details and examples, see `numpy.corrcoef`.
+
+    Parameters
+    ----------
+    x : array_like
+        A 1-D or 2-D array containing multiple variables and observations.
+        Each row of `x` represents a variable, and each column a single
+        observation of all those variables. Also see `rowvar` below.
+    y : array_like, optional
+        An additional set of variables and observations. `y` has the same
+        shape as `x`.
+    rowvar : bool, optional
+        If `rowvar` is True (default), then each row represents a
+        variable, with observations in the columns. Otherwise, the relationship
+        is transposed: each column represents a variable, while the rows
+        contain observations.
+    bias : _NoValue, optional
+        Has no effect, do not use.
+
+        .. deprecated:: 1.10.0
+    allow_masked : bool, optional
+        If True, masked values are propagated pair-wise: if a value is masked
+        in `x`, the corresponding value is masked in `y`.
+        If False, raises an exception.  Because `bias` is deprecated, this
+        argument needs to be treated as keyword only to avoid a warning.
+    ddof : _NoValue, optional
+        Has no effect, do not use.
+
+        .. deprecated:: 1.10.0
+
+    See Also
+    --------
+    numpy.corrcoef : Equivalent function in top-level NumPy module.
+    cov : Estimate the covariance matrix.
+
+    Notes
+    -----
+    This function accepts but discards arguments `bias` and `ddof`.  This is
+    for backwards compatibility with previous versions of this function.  These
+    arguments had no effect on the return values of the function and can be
+    safely ignored in this and previous versions of numpy.
+    """
+    msg = 'bias and ddof have no effect and are deprecated'
+    if bias is not np._NoValue or ddof is not np._NoValue:
+        # 2015-03-15, 1.10
+        warnings.warn(msg, DeprecationWarning, stacklevel=2)
+    # Get the data
+    (x, xnotmask, rowvar) = _covhelper(x, y, rowvar, allow_masked)
+    # Compute the covariance matrix
+    if not rowvar:
+        fact = np.dot(xnotmask.T, xnotmask) * 1.
+        c = (dot(x.T, x.conj(), strict=False) / fact).squeeze()
+    else:
+        fact = np.dot(xnotmask, xnotmask.T) * 1.
+        c = (dot(x, x.T.conj(), strict=False) / fact).squeeze()
+    # Check whether we have a scalar
+    try:
+        diag = ma.diagonal(c)
+    except ValueError:
+        return 1
+    #
+    if xnotmask.all():
+        _denom = ma.sqrt(ma.multiply.outer(diag, diag))
+    else:
+        _denom = diagflat(diag)
+        _denom._sharedmask = False  # We know return is always a copy
+        n = x.shape[1 - rowvar]
+        if rowvar:
+            for i in range(n - 1):
+                for j in range(i + 1, n):
+                    _x = mask_cols(vstack((x[i], x[j]))).var(axis=1)
+                    _denom[i, j] = _denom[j, i] = ma.sqrt(ma.multiply.reduce(_x))
+        else:
+            for i in range(n - 1):
+                for j in range(i + 1, n):
+                    _x = mask_cols(
+                            vstack((x[:, i], x[:, j]))).var(axis=1)
+                    _denom[i, j] = _denom[j, i] = ma.sqrt(ma.multiply.reduce(_x))
+    return c / _denom
+
+#####--------------------------------------------------------------------------
+#---- --- Concatenation helpers ---
+#####--------------------------------------------------------------------------
+
+class MAxisConcatenator(AxisConcatenator):
+    """
+    Translate slice objects to concatenation along an axis.
+
+    For documentation on usage, see `mr_class`.
+
+    See Also
+    --------
+    mr_class
+
+    """
+    concatenate = staticmethod(concatenate)
+
+    @classmethod
+    def makemat(cls, arr):
+        # There used to be a view as np.matrix here, but we may eventually
+        # deprecate that class. In preparation, we use the unmasked version
+        # to construct the matrix (with copy=False for backwards compatibility
+        # with the .view)
+        data = super().makemat(arr.data, copy=False)
+        return array(data, mask=arr.mask)
+
+    def __getitem__(self, key):
+        # matrix builder syntax, like 'a, b; c, d'
+        if isinstance(key, str):
+            raise MAError("Unavailable for masked array.")
+
+        return super().__getitem__(key)
+
+
+class mr_class(MAxisConcatenator):
+    """
+    Translate slice objects to concatenation along the first axis.
+
+    This is the masked array version of `lib.index_tricks.RClass`.
+
+    See Also
+    --------
+    lib.index_tricks.RClass
+
+    Examples
+    --------
+    >>> np.ma.mr_[np.ma.array([1,2,3]), 0, 0, np.ma.array([4,5,6])]
+    masked_array(data=[1, 2, 3, ..., 4, 5, 6],
+                 mask=False,
+           fill_value=999999)
+
+    """
+    def __init__(self):
+        MAxisConcatenator.__init__(self, 0)
+
+mr_ = mr_class()
+
+
+#####--------------------------------------------------------------------------
+#---- Find unmasked data ---
+#####--------------------------------------------------------------------------
+
+def ndenumerate(a, compressed=True):
+    """
+    Multidimensional index iterator.
+
+    Return an iterator yielding pairs of array coordinates and values,
+    skipping elements that are masked. With `compressed=False`,
+    `ma.masked` is yielded as the value of masked elements. This
+    behavior differs from that of `numpy.ndenumerate`, which yields the
+    value of the underlying data array.
+
+    Notes
+    -----
+    .. versionadded:: 1.23.0
+
+    Parameters
+    ----------
+    a : array_like
+        An array with (possibly) masked elements.
+    compressed : bool, optional
+        If True (default), masked elements are skipped.
+
+    See Also
+    --------
+    numpy.ndenumerate : Equivalent function ignoring any mask.
+
+    Examples
+    --------
+    >>> a = np.ma.arange(9).reshape((3, 3))
+    >>> a[1, 0] = np.ma.masked
+    >>> a[1, 2] = np.ma.masked
+    >>> a[2, 1] = np.ma.masked
+    >>> a
+    masked_array(
+      data=[[0, 1, 2],
+            [--, 4, --],
+            [6, --, 8]],
+      mask=[[False, False, False],
+            [ True, False,  True],
+            [False,  True, False]],
+      fill_value=999999)
+    >>> for index, x in np.ma.ndenumerate(a):
+    ...     print(index, x)
+    (0, 0) 0
+    (0, 1) 1
+    (0, 2) 2
+    (1, 1) 4
+    (2, 0) 6
+    (2, 2) 8
+
+    >>> for index, x in np.ma.ndenumerate(a, compressed=False):
+    ...     print(index, x)
+    (0, 0) 0
+    (0, 1) 1
+    (0, 2) 2
+    (1, 0) --
+    (1, 1) 4
+    (1, 2) --
+    (2, 0) 6
+    (2, 1) --
+    (2, 2) 8
+    """
+    for it, mask in zip(np.ndenumerate(a), getmaskarray(a).flat):
+        if not mask:
+            yield it
+        elif not compressed:
+            yield it[0], masked
+
+
+def flatnotmasked_edges(a):
+    """
+    Find the indices of the first and last unmasked values.
+
+    Expects a 1-D `MaskedArray`, returns None if all values are masked.
+
+    Parameters
+    ----------
+    a : array_like
+        Input 1-D `MaskedArray`
+
+    Returns
+    -------
+    edges : ndarray or None
+        The indices of first and last non-masked value in the array.
+        Returns None if all values are masked.
+
+    See Also
+    --------
+    flatnotmasked_contiguous, notmasked_contiguous, notmasked_edges
+    clump_masked, clump_unmasked
+
+    Notes
+    -----
+    Only accepts 1-D arrays.
+
+    Examples
+    --------
+    >>> a = np.ma.arange(10)
+    >>> np.ma.flatnotmasked_edges(a)
+    array([0, 9])
+
+    >>> mask = (a < 3) | (a > 8) | (a == 5)
+    >>> a[mask] = np.ma.masked
+    >>> np.array(a[~a.mask])
+    array([3, 4, 6, 7, 8])
+
+    >>> np.ma.flatnotmasked_edges(a)
+    array([3, 8])
+
+    >>> a[:] = np.ma.masked
+    >>> print(np.ma.flatnotmasked_edges(a))
+    None
+
+    """
+    m = getmask(a)
+    if m is nomask or not np.any(m):
+        return np.array([0, a.size - 1])
+    unmasked = np.flatnonzero(~m)
+    if len(unmasked) > 0:
+        return unmasked[[0, -1]]
+    else:
+        return None
+
+
+def notmasked_edges(a, axis=None):
+    """
+    Find the indices of the first and last unmasked values along an axis.
+
+    If all values are masked, return None.  Otherwise, return a list
+    of two tuples, corresponding to the indices of the first and last
+    unmasked values respectively.
+
+    Parameters
+    ----------
+    a : array_like
+        The input array.
+    axis : int, optional
+        Axis along which to perform the operation.
+        If None (default), applies to a flattened version of the array.
+
+    Returns
+    -------
+    edges : ndarray or list
+        An array of start and end indexes if there are any masked data in
+        the array. If there are no masked data in the array, `edges` is a
+        list of the first and last index.
+
+    See Also
+    --------
+    flatnotmasked_contiguous, flatnotmasked_edges, notmasked_contiguous
+    clump_masked, clump_unmasked
+
+    Examples
+    --------
+    >>> a = np.arange(9).reshape((3, 3))
+    >>> m = np.zeros_like(a)
+    >>> m[1:, 1:] = 1
+
+    >>> am = np.ma.array(a, mask=m)
+    >>> np.array(am[~am.mask])
+    array([0, 1, 2, 3, 6])
+
+    >>> np.ma.notmasked_edges(am)
+    array([0, 6])
+
+    """
+    a = asarray(a)
+    if axis is None or a.ndim == 1:
+        return flatnotmasked_edges(a)
+    m = getmaskarray(a)
+    idx = array(np.indices(a.shape), mask=np.asarray([m] * a.ndim))
+    return [tuple([idx[i].min(axis).compressed() for i in range(a.ndim)]),
+            tuple([idx[i].max(axis).compressed() for i in range(a.ndim)]), ]
+
+
+def flatnotmasked_contiguous(a):
+    """
+    Find contiguous unmasked data in a masked array.
+
+    Parameters
+    ----------
+    a : array_like
+        The input array.
+
+    Returns
+    -------
+    slice_list : list
+        A sorted sequence of `slice` objects (start index, end index).
+
+        .. versionchanged:: 1.15.0
+            Now returns an empty list instead of None for a fully masked array
+
+    See Also
+    --------
+    flatnotmasked_edges, notmasked_contiguous, notmasked_edges
+    clump_masked, clump_unmasked
+
+    Notes
+    -----
+    Only accepts 2-D arrays at most.
+
+    Examples
+    --------
+    >>> a = np.ma.arange(10)
+    >>> np.ma.flatnotmasked_contiguous(a)
+    [slice(0, 10, None)]
+
+    >>> mask = (a < 3) | (a > 8) | (a == 5)
+    >>> a[mask] = np.ma.masked
+    >>> np.array(a[~a.mask])
+    array([3, 4, 6, 7, 8])
+
+    >>> np.ma.flatnotmasked_contiguous(a)
+    [slice(3, 5, None), slice(6, 9, None)]
+    >>> a[:] = np.ma.masked
+    >>> np.ma.flatnotmasked_contiguous(a)
+    []
+
+    """
+    m = getmask(a)
+    if m is nomask:
+        return [slice(0, a.size)]
+    i = 0
+    result = []
+    for (k, g) in itertools.groupby(m.ravel()):
+        n = len(list(g))
+        if not k:
+            result.append(slice(i, i + n))
+        i += n
+    return result
+
+
+def notmasked_contiguous(a, axis=None):
+    """
+    Find contiguous unmasked data in a masked array along the given axis.
+
+    Parameters
+    ----------
+    a : array_like
+        The input array.
+    axis : int, optional
+        Axis along which to perform the operation.
+        If None (default), applies to a flattened version of the array, and this
+        is the same as `flatnotmasked_contiguous`.
+
+    Returns
+    -------
+    endpoints : list
+        A list of slices (start and end indexes) of unmasked indexes
+        in the array.
+
+        If the input is 2d and axis is specified, the result is a list of lists.
+
+    See Also
+    --------
+    flatnotmasked_edges, flatnotmasked_contiguous, notmasked_edges
+    clump_masked, clump_unmasked
+
+    Notes
+    -----
+    Only accepts 2-D arrays at most.
+
+    Examples
+    --------
+    >>> a = np.arange(12).reshape((3, 4))
+    >>> mask = np.zeros_like(a)
+    >>> mask[1:, :-1] = 1; mask[0, 1] = 1; mask[-1, 0] = 0
+    >>> ma = np.ma.array(a, mask=mask)
+    >>> ma
+    masked_array(
+      data=[[0, --, 2, 3],
+            [--, --, --, 7],
+            [8, --, --, 11]],
+      mask=[[False,  True, False, False],
+            [ True,  True,  True, False],
+            [False,  True,  True, False]],
+      fill_value=999999)
+    >>> np.array(ma[~ma.mask])
+    array([ 0,  2,  3,  7, 8, 11])
+
+    >>> np.ma.notmasked_contiguous(ma)
+    [slice(0, 1, None), slice(2, 4, None), slice(7, 9, None), slice(11, 12, None)]
+
+    >>> np.ma.notmasked_contiguous(ma, axis=0)
+    [[slice(0, 1, None), slice(2, 3, None)], [], [slice(0, 1, None)], [slice(0, 3, None)]]
+
+    >>> np.ma.notmasked_contiguous(ma, axis=1)
+    [[slice(0, 1, None), slice(2, 4, None)], [slice(3, 4, None)], [slice(0, 1, None), slice(3, 4, None)]]
+
+    """
+    a = asarray(a)
+    nd = a.ndim
+    if nd > 2:
+        raise NotImplementedError("Currently limited to at most 2D array.")
+    if axis is None or nd == 1:
+        return flatnotmasked_contiguous(a)
+    #
+    result = []
+    #
+    other = (axis + 1) % 2
+    idx = [0, 0]
+    idx[axis] = slice(None, None)
+    #
+    for i in range(a.shape[other]):
+        idx[other] = i
+        result.append(flatnotmasked_contiguous(a[tuple(idx)]))
+    return result
+
+
+def _ezclump(mask):
+    """
+    Finds the clumps (groups of data with the same values) for a 1D bool array.
+
+    Returns a series of slices.
+    """
+    if mask.ndim > 1:
+        mask = mask.ravel()
+    idx = (mask[1:] ^ mask[:-1]).nonzero()
+    idx = idx[0] + 1
+
+    if mask[0]:
+        if len(idx) == 0:
+            return [slice(0, mask.size)]
+
+        r = [slice(0, idx[0])]
+        r.extend((slice(left, right)
+                  for left, right in zip(idx[1:-1:2], idx[2::2])))
+    else:
+        if len(idx) == 0:
+            return []
+
+        r = [slice(left, right) for left, right in zip(idx[:-1:2], idx[1::2])]
+
+    if mask[-1]:
+        r.append(slice(idx[-1], mask.size))
+    return r
+
+
+def clump_unmasked(a):
+    """
+    Return list of slices corresponding to the unmasked clumps of a 1-D array.
+    (A "clump" is defined as a contiguous region of the array).
+
+    Parameters
+    ----------
+    a : ndarray
+        A one-dimensional masked array.
+
+    Returns
+    -------
+    slices : list of slice
+        The list of slices, one for each continuous region of unmasked
+        elements in `a`.
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    See Also
+    --------
+    flatnotmasked_edges, flatnotmasked_contiguous, notmasked_edges
+    notmasked_contiguous, clump_masked
+
+    Examples
+    --------
+    >>> a = np.ma.masked_array(np.arange(10))
+    >>> a[[0, 1, 2, 6, 8, 9]] = np.ma.masked
+    >>> np.ma.clump_unmasked(a)
+    [slice(3, 6, None), slice(7, 8, None)]
+
+    """
+    mask = getattr(a, '_mask', nomask)
+    if mask is nomask:
+        return [slice(0, a.size)]
+    return _ezclump(~mask)
+
+
+def clump_masked(a):
+    """
+    Returns a list of slices corresponding to the masked clumps of a 1-D array.
+    (A "clump" is defined as a contiguous region of the array).
+
+    Parameters
+    ----------
+    a : ndarray
+        A one-dimensional masked array.
+
+    Returns
+    -------
+    slices : list of slice
+        The list of slices, one for each continuous region of masked elements
+        in `a`.
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    See Also
+    --------
+    flatnotmasked_edges, flatnotmasked_contiguous, notmasked_edges
+    notmasked_contiguous, clump_unmasked
+
+    Examples
+    --------
+    >>> a = np.ma.masked_array(np.arange(10))
+    >>> a[[0, 1, 2, 6, 8, 9]] = np.ma.masked
+    >>> np.ma.clump_masked(a)
+    [slice(0, 3, None), slice(6, 7, None), slice(8, 10, None)]
+
+    """
+    mask = ma.getmask(a)
+    if mask is nomask:
+        return []
+    return _ezclump(mask)
+
+
+###############################################################################
+#                              Polynomial fit                                 #
+###############################################################################
+
+
+def vander(x, n=None):
+    """
+    Masked values in the input array result in rows of zeros.
+
+    """
+    _vander = np.vander(x, n)
+    m = getmask(x)
+    if m is not nomask:
+        _vander[m] = 0
+    return _vander
+
+vander.__doc__ = ma.doc_note(np.vander.__doc__, vander.__doc__)
+
+
+def polyfit(x, y, deg, rcond=None, full=False, w=None, cov=False):
+    """
+    Any masked values in x is propagated in y, and vice-versa.
+
+    """
+    x = asarray(x)
+    y = asarray(y)
+
+    m = getmask(x)
+    if y.ndim == 1:
+        m = mask_or(m, getmask(y))
+    elif y.ndim == 2:
+        my = getmask(mask_rows(y))
+        if my is not nomask:
+            m = mask_or(m, my[:, 0])
+    else:
+        raise TypeError("Expected a 1D or 2D array for y!")
+
+    if w is not None:
+        w = asarray(w)
+        if w.ndim != 1:
+            raise TypeError("expected a 1-d array for weights")
+        if w.shape[0] != y.shape[0]:
+            raise TypeError("expected w and y to have the same length")
+        m = mask_or(m, getmask(w))
+
+    if m is not nomask:
+        not_m = ~m
+        if w is not None:
+            w = w[not_m]
+        return np.polyfit(x[not_m], y[not_m], deg, rcond, full, w, cov)
+    else:
+        return np.polyfit(x, y, deg, rcond, full, w, cov)
+
+polyfit.__doc__ = ma.doc_note(np.polyfit.__doc__, polyfit.__doc__)

llava_next/lib/python3.10/site-packages/numpy/ma/extras.pyi

@@ -0,0 +1,85 @@
+from typing import Any
+from numpy.lib.index_tricks import AxisConcatenator
+
+from numpy.ma.core import (
+    dot as dot,
+    mask_rowcols as mask_rowcols,
+)
+
+__all__: list[str]
+
+def count_masked(arr, axis=...): ...
+def masked_all(shape, dtype = ...): ...
+def masked_all_like(arr): ...
+
+class _fromnxfunction:
+    __name__: Any
+    __doc__: Any
+    def __init__(self, funcname): ...
+    def getdoc(self): ...
+    def __call__(self, *args, **params): ...
+
+class _fromnxfunction_single(_fromnxfunction):
+    def __call__(self, x, *args, **params): ...
+
+class _fromnxfunction_seq(_fromnxfunction):
+    def __call__(self, x, *args, **params): ...
+
+class _fromnxfunction_allargs(_fromnxfunction):
+    def __call__(self, *args, **params): ...
+
+atleast_1d: _fromnxfunction_allargs
+atleast_2d: _fromnxfunction_allargs
+atleast_3d: _fromnxfunction_allargs
+
+vstack: _fromnxfunction_seq
+row_stack: _fromnxfunction_seq
+hstack: _fromnxfunction_seq
+column_stack: _fromnxfunction_seq
+dstack: _fromnxfunction_seq
+stack: _fromnxfunction_seq
+
+hsplit: _fromnxfunction_single
+diagflat: _fromnxfunction_single
+
+def apply_along_axis(func1d, axis, arr, *args, **kwargs): ...
+def apply_over_axes(func, a, axes): ...
+def average(a, axis=..., weights=..., returned=..., keepdims=...): ...
+def median(a, axis=..., out=..., overwrite_input=..., keepdims=...): ...
+def compress_nd(x, axis=...): ...
+def compress_rowcols(x, axis=...): ...
+def compress_rows(a): ...
+def compress_cols(a): ...
+def mask_rows(a, axis = ...): ...
+def mask_cols(a, axis = ...): ...
+def ediff1d(arr, to_end=..., to_begin=...): ...
+def unique(ar1, return_index=..., return_inverse=...): ...
+def intersect1d(ar1, ar2, assume_unique=...): ...
+def setxor1d(ar1, ar2, assume_unique=...): ...
+def in1d(ar1, ar2, assume_unique=..., invert=...): ...
+def isin(element, test_elements, assume_unique=..., invert=...): ...
+def union1d(ar1, ar2): ...
+def setdiff1d(ar1, ar2, assume_unique=...): ...
+def cov(x, y=..., rowvar=..., bias=..., allow_masked=..., ddof=...): ...
+def corrcoef(x, y=..., rowvar=..., bias = ..., allow_masked=..., ddof = ...): ...
+
+class MAxisConcatenator(AxisConcatenator):
+    concatenate: Any
+    @classmethod
+    def makemat(cls, arr): ...
+    def __getitem__(self, key): ...
+
+class mr_class(MAxisConcatenator):
+    def __init__(self): ...
+
+mr_: mr_class
+
+def ndenumerate(a, compressed=...): ...
+def flatnotmasked_edges(a): ...
+def notmasked_edges(a, axis=...): ...
+def flatnotmasked_contiguous(a): ...
+def notmasked_contiguous(a, axis=...): ...
+def clump_unmasked(a): ...
+def clump_masked(a): ...
+def vander(x, n=...): ...
+def polyfit(x, y, deg, rcond=..., full=..., w=..., cov=...): ...

llava_next/lib/python3.10/site-packages/numpy/ma/mrecords.py

@@ -0,0 +1,783 @@
+""":mod:`numpy.ma..mrecords`
+
+Defines the equivalent of :class:`numpy.recarrays` for masked arrays,
+where fields can be accessed as attributes.
+Note that :class:`numpy.ma.MaskedArray` already supports structured datatypes
+and the masking of individual fields.
+
+.. moduleauthor:: Pierre Gerard-Marchant
+
+"""
+#  We should make sure that no field is called '_mask','mask','_fieldmask',
+#  or whatever restricted keywords.  An idea would be to no bother in the
+#  first place, and then rename the invalid fields with a trailing
+#  underscore. Maybe we could just overload the parser function ?
+
+from numpy.ma import (
+    MAError, MaskedArray, masked, nomask, masked_array, getdata,
+    getmaskarray, filled
+)
+import numpy.ma as ma
+import warnings
+
+import numpy as np
+from numpy import (
+    bool_, dtype, ndarray, recarray, array as narray
+)
+from numpy.core.records import (
+    fromarrays as recfromarrays, fromrecords as recfromrecords
+)
+
+_byteorderconv = np.core.records._byteorderconv
+
+
+_check_fill_value = ma.core._check_fill_value
+
+
+__all__ = [
+    'MaskedRecords', 'mrecarray', 'fromarrays', 'fromrecords',
+    'fromtextfile', 'addfield',
+]
+
+reserved_fields = ['_data', '_mask', '_fieldmask', 'dtype']
+
+
+def _checknames(descr, names=None):
+    """
+    Checks that field names ``descr`` are not reserved keywords.
+
+    If this is the case, a default 'f%i' is substituted.  If the argument
+    `names` is not None, updates the field names to valid names.
+
+    """
+    ndescr = len(descr)
+    default_names = ['f%i' % i for i in range(ndescr)]
+    if names is None:
+        new_names = default_names
+    else:
+        if isinstance(names, (tuple, list)):
+            new_names = names
+        elif isinstance(names, str):
+            new_names = names.split(',')
+        else:
+            raise NameError(f'illegal input names {names!r}')
+        nnames = len(new_names)
+        if nnames < ndescr:
+            new_names += default_names[nnames:]
+    ndescr = []
+    for (n, d, t) in zip(new_names, default_names, descr.descr):
+        if n in reserved_fields:
+            if t[0] in reserved_fields:
+                ndescr.append((d, t[1]))
+            else:
+                ndescr.append(t)
+        else:
+            ndescr.append((n, t[1]))
+    return np.dtype(ndescr)
+
+
+def _get_fieldmask(self):
+    mdescr = [(n, '|b1') for n in self.dtype.names]
+    fdmask = np.empty(self.shape, dtype=mdescr)
+    fdmask.flat = tuple([False] * len(mdescr))
+    return fdmask
+
+
+class MaskedRecords(MaskedArray):
+    """
+
+    Attributes
+    ----------
+    _data : recarray
+        Underlying data, as a record array.
+    _mask : boolean array
+        Mask of the records. A record is masked when all its fields are
+        masked.
+    _fieldmask : boolean recarray
+        Record array of booleans, setting the mask of each individual field
+        of each record.
+    _fill_value : record
+        Filling values for each field.
+
+    """
+
+    def __new__(cls, shape, dtype=None, buf=None, offset=0, strides=None,
+                formats=None, names=None, titles=None,
+                byteorder=None, aligned=False,
+                mask=nomask, hard_mask=False, fill_value=None, keep_mask=True,
+                copy=False,
+                **options):
+
+        self = recarray.__new__(cls, shape, dtype=dtype, buf=buf, offset=offset,
+                                strides=strides, formats=formats, names=names,
+                                titles=titles, byteorder=byteorder,
+                                aligned=aligned,)
+
+        mdtype = ma.make_mask_descr(self.dtype)
+        if mask is nomask or not np.size(mask):
+            if not keep_mask:
+                self._mask = tuple([False] * len(mdtype))
+        else:
+            mask = np.array(mask, copy=copy)
+            if mask.shape != self.shape:
+                (nd, nm) = (self.size, mask.size)
+                if nm == 1:
+                    mask = np.resize(mask, self.shape)
+                elif nm == nd:
+                    mask = np.reshape(mask, self.shape)
+                else:
+                    msg = "Mask and data not compatible: data size is %i, " + \
+                          "mask size is %i."
+                    raise MAError(msg % (nd, nm))
+            if not keep_mask:
+                self.__setmask__(mask)
+                self._sharedmask = True
+            else:
+                if mask.dtype == mdtype:
+                    _mask = mask
+                else:
+                    _mask = np.array([tuple([m] * len(mdtype)) for m in mask],
+                                     dtype=mdtype)
+                self._mask = _mask
+        return self
+
+    def __array_finalize__(self, obj):
+        # Make sure we have a _fieldmask by default
+        _mask = getattr(obj, '_mask', None)
+        if _mask is None:
+            objmask = getattr(obj, '_mask', nomask)
+            _dtype = ndarray.__getattribute__(self, 'dtype')
+            if objmask is nomask:
+                _mask = ma.make_mask_none(self.shape, dtype=_dtype)
+            else:
+                mdescr = ma.make_mask_descr(_dtype)
+                _mask = narray([tuple([m] * len(mdescr)) for m in objmask],
+                               dtype=mdescr).view(recarray)
+        # Update some of the attributes
+        _dict = self.__dict__
+        _dict.update(_mask=_mask)
+        self._update_from(obj)
+        if _dict['_baseclass'] == ndarray:
+            _dict['_baseclass'] = recarray
+        return
+
+    @property
+    def _data(self):
+        """
+        Returns the data as a recarray.
+
+        """
+        return ndarray.view(self, recarray)
+
+    @property
+    def _fieldmask(self):
+        """
+        Alias to mask.
+
+        """
+        return self._mask
+
+    def __len__(self):
+        """
+        Returns the length
+
+        """
+        # We have more than one record
+        if self.ndim:
+            return len(self._data)
+        # We have only one record: return the nb of fields
+        return len(self.dtype)
+
+    def __getattribute__(self, attr):
+        try:
+            return object.__getattribute__(self, attr)
+        except AttributeError:
+            # attr must be a fieldname
+            pass
+        fielddict = ndarray.__getattribute__(self, 'dtype').fields
+        try:
+            res = fielddict[attr][:2]
+        except (TypeError, KeyError) as e:
+            raise AttributeError(
+                f'record array has no attribute {attr}') from e
+        # So far, so good
+        _localdict = ndarray.__getattribute__(self, '__dict__')
+        _data = ndarray.view(self, _localdict['_baseclass'])
+        obj = _data.getfield(*res)
+        if obj.dtype.names is not None:
+            raise NotImplementedError("MaskedRecords is currently limited to"
+                                      "simple records.")
+        # Get some special attributes
+        # Reset the object's mask
+        hasmasked = False
+        _mask = _localdict.get('_mask', None)
+        if _mask is not None:
+            try:
+                _mask = _mask[attr]
+            except IndexError:
+                # Couldn't find a mask: use the default (nomask)
+                pass
+            tp_len = len(_mask.dtype)
+            hasmasked = _mask.view((bool, ((tp_len,) if tp_len else ()))).any()
+        if (obj.shape or hasmasked):
+            obj = obj.view(MaskedArray)
+            obj._baseclass = ndarray
+            obj._isfield = True
+            obj._mask = _mask
+            # Reset the field values
+            _fill_value = _localdict.get('_fill_value', None)
+            if _fill_value is not None:
+                try:
+                    obj._fill_value = _fill_value[attr]
+                except ValueError:
+                    obj._fill_value = None
+        else:
+            obj = obj.item()
+        return obj
+
+    def __setattr__(self, attr, val):
+        """
+        Sets the attribute attr to the value val.
+
+        """
+        # Should we call __setmask__ first ?
+        if attr in ['mask', 'fieldmask']:
+            self.__setmask__(val)
+            return
+        # Create a shortcut (so that we don't have to call getattr all the time)
+        _localdict = object.__getattribute__(self, '__dict__')
+        # Check whether we're creating a new field
+        newattr = attr not in _localdict
+        try:
+            # Is attr a generic attribute ?
+            ret = object.__setattr__(self, attr, val)
+        except Exception:
+            # Not a generic attribute: exit if it's not a valid field
+            fielddict = ndarray.__getattribute__(self, 'dtype').fields or {}
+            optinfo = ndarray.__getattribute__(self, '_optinfo') or {}
+            if not (attr in fielddict or attr in optinfo):
+                raise
+        else:
+            # Get the list of names
+            fielddict = ndarray.__getattribute__(self, 'dtype').fields or {}
+            # Check the attribute
+            if attr not in fielddict:
+                return ret
+            if newattr:
+                # We just added this one or this setattr worked on an
+                # internal attribute.
+                try:
+                    object.__delattr__(self, attr)
+                except Exception:
+                    return ret
+        # Let's try to set the field
+        try:
+            res = fielddict[attr][:2]
+        except (TypeError, KeyError) as e:
+            raise AttributeError(
+                f'record array has no attribute {attr}') from e
+
+        if val is masked:
+            _fill_value = _localdict['_fill_value']
+            if _fill_value is not None:
+                dval = _localdict['_fill_value'][attr]
+            else:
+                dval = val
+            mval = True
+        else:
+            dval = filled(val)
+            mval = getmaskarray(val)
+        obj = ndarray.__getattribute__(self, '_data').setfield(dval, *res)
+        _localdict['_mask'].__setitem__(attr, mval)
+        return obj
+
+    def __getitem__(self, indx):
+        """
+        Returns all the fields sharing the same fieldname base.
+
+        The fieldname base is either `_data` or `_mask`.
+
+        """
+        _localdict = self.__dict__
+        _mask = ndarray.__getattribute__(self, '_mask')
+        _data = ndarray.view(self, _localdict['_baseclass'])
+        # We want a field
+        if isinstance(indx, str):
+            # Make sure _sharedmask is True to propagate back to _fieldmask
+            # Don't use _set_mask, there are some copies being made that
+            # break propagation Don't force the mask to nomask, that wreaks
+            # easy masking
+            obj = _data[indx].view(MaskedArray)
+            obj._mask = _mask[indx]
+            obj._sharedmask = True
+            fval = _localdict['_fill_value']
+            if fval is not None:
+                obj._fill_value = fval[indx]
+            # Force to masked if the mask is True
+            if not obj.ndim and obj._mask:
+                return masked
+            return obj
+        # We want some elements.
+        # First, the data.
+        obj = np.array(_data[indx], copy=False).view(mrecarray)
+        obj._mask = np.array(_mask[indx], copy=False).view(recarray)
+        return obj
+
+    def __setitem__(self, indx, value):
+        """
+        Sets the given record to value.
+
+        """
+        MaskedArray.__setitem__(self, indx, value)
+        if isinstance(indx, str):
+            self._mask[indx] = ma.getmaskarray(value)
+
+    def __str__(self):
+        """
+        Calculates the string representation.
+
+        """
+        if self.size > 1:
+            mstr = [f"({','.join([str(i) for i in s])})"
+                    for s in zip(*[getattr(self, f) for f in self.dtype.names])]
+            return f"[{', '.join(mstr)}]"
+        else:
+            mstr = [f"{','.join([str(i) for i in s])}"
+                    for s in zip([getattr(self, f) for f in self.dtype.names])]
+            return f"({', '.join(mstr)})"
+
+    def __repr__(self):
+        """
+        Calculates the repr representation.
+
+        """
+        _names = self.dtype.names
+        fmt = "%%%is : %%s" % (max([len(n) for n in _names]) + 4,)
+        reprstr = [fmt % (f, getattr(self, f)) for f in self.dtype.names]
+        reprstr.insert(0, 'masked_records(')
+        reprstr.extend([fmt % ('    fill_value', self.fill_value),
+                        '              )'])
+        return str("\n".join(reprstr))
+
+    def view(self, dtype=None, type=None):
+        """
+        Returns a view of the mrecarray.
+
+        """
+        # OK, basic copy-paste from MaskedArray.view.
+        if dtype is None:
+            if type is None:
+                output = ndarray.view(self)
+            else:
+                output = ndarray.view(self, type)
+        # Here again.
+        elif type is None:
+            try:
+                if issubclass(dtype, ndarray):
+                    output = ndarray.view(self, dtype)
+                else:
+                    output = ndarray.view(self, dtype)
+            # OK, there's the change
+            except TypeError:
+                dtype = np.dtype(dtype)
+                # we need to revert to MaskedArray, but keeping the possibility
+                # of subclasses (eg, TimeSeriesRecords), so we'll force a type
+                # set to the first parent
+                if dtype.fields is None:
+                    basetype = self.__class__.__bases__[0]
+                    output = self.__array__().view(dtype, basetype)
+                    output._update_from(self)
+                else:
+                    output = ndarray.view(self, dtype)
+                output._fill_value = None
+        else:
+            output = ndarray.view(self, dtype, type)
+        # Update the mask, just like in MaskedArray.view
+        if (getattr(output, '_mask', nomask) is not nomask):
+            mdtype = ma.make_mask_descr(output.dtype)
+            output._mask = self._mask.view(mdtype, ndarray)
+            output._mask.shape = output.shape
+        return output
+
+    def harden_mask(self):
+        """
+        Forces the mask to hard.
+
+        """
+        self._hardmask = True
+
+    def soften_mask(self):
+        """
+        Forces the mask to soft
+
+        """
+        self._hardmask = False
+
+    def copy(self):
+        """
+        Returns a copy of the masked record.
+
+        """
+        copied = self._data.copy().view(type(self))
+        copied._mask = self._mask.copy()
+        return copied
+
+    def tolist(self, fill_value=None):
+        """
+        Return the data portion of the array as a list.
+
+        Data items are converted to the nearest compatible Python type.
+        Masked values are converted to fill_value. If fill_value is None,
+        the corresponding entries in the output list will be ``None``.
+
+        """
+        if fill_value is not None:
+            return self.filled(fill_value).tolist()
+        result = narray(self.filled().tolist(), dtype=object)
+        mask = narray(self._mask.tolist())
+        result[mask] = None
+        return result.tolist()
+
+    def __getstate__(self):
+        """Return the internal state of the masked array.
+
+        This is for pickling.
+
+        """
+        state = (1,
+                 self.shape,
+                 self.dtype,
+                 self.flags.fnc,
+                 self._data.tobytes(),
+                 self._mask.tobytes(),
+                 self._fill_value,
+                 )
+        return state
+
+    def __setstate__(self, state):
+        """
+        Restore the internal state of the masked array.
+
+        This is for pickling.  ``state`` is typically the output of the
+        ``__getstate__`` output, and is a 5-tuple:
+
+        - class name
+        - a tuple giving the shape of the data
+        - a typecode for the data
+        - a binary string for the data
+        - a binary string for the mask.
+
+        """
+        (ver, shp, typ, isf, raw, msk, flv) = state
+        ndarray.__setstate__(self, (shp, typ, isf, raw))
+        mdtype = dtype([(k, bool_) for (k, _) in self.dtype.descr])
+        self.__dict__['_mask'].__setstate__((shp, mdtype, isf, msk))
+        self.fill_value = flv
+
+    def __reduce__(self):
+        """
+        Return a 3-tuple for pickling a MaskedArray.
+
+        """
+        return (_mrreconstruct,
+                (self.__class__, self._baseclass, (0,), 'b',),
+                self.__getstate__())
+
+
+def _mrreconstruct(subtype, baseclass, baseshape, basetype,):
+    """
+    Build a new MaskedArray from the information stored in a pickle.
+
+    """
+    _data = ndarray.__new__(baseclass, baseshape, basetype).view(subtype)
+    _mask = ndarray.__new__(ndarray, baseshape, 'b1')
+    return subtype.__new__(subtype, _data, mask=_mask, dtype=basetype,)
+
+mrecarray = MaskedRecords
+
+
+###############################################################################
+#                             Constructors                                    #
+###############################################################################
+
+
+def fromarrays(arraylist, dtype=None, shape=None, formats=None,
+               names=None, titles=None, aligned=False, byteorder=None,
+               fill_value=None):
+    """
+    Creates a mrecarray from a (flat) list of masked arrays.
+
+    Parameters
+    ----------
+    arraylist : sequence
+        A list of (masked) arrays. Each element of the sequence is first converted
+        to a masked array if needed. If a 2D array is passed as argument, it is
+        processed line by line
+    dtype : {None, dtype}, optional
+        Data type descriptor.
+    shape : {None, integer}, optional
+        Number of records. If None, shape is defined from the shape of the
+        first array in the list.
+    formats : {None, sequence}, optional
+        Sequence of formats for each individual field. If None, the formats will
+        be autodetected by inspecting the fields and selecting the highest dtype
+        possible.
+    names : {None, sequence}, optional
+        Sequence of the names of each field.
+    fill_value : {None, sequence}, optional
+        Sequence of data to be used as filling values.
+
+    Notes
+    -----
+    Lists of tuples should be preferred over lists of lists for faster processing.
+
+    """
+    datalist = [getdata(x) for x in arraylist]
+    masklist = [np.atleast_1d(getmaskarray(x)) for x in arraylist]
+    _array = recfromarrays(datalist,
+                           dtype=dtype, shape=shape, formats=formats,
+                           names=names, titles=titles, aligned=aligned,
+                           byteorder=byteorder).view(mrecarray)
+    _array._mask.flat = list(zip(*masklist))
+    if fill_value is not None:
+        _array.fill_value = fill_value
+    return _array
+
+
+def fromrecords(reclist, dtype=None, shape=None, formats=None, names=None,
+                titles=None, aligned=False, byteorder=None,
+                fill_value=None, mask=nomask):
+    """
+    Creates a MaskedRecords from a list of records.
+
+    Parameters
+    ----------
+    reclist : sequence
+        A list of records. Each element of the sequence is first converted
+        to a masked array if needed. If a 2D array is passed as argument, it is
+        processed line by line
+    dtype : {None, dtype}, optional
+        Data type descriptor.
+    shape : {None,int}, optional
+        Number of records. If None, ``shape`` is defined from the shape of the
+        first array in the list.
+    formats : {None, sequence}, optional
+        Sequence of formats for each individual field. If None, the formats will
+        be autodetected by inspecting the fields and selecting the highest dtype
+        possible.
+    names : {None, sequence}, optional
+        Sequence of the names of each field.
+    fill_value : {None, sequence}, optional
+        Sequence of data to be used as filling values.
+    mask : {nomask, sequence}, optional.
+        External mask to apply on the data.
+
+    Notes
+    -----
+    Lists of tuples should be preferred over lists of lists for faster processing.
+
+    """
+    # Grab the initial _fieldmask, if needed:
+    _mask = getattr(reclist, '_mask', None)
+    # Get the list of records.
+    if isinstance(reclist, ndarray):
+        # Make sure we don't have some hidden mask
+        if isinstance(reclist, MaskedArray):
+            reclist = reclist.filled().view(ndarray)
+        # Grab the initial dtype, just in case
+        if dtype is None:
+            dtype = reclist.dtype
+        reclist = reclist.tolist()
+    mrec = recfromrecords(reclist, dtype=dtype, shape=shape, formats=formats,
+                          names=names, titles=titles,
+                          aligned=aligned, byteorder=byteorder).view(mrecarray)
+    # Set the fill_value if needed
+    if fill_value is not None:
+        mrec.fill_value = fill_value
+    # Now, let's deal w/ the mask
+    if mask is not nomask:
+        mask = np.array(mask, copy=False)
+        maskrecordlength = len(mask.dtype)
+        if maskrecordlength:
+            mrec._mask.flat = mask
+        elif mask.ndim == 2:
+            mrec._mask.flat = [tuple(m) for m in mask]
+        else:
+            mrec.__setmask__(mask)
+    if _mask is not None:
+        mrec._mask[:] = _mask
+    return mrec
+
+
+def _guessvartypes(arr):
+    """
+    Tries to guess the dtypes of the str_ ndarray `arr`.
+
+    Guesses by testing element-wise conversion. Returns a list of dtypes.
+    The array is first converted to ndarray. If the array is 2D, the test
+    is performed on the first line. An exception is raised if the file is
+    3D or more.
+
+    """
+    vartypes = []
+    arr = np.asarray(arr)
+    if arr.ndim == 2:
+        arr = arr[0]
+    elif arr.ndim > 2:
+        raise ValueError("The array should be 2D at most!")
+    # Start the conversion loop.
+    for f in arr:
+        try:
+            int(f)
+        except (ValueError, TypeError):
+            try:
+                float(f)
+            except (ValueError, TypeError):
+                try:
+                    complex(f)
+                except (ValueError, TypeError):
+                    vartypes.append(arr.dtype)
+                else:
+                    vartypes.append(np.dtype(complex))
+            else:
+                vartypes.append(np.dtype(float))
+        else:
+            vartypes.append(np.dtype(int))
+    return vartypes
+
+
+def openfile(fname):
+    """
+    Opens the file handle of file `fname`.
+
+    """
+    # A file handle
+    if hasattr(fname, 'readline'):
+        return fname
+    # Try to open the file and guess its type
+    try:
+        f = open(fname)
+    except FileNotFoundError as e:
+        raise FileNotFoundError(f"No such file: '{fname}'") from e
+    if f.readline()[:2] != "\\x":
+        f.seek(0, 0)
+        return f
+    f.close()
+    raise NotImplementedError("Wow, binary file")
+
+
+def fromtextfile(fname, delimiter=None, commentchar='#', missingchar='',
+                 varnames=None, vartypes=None,
+                 *, delimitor=np._NoValue):  # backwards compatibility
+    """
+    Creates a mrecarray from data stored in the file `filename`.
+
+    Parameters
+    ----------
+    fname : {file name/handle}
+        Handle of an opened file.
+    delimiter : {None, string}, optional
+        Alphanumeric character used to separate columns in the file.
+        If None, any (group of) white spacestring(s) will be used.
+    commentchar : {'#', string}, optional
+        Alphanumeric character used to mark the start of a comment.
+    missingchar : {'', string}, optional
+        String indicating missing data, and used to create the masks.
+    varnames : {None, sequence}, optional
+        Sequence of the variable names. If None, a list will be created from
+        the first non empty line of the file.
+    vartypes : {None, sequence}, optional
+        Sequence of the variables dtypes. If None, it will be estimated from
+        the first non-commented line.
+
+
+    Ultra simple: the varnames are in the header, one line"""
+    if delimitor is not np._NoValue:
+        if delimiter is not None:
+            raise TypeError("fromtextfile() got multiple values for argument "
+                            "'delimiter'")
+        # NumPy 1.22.0, 2021-09-23
+        warnings.warn("The 'delimitor' keyword argument of "
+                      "numpy.ma.mrecords.fromtextfile() is deprecated "
+                      "since NumPy 1.22.0, use 'delimiter' instead.",
+                      DeprecationWarning, stacklevel=2)
+        delimiter = delimitor
+
+    # Try to open the file.
+    ftext = openfile(fname)
+
+    # Get the first non-empty line as the varnames
+    while True:
+        line = ftext.readline()
+        firstline = line[:line.find(commentchar)].strip()
+        _varnames = firstline.split(delimiter)
+        if len(_varnames) > 1:
+            break
+    if varnames is None:
+        varnames = _varnames
+
+    # Get the data.
+    _variables = masked_array([line.strip().split(delimiter) for line in ftext
+                               if line[0] != commentchar and len(line) > 1])
+    (_, nfields) = _variables.shape
+    ftext.close()
+
+    # Try to guess the dtype.
+    if vartypes is None:
+        vartypes = _guessvartypes(_variables[0])
+    else:
+        vartypes = [np.dtype(v) for v in vartypes]
+        if len(vartypes) != nfields:
+            msg = "Attempting to %i dtypes for %i fields!"
+            msg += " Reverting to default."
+            warnings.warn(msg % (len(vartypes), nfields), stacklevel=2)
+            vartypes = _guessvartypes(_variables[0])
+
+    # Construct the descriptor.
+    mdescr = [(n, f) for (n, f) in zip(varnames, vartypes)]
+    mfillv = [ma.default_fill_value(f) for f in vartypes]
+
+    # Get the data and the mask.
+    # We just need a list of masked_arrays. It's easier to create it like that:
+    _mask = (_variables.T == missingchar)
+    _datalist = [masked_array(a, mask=m, dtype=t, fill_value=f)
+                 for (a, m, t, f) in zip(_variables.T, _mask, vartypes, mfillv)]
+
+    return fromarrays(_datalist, dtype=mdescr)
+
+
+def addfield(mrecord, newfield, newfieldname=None):
+    """Adds a new field to the masked record array
+
+    Uses `newfield` as data and `newfieldname` as name. If `newfieldname`
+    is None, the new field name is set to 'fi', where `i` is the number of
+    existing fields.
+
+    """
+    _data = mrecord._data
+    _mask = mrecord._mask
+    if newfieldname is None or newfieldname in reserved_fields:
+        newfieldname = 'f%i' % len(_data.dtype)
+    newfield = ma.array(newfield)
+    # Get the new data.
+    # Create a new empty recarray
+    newdtype = np.dtype(_data.dtype.descr + [(newfieldname, newfield.dtype)])
+    newdata = recarray(_data.shape, newdtype)
+    # Add the existing field
+    [newdata.setfield(_data.getfield(*f), *f)
+     for f in _data.dtype.fields.values()]
+    # Add the new field
+    newdata.setfield(newfield._data, *newdata.dtype.fields[newfieldname])
+    newdata = newdata.view(MaskedRecords)
+    # Get the new mask
+    # Create a new empty recarray
+    newmdtype = np.dtype([(n, bool_) for n in newdtype.names])
+    newmask = recarray(_data.shape, newmdtype)
+    # Add the old masks
+    [newmask.setfield(_mask.getfield(*f), *f)
+     for f in _mask.dtype.fields.values()]
+    # Add the mask of the new field
+    newmask.setfield(getmaskarray(newfield),
+                     *newmask.dtype.fields[newfieldname])
+    newdata._mask = newmask
+    return newdata

llava_next/lib/python3.10/site-packages/numpy/ma/mrecords.pyi

@@ -0,0 +1,90 @@
+from typing import Any, TypeVar
+
+from numpy import dtype
+from numpy.ma import MaskedArray
+
+__all__: list[str]
+
+# TODO: Set the `bound` to something more suitable once we
+# have proper shape support
+_ShapeType = TypeVar("_ShapeType", bound=Any)
+_DType_co = TypeVar("_DType_co", bound=dtype[Any], covariant=True)
+
+class MaskedRecords(MaskedArray[_ShapeType, _DType_co]):
+    def __new__(
+        cls,
+        shape,
+        dtype=...,
+        buf=...,
+        offset=...,
+        strides=...,
+        formats=...,
+        names=...,
+        titles=...,
+        byteorder=...,
+        aligned=...,
+        mask=...,
+        hard_mask=...,
+        fill_value=...,
+        keep_mask=...,
+        copy=...,
+        **options,
+    ): ...
+    _mask: Any
+    _fill_value: Any
+    @property
+    def _data(self): ...
+    @property
+    def _fieldmask(self): ...
+    def __array_finalize__(self, obj): ...
+    def __len__(self): ...
+    def __getattribute__(self, attr): ...
+    def __setattr__(self, attr, val): ...
+    def __getitem__(self, indx): ...
+    def __setitem__(self, indx, value): ...
+    def view(self, dtype=..., type=...): ...
+    def harden_mask(self): ...
+    def soften_mask(self): ...
+    def copy(self): ...
+    def tolist(self, fill_value=...): ...
+    def __reduce__(self): ...
+
+mrecarray = MaskedRecords
+
+def fromarrays(
+    arraylist,
+    dtype=...,
+    shape=...,
+    formats=...,
+    names=...,
+    titles=...,
+    aligned=...,
+    byteorder=...,
+    fill_value=...,
+): ...
+
+def fromrecords(
+    reclist,
+    dtype=...,
+    shape=...,
+    formats=...,
+    names=...,
+    titles=...,
+    aligned=...,
+    byteorder=...,
+    fill_value=...,
+    mask=...,
+): ...
+
+def fromtextfile(
+    fname,
+    delimiter=...,
+    commentchar=...,
+    missingchar=...,
+    varnames=...,
+    vartypes=...,
+    # NOTE: deprecated: NumPy 1.22.0, 2021-09-23
+    # delimitor=...,
+): ...
+
+def addfield(mrecord, newfield, newfieldname=...): ...

llava_next/lib/python3.10/site-packages/numpy/ma/setup.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+def configuration(parent_package='',top_path=None):
+    from numpy.distutils.misc_util import Configuration
+    config = Configuration('ma', parent_package, top_path)
+    config.add_subpackage('tests')
+    config.add_data_files('*.pyi')
+    return config
+
+if __name__ == "__main__":
+    from numpy.distutils.core import setup
+    config = configuration(top_path='').todict()
+    setup(**config)

llava_next/lib/python3.10/site-packages/numpy/ma/tests/test_old_ma.py

@@ -0,0 +1,874 @@
+from functools import reduce
+
+import pytest
+
+import numpy as np
+import numpy.core.umath as umath
+import numpy.core.fromnumeric as fromnumeric
+from numpy.testing import (
+    assert_, assert_raises, assert_equal,
+    )
+from numpy.ma import (
+    MaskType, MaskedArray, absolute, add, all, allclose, allequal, alltrue,
+    arange, arccos, arcsin, arctan, arctan2, array, average, choose,
+    concatenate, conjugate, cos, cosh, count, divide, equal, exp, filled,
+    getmask, greater, greater_equal, inner, isMaskedArray, less,
+    less_equal, log, log10, make_mask, masked, masked_array, masked_equal,
+    masked_greater, masked_greater_equal, masked_inside, masked_less,
+    masked_less_equal, masked_not_equal, masked_outside,
+    masked_print_option, masked_values, masked_where, maximum, minimum,
+    multiply, nomask, nonzero, not_equal, ones, outer, product, put, ravel,
+    repeat, resize, shape, sin, sinh, sometrue, sort, sqrt, subtract, sum,
+    take, tan, tanh, transpose, where, zeros,
+    )
+from numpy.compat import pickle
+
+pi = np.pi
+
+
+def eq(v, w, msg=''):
+    result = allclose(v, w)
+    if not result:
+        print(f'Not eq:{msg}\n{v}\n----{w}')
+    return result
+
+
+class TestMa:
+
+    def setup_method(self):
+        x = np.array([1., 1., 1., -2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
+        y = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
+        a10 = 10.
+        m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
+        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1]
+        xm = array(x, mask=m1)
+        ym = array(y, mask=m2)
+        z = np.array([-.5, 0., .5, .8])
+        zm = array(z, mask=[0, 1, 0, 0])
+        xf = np.where(m1, 1e+20, x)
+        s = x.shape
+        xm.set_fill_value(1e+20)
+        self.d = (x, y, a10, m1, m2, xm, ym, z, zm, xf, s)
+
+    def test_testBasic1d(self):
+        # Test of basic array creation and properties in 1 dimension.
+        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
+        assert_(not isMaskedArray(x))
+        assert_(isMaskedArray(xm))
+        assert_equal(shape(xm), s)
+        assert_equal(xm.shape, s)
+        assert_equal(xm.dtype, x.dtype)
+        assert_equal(xm.size, reduce(lambda x, y:x * y, s))
+        assert_equal(count(xm), len(m1) - reduce(lambda x, y:x + y, m1))
+        assert_(eq(xm, xf))
+        assert_(eq(filled(xm, 1.e20), xf))
+        assert_(eq(x, xm))
+
+    @pytest.mark.parametrize("s", [(4, 3), (6, 2)])
+    def test_testBasic2d(self, s):
+        # Test of basic array creation and properties in 2 dimensions.
+        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
+        x.shape = s
+        y.shape = s
+        xm.shape = s
+        ym.shape = s
+        xf.shape = s
+
+        assert_(not isMaskedArray(x))
+        assert_(isMaskedArray(xm))
+        assert_equal(shape(xm), s)
+        assert_equal(xm.shape, s)
+        assert_equal(xm.size, reduce(lambda x, y: x * y, s))
+        assert_equal(count(xm), len(m1) - reduce(lambda x, y: x + y, m1))
+        assert_(eq(xm, xf))
+        assert_(eq(filled(xm, 1.e20), xf))
+        assert_(eq(x, xm))
+
+    def test_testArithmetic(self):
+        # Test of basic arithmetic.
+        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
+        a2d = array([[1, 2], [0, 4]])
+        a2dm = masked_array(a2d, [[0, 0], [1, 0]])
+        assert_(eq(a2d * a2d, a2d * a2dm))
+        assert_(eq(a2d + a2d, a2d + a2dm))
+        assert_(eq(a2d - a2d, a2d - a2dm))
+        for s in [(12,), (4, 3), (2, 6)]:
+            x = x.reshape(s)
+            y = y.reshape(s)
+            xm = xm.reshape(s)
+            ym = ym.reshape(s)
+            xf = xf.reshape(s)
+            assert_(eq(-x, -xm))
+            assert_(eq(x + y, xm + ym))
+            assert_(eq(x - y, xm - ym))
+            assert_(eq(x * y, xm * ym))
+            with np.errstate(divide='ignore', invalid='ignore'):
+                assert_(eq(x / y, xm / ym))
+            assert_(eq(a10 + y, a10 + ym))
+            assert_(eq(a10 - y, a10 - ym))
+            assert_(eq(a10 * y, a10 * ym))
+            with np.errstate(divide='ignore', invalid='ignore'):
+                assert_(eq(a10 / y, a10 / ym))
+            assert_(eq(x + a10, xm + a10))
+            assert_(eq(x - a10, xm - a10))
+            assert_(eq(x * a10, xm * a10))
+            assert_(eq(x / a10, xm / a10))
+            assert_(eq(x ** 2, xm ** 2))
+            assert_(eq(abs(x) ** 2.5, abs(xm) ** 2.5))
+            assert_(eq(x ** y, xm ** ym))
+            assert_(eq(np.add(x, y), add(xm, ym)))
+            assert_(eq(np.subtract(x, y), subtract(xm, ym)))
+            assert_(eq(np.multiply(x, y), multiply(xm, ym)))
+            with np.errstate(divide='ignore', invalid='ignore'):
+                assert_(eq(np.divide(x, y), divide(xm, ym)))
+
+    def test_testMixedArithmetic(self):
+        na = np.array([1])
+        ma = array([1])
+        assert_(isinstance(na + ma, MaskedArray))
+        assert_(isinstance(ma + na, MaskedArray))
+
+    def test_testUfuncs1(self):
+        # Test various functions such as sin, cos.
+        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
+        assert_(eq(np.cos(x), cos(xm)))
+        assert_(eq(np.cosh(x), cosh(xm)))
+        assert_(eq(np.sin(x), sin(xm)))
+        assert_(eq(np.sinh(x), sinh(xm)))
+        assert_(eq(np.tan(x), tan(xm)))
+        assert_(eq(np.tanh(x), tanh(xm)))
+        with np.errstate(divide='ignore', invalid='ignore'):
+            assert_(eq(np.sqrt(abs(x)), sqrt(xm)))
+            assert_(eq(np.log(abs(x)), log(xm)))
+            assert_(eq(np.log10(abs(x)), log10(xm)))
+        assert_(eq(np.exp(x), exp(xm)))
+        assert_(eq(np.arcsin(z), arcsin(zm)))
+        assert_(eq(np.arccos(z), arccos(zm)))
+        assert_(eq(np.arctan(z), arctan(zm)))
+        assert_(eq(np.arctan2(x, y), arctan2(xm, ym)))
+        assert_(eq(np.absolute(x), absolute(xm)))
+        assert_(eq(np.equal(x, y), equal(xm, ym)))
+        assert_(eq(np.not_equal(x, y), not_equal(xm, ym)))
+        assert_(eq(np.less(x, y), less(xm, ym)))
+        assert_(eq(np.greater(x, y), greater(xm, ym)))
+        assert_(eq(np.less_equal(x, y), less_equal(xm, ym)))
+        assert_(eq(np.greater_equal(x, y), greater_equal(xm, ym)))
+        assert_(eq(np.conjugate(x), conjugate(xm)))
+        assert_(eq(np.concatenate((x, y)), concatenate((xm, ym))))
+        assert_(eq(np.concatenate((x, y)), concatenate((x, y))))
+        assert_(eq(np.concatenate((x, y)), concatenate((xm, y))))
+        assert_(eq(np.concatenate((x, y, x)), concatenate((x, ym, x))))
+
+    def test_xtestCount(self):
+        # Test count
+        ott = array([0., 1., 2., 3.], mask=[1, 0, 0, 0])
+        assert_(count(ott).dtype.type is np.intp)
+        assert_equal(3, count(ott))
+        assert_equal(1, count(1))
+        assert_(eq(0, array(1, mask=[1])))
+        ott = ott.reshape((2, 2))
+        assert_(count(ott).dtype.type is np.intp)
+        assert_(isinstance(count(ott, 0), np.ndarray))
+        assert_(count(ott).dtype.type is np.intp)
+        assert_(eq(3, count(ott)))
+        assert_(getmask(count(ott, 0)) is nomask)
+        assert_(eq([1, 2], count(ott, 0)))
+
+    def test_testMinMax(self):
+        # Test minimum and maximum.
+        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
+        xr = np.ravel(x)  # max doesn't work if shaped
+        xmr = ravel(xm)
+
+        # true because of careful selection of data
+        assert_(eq(max(xr), maximum.reduce(xmr)))
+        assert_(eq(min(xr), minimum.reduce(xmr)))
+
+    def test_testAddSumProd(self):
+        # Test add, sum, product.
+        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
+        assert_(eq(np.add.reduce(x), add.reduce(x)))
+        assert_(eq(np.add.accumulate(x), add.accumulate(x)))
+        assert_(eq(4, sum(array(4), axis=0)))
+        assert_(eq(4, sum(array(4), axis=0)))
+        assert_(eq(np.sum(x, axis=0), sum(x, axis=0)))
+        assert_(eq(np.sum(filled(xm, 0), axis=0), sum(xm, axis=0)))
+        assert_(eq(np.sum(x, 0), sum(x, 0)))
+        assert_(eq(np.prod(x, axis=0), product(x, axis=0)))
+        assert_(eq(np.prod(x, 0), product(x, 0)))
+        assert_(eq(np.prod(filled(xm, 1), axis=0),
+                           product(xm, axis=0)))
+        if len(s) > 1:
+            assert_(eq(np.concatenate((x, y), 1),
+                               concatenate((xm, ym), 1)))
+            assert_(eq(np.add.reduce(x, 1), add.reduce(x, 1)))
+            assert_(eq(np.sum(x, 1), sum(x, 1)))
+            assert_(eq(np.prod(x, 1), product(x, 1)))
+
+    def test_testCI(self):
+        # Test of conversions and indexing
+        x1 = np.array([1, 2, 4, 3])
+        x2 = array(x1, mask=[1, 0, 0, 0])
+        x3 = array(x1, mask=[0, 1, 0, 1])
+        x4 = array(x1)
+        # test conversion to strings
+        str(x2)  # raises?
+        repr(x2)  # raises?
+        assert_(eq(np.sort(x1), sort(x2, fill_value=0)))
+        # tests of indexing
+        assert_(type(x2[1]) is type(x1[1]))
+        assert_(x1[1] == x2[1])
+        assert_(x2[0] is masked)
+        assert_(eq(x1[2], x2[2]))
+        assert_(eq(x1[2:5], x2[2:5]))
+        assert_(eq(x1[:], x2[:]))
+        assert_(eq(x1[1:], x3[1:]))
+        x1[2] = 9
+        x2[2] = 9
+        assert_(eq(x1, x2))
+        x1[1:3] = 99
+        x2[1:3] = 99
+        assert_(eq(x1, x2))
+        x2[1] = masked
+        assert_(eq(x1, x2))
+        x2[1:3] = masked
+        assert_(eq(x1, x2))
+        x2[:] = x1
+        x2[1] = masked
+        assert_(allequal(getmask(x2), array([0, 1, 0, 0])))
+        x3[:] = masked_array([1, 2, 3, 4], [0, 1, 1, 0])
+        assert_(allequal(getmask(x3), array([0, 1, 1, 0])))
+        x4[:] = masked_array([1, 2, 3, 4], [0, 1, 1, 0])
+        assert_(allequal(getmask(x4), array([0, 1, 1, 0])))
+        assert_(allequal(x4, array([1, 2, 3, 4])))
+        x1 = np.arange(5) * 1.0
+        x2 = masked_values(x1, 3.0)
+        assert_(eq(x1, x2))
+        assert_(allequal(array([0, 0, 0, 1, 0], MaskType), x2.mask))
+        assert_(eq(3.0, x2.fill_value))
+        x1 = array([1, 'hello', 2, 3], object)
+        x2 = np.array([1, 'hello', 2, 3], object)
+        s1 = x1[1]
+        s2 = x2[1]
+        assert_equal(type(s2), str)
+        assert_equal(type(s1), str)
+        assert_equal(s1, s2)
+        assert_(x1[1:1].shape == (0,))
+
+    def test_testCopySize(self):
+        # Tests of some subtle points of copying and sizing.
+        n = [0, 0, 1, 0, 0]
+        m = make_mask(n)
+        m2 = make_mask(m)
+        assert_(m is m2)
+        m3 = make_mask(m, copy=True)
+        assert_(m is not m3)
+
+        x1 = np.arange(5)
+        y1 = array(x1, mask=m)
+        assert_(y1._data is not x1)
+        assert_(allequal(x1, y1._data))
+        assert_(y1._mask is m)
+
+        y1a = array(y1, copy=0)
+        # For copy=False, one might expect that the array would just
+        # passed on, i.e., that it would be "is" instead of "==".
+        # See gh-4043 for discussion.
+        assert_(y1a._mask.__array_interface__ ==
+                y1._mask.__array_interface__)
+
+        y2 = array(x1, mask=m3, copy=0)
+        assert_(y2._mask is m3)
+        assert_(y2[2] is masked)
+        y2[2] = 9
+        assert_(y2[2] is not masked)
+        assert_(y2._mask is m3)
+        assert_(allequal(y2.mask, 0))
+
+        y2a = array(x1, mask=m, copy=1)
+        assert_(y2a._mask is not m)
+        assert_(y2a[2] is masked)
+        y2a[2] = 9
+        assert_(y2a[2] is not masked)
+        assert_(y2a._mask is not m)
+        assert_(allequal(y2a.mask, 0))
+
+        y3 = array(x1 * 1.0, mask=m)
+        assert_(filled(y3).dtype is (x1 * 1.0).dtype)
+
+        x4 = arange(4)
+        x4[2] = masked
+        y4 = resize(x4, (8,))
+        assert_(eq(concatenate([x4, x4]), y4))
+        assert_(eq(getmask(y4), [0, 0, 1, 0, 0, 0, 1, 0]))
+        y5 = repeat(x4, (2, 2, 2, 2), axis=0)
+        assert_(eq(y5, [0, 0, 1, 1, 2, 2, 3, 3]))
+        y6 = repeat(x4, 2, axis=0)
+        assert_(eq(y5, y6))
+
+    def test_testPut(self):
+        # Test of put
+        d = arange(5)
+        n = [0, 0, 0, 1, 1]
+        m = make_mask(n)
+        m2 = m.copy()
+        x = array(d, mask=m)
+        assert_(x[3] is masked)
+        assert_(x[4] is masked)
+        x[[1, 4]] = [10, 40]
+        assert_(x._mask is m)
+        assert_(x[3] is masked)
+        assert_(x[4] is not masked)
+        assert_(eq(x, [0, 10, 2, -1, 40]))
+
+        x = array(d, mask=m2, copy=True)
+        x.put([0, 1, 2], [-1, 100, 200])
+        assert_(x._mask is not m2)
+        assert_(x[3] is masked)
+        assert_(x[4] is masked)
+        assert_(eq(x, [-1, 100, 200, 0, 0]))
+
+    def test_testPut2(self):
+        # Test of put
+        d = arange(5)
+        x = array(d, mask=[0, 0, 0, 0, 0])
+        z = array([10, 40], mask=[1, 0])
+        assert_(x[2] is not masked)
+        assert_(x[3] is not masked)
+        x[2:4] = z
+        assert_(x[2] is masked)
+        assert_(x[3] is not masked)
+        assert_(eq(x, [0, 1, 10, 40, 4]))
+
+        d = arange(5)
+        x = array(d, mask=[0, 0, 0, 0, 0])
+        y = x[2:4]
+        z = array([10, 40], mask=[1, 0])
+        assert_(x[2] is not masked)
+        assert_(x[3] is not masked)
+        y[:] = z
+        assert_(y[0] is masked)
+        assert_(y[1] is not masked)
+        assert_(eq(y, [10, 40]))
+        assert_(x[2] is masked)
+        assert_(x[3] is not masked)
+        assert_(eq(x, [0, 1, 10, 40, 4]))
+
+    def test_testMaPut(self):
+        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
+        m = [1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1]
+        i = np.nonzero(m)[0]
+        put(ym, i, zm)
+        assert_(all(take(ym, i, axis=0) == zm))
+
+    def test_testOddFeatures(self):
+        # Test of other odd features
+        x = arange(20)
+        x = x.reshape(4, 5)
+        x.flat[5] = 12
+        assert_(x[1, 0] == 12)
+        z = x + 10j * x
+        assert_(eq(z.real, x))
+        assert_(eq(z.imag, 10 * x))
+        assert_(eq((z * conjugate(z)).real, 101 * x * x))
+        z.imag[...] = 0.0
+
+        x = arange(10)
+        x[3] = masked
+        assert_(str(x[3]) == str(masked))
+        c = x >= 8
+        assert_(count(where(c, masked, masked)) == 0)
+        assert_(shape(where(c, masked, masked)) == c.shape)
+        z = where(c, x, masked)
+        assert_(z.dtype is x.dtype)
+        assert_(z[3] is masked)
+        assert_(z[4] is masked)
+        assert_(z[7] is masked)
+        assert_(z[8] is not masked)
+        assert_(z[9] is not masked)
+        assert_(eq(x, z))
+        z = where(c, masked, x)
+        assert_(z.dtype is x.dtype)
+        assert_(z[3] is masked)
+        assert_(z[4] is not masked)
+        assert_(z[7] is not masked)
+        assert_(z[8] is masked)
+        assert_(z[9] is masked)
+        z = masked_where(c, x)
+        assert_(z.dtype is x.dtype)
+        assert_(z[3] is masked)
+        assert_(z[4] is not masked)
+        assert_(z[7] is not masked)
+        assert_(z[8] is masked)
+        assert_(z[9] is masked)
+        assert_(eq(x, z))
+        x = array([1., 2., 3., 4., 5.])
+        c = array([1, 1, 1, 0, 0])
+        x[2] = masked
+        z = where(c, x, -x)
+        assert_(eq(z, [1., 2., 0., -4., -5]))
+        c[0] = masked
+        z = where(c, x, -x)
+        assert_(eq(z, [1., 2., 0., -4., -5]))
+        assert_(z[0] is masked)
+        assert_(z[1] is not masked)
+        assert_(z[2] is masked)
+        assert_(eq(masked_where(greater(x, 2), x), masked_greater(x, 2)))
+        assert_(eq(masked_where(greater_equal(x, 2), x),
+                   masked_greater_equal(x, 2)))
+        assert_(eq(masked_where(less(x, 2), x), masked_less(x, 2)))
+        assert_(eq(masked_where(less_equal(x, 2), x), masked_less_equal(x, 2)))
+        assert_(eq(masked_where(not_equal(x, 2), x), masked_not_equal(x, 2)))
+        assert_(eq(masked_where(equal(x, 2), x), masked_equal(x, 2)))
+        assert_(eq(masked_where(not_equal(x, 2), x), masked_not_equal(x, 2)))
+        assert_(eq(masked_inside(list(range(5)), 1, 3), [0, 199, 199, 199, 4]))
+        assert_(eq(masked_outside(list(range(5)), 1, 3), [199, 1, 2, 3, 199]))
+        assert_(eq(masked_inside(array(list(range(5)),
+                                       mask=[1, 0, 0, 0, 0]), 1, 3).mask,
+                   [1, 1, 1, 1, 0]))
+        assert_(eq(masked_outside(array(list(range(5)),
+                                        mask=[0, 1, 0, 0, 0]), 1, 3).mask,
+                   [1, 1, 0, 0, 1]))
+        assert_(eq(masked_equal(array(list(range(5)),
+                                      mask=[1, 0, 0, 0, 0]), 2).mask,
+                   [1, 0, 1, 0, 0]))
+        assert_(eq(masked_not_equal(array([2, 2, 1, 2, 1],
+                                          mask=[1, 0, 0, 0, 0]), 2).mask,
+                   [1, 0, 1, 0, 1]))
+        assert_(eq(masked_where([1, 1, 0, 0, 0], [1, 2, 3, 4, 5]),
+                   [99, 99, 3, 4, 5]))
+        atest = ones((10, 10, 10), dtype=np.float32)
+        btest = zeros(atest.shape, MaskType)
+        ctest = masked_where(btest, atest)
+        assert_(eq(atest, ctest))
+        z = choose(c, (-x, x))
+        assert_(eq(z, [1., 2., 0., -4., -5]))
+        assert_(z[0] is masked)
+        assert_(z[1] is not masked)
+        assert_(z[2] is masked)
+        x = arange(6)
+        x[5] = masked
+        y = arange(6) * 10
+        y[2] = masked
+        c = array([1, 1, 1, 0, 0, 0], mask=[1, 0, 0, 0, 0, 0])
+        cm = c.filled(1)
+        z = where(c, x, y)
+        zm = where(cm, x, y)
+        assert_(eq(z, zm))
+        assert_(getmask(zm) is nomask)
+        assert_(eq(zm, [0, 1, 2, 30, 40, 50]))
+        z = where(c, masked, 1)
+        assert_(eq(z, [99, 99, 99, 1, 1, 1]))
+        z = where(c, 1, masked)
+        assert_(eq(z, [99, 1, 1, 99, 99, 99]))
+
+    def test_testMinMax2(self):
+        # Test of minimum, maximum.
+        assert_(eq(minimum([1, 2, 3], [4, 0, 9]), [1, 0, 3]))
+        assert_(eq(maximum([1, 2, 3], [4, 0, 9]), [4, 2, 9]))
+        x = arange(5)
+        y = arange(5) - 2
+        x[3] = masked
+        y[0] = masked
+        assert_(eq(minimum(x, y), where(less(x, y), x, y)))
+        assert_(eq(maximum(x, y), where(greater(x, y), x, y)))
+        assert_(minimum.reduce(x) == 0)
+        assert_(maximum.reduce(x) == 4)
+
+    def test_testTakeTransposeInnerOuter(self):
+        # Test of take, transpose, inner, outer products
+        x = arange(24)
+        y = np.arange(24)
+        x[5:6] = masked
+        x = x.reshape(2, 3, 4)
+        y = y.reshape(2, 3, 4)
+        assert_(eq(np.transpose(y, (2, 0, 1)), transpose(x, (2, 0, 1))))
+        assert_(eq(np.take(y, (2, 0, 1), 1), take(x, (2, 0, 1), 1)))
+        assert_(eq(np.inner(filled(x, 0), filled(y, 0)),
+                   inner(x, y)))
+        assert_(eq(np.outer(filled(x, 0), filled(y, 0)),
+                   outer(x, y)))
+        y = array(['abc', 1, 'def', 2, 3], object)
+        y[2] = masked
+        t = take(y, [0, 3, 4])
+        assert_(t[0] == 'abc')
+        assert_(t[1] == 2)
+        assert_(t[2] == 3)
+
+    def test_testInplace(self):
+        # Test of inplace operations and rich comparisons
+        y = arange(10)
+
+        x = arange(10)
+        xm = arange(10)
+        xm[2] = masked
+        x += 1
+        assert_(eq(x, y + 1))
+        xm += 1
+        assert_(eq(x, y + 1))
+
+        x = arange(10)
+        xm = arange(10)
+        xm[2] = masked
+        x -= 1
+        assert_(eq(x, y - 1))
+        xm -= 1
+        assert_(eq(xm, y - 1))
+
+        x = arange(10) * 1.0
+        xm = arange(10) * 1.0
+        xm[2] = masked
+        x *= 2.0
+        assert_(eq(x, y * 2))
+        xm *= 2.0
+        assert_(eq(xm, y * 2))
+
+        x = arange(10) * 2
+        xm = arange(10)
+        xm[2] = masked
+        x //= 2
+        assert_(eq(x, y))
+        xm //= 2
+        assert_(eq(x, y))
+
+        x = arange(10) * 1.0
+        xm = arange(10) * 1.0
+        xm[2] = masked
+        x /= 2.0
+        assert_(eq(x, y / 2.0))
+        xm /= arange(10)
+        assert_(eq(xm, ones((10,))))
+
+        x = arange(10).astype(np.float32)
+        xm = arange(10)
+        xm[2] = masked
+        x += 1.
+        assert_(eq(x, y + 1.))
+
+    def test_testPickle(self):
+        # Test of pickling
+        x = arange(12)
+        x[4:10:2] = masked
+        x = x.reshape(4, 3)
+        for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
+            s = pickle.dumps(x, protocol=proto)
+            y = pickle.loads(s)
+            assert_(eq(x, y))
+
+    def test_testMasked(self):
+        # Test of masked element
+        xx = arange(6)
+        xx[1] = masked
+        assert_(str(masked) == '--')
+        assert_(xx[1] is masked)
+        assert_equal(filled(xx[1], 0), 0)
+
+    def test_testAverage1(self):
+        # Test of average.
+        ott = array([0., 1., 2., 3.], mask=[1, 0, 0, 0])
+        assert_(eq(2.0, average(ott, axis=0)))
+        assert_(eq(2.0, average(ott, weights=[1., 1., 2., 1.])))
+        result, wts = average(ott, weights=[1., 1., 2., 1.], returned=True)
+        assert_(eq(2.0, result))
+        assert_(wts == 4.0)
+        ott[:] = masked
+        assert_(average(ott, axis=0) is masked)
+        ott = array([0., 1., 2., 3.], mask=[1, 0, 0, 0])
+        ott = ott.reshape(2, 2)
+        ott[:, 1] = masked
+        assert_(eq(average(ott, axis=0), [2.0, 0.0]))
+        assert_(average(ott, axis=1)[0] is masked)
+        assert_(eq([2., 0.], average(ott, axis=0)))
+        result, wts = average(ott, axis=0, returned=True)
+        assert_(eq(wts, [1., 0.]))
+
+    def test_testAverage2(self):
+        # More tests of average.
+        w1 = [0, 1, 1, 1, 1, 0]
+        w2 = [[0, 1, 1, 1, 1, 0], [1, 0, 0, 0, 0, 1]]
+        x = arange(6)
+        assert_(allclose(average(x, axis=0), 2.5))
+        assert_(allclose(average(x, axis=0, weights=w1), 2.5))
+        y = array([arange(6), 2.0 * arange(6)])
+        assert_(allclose(average(y, None),
+                                 np.add.reduce(np.arange(6)) * 3. / 12.))
+        assert_(allclose(average(y, axis=0), np.arange(6) * 3. / 2.))
+        assert_(allclose(average(y, axis=1),
+                                 [average(x, axis=0), average(x, axis=0)*2.0]))
+        assert_(allclose(average(y, None, weights=w2), 20. / 6.))
+        assert_(allclose(average(y, axis=0, weights=w2),
+                                 [0., 1., 2., 3., 4., 10.]))
+        assert_(allclose(average(y, axis=1),
+                                 [average(x, axis=0), average(x, axis=0)*2.0]))
+        m1 = zeros(6)
+        m2 = [0, 0, 1, 1, 0, 0]
+        m3 = [[0, 0, 1, 1, 0, 0], [0, 1, 1, 1, 1, 0]]
+        m4 = ones(6)
+        m5 = [0, 1, 1, 1, 1, 1]
+        assert_(allclose(average(masked_array(x, m1), axis=0), 2.5))
+        assert_(allclose(average(masked_array(x, m2), axis=0), 2.5))
+        assert_(average(masked_array(x, m4), axis=0) is masked)
+        assert_equal(average(masked_array(x, m5), axis=0), 0.0)
+        assert_equal(count(average(masked_array(x, m4), axis=0)), 0)
+        z = masked_array(y, m3)
+        assert_(allclose(average(z, None), 20. / 6.))
+        assert_(allclose(average(z, axis=0),
+                                 [0., 1., 99., 99., 4.0, 7.5]))
+        assert_(allclose(average(z, axis=1), [2.5, 5.0]))
+        assert_(allclose(average(z, axis=0, weights=w2),
+                                 [0., 1., 99., 99., 4.0, 10.0]))
+
+        a = arange(6)
+        b = arange(6) * 3
+        r1, w1 = average([[a, b], [b, a]], axis=1, returned=True)
+        assert_equal(shape(r1), shape(w1))
+        assert_equal(r1.shape, w1.shape)
+        r2, w2 = average(ones((2, 2, 3)), axis=0, weights=[3, 1], returned=True)
+        assert_equal(shape(w2), shape(r2))
+        r2, w2 = average(ones((2, 2, 3)), returned=True)
+        assert_equal(shape(w2), shape(r2))
+        r2, w2 = average(ones((2, 2, 3)), weights=ones((2, 2, 3)), returned=True)
+        assert_(shape(w2) == shape(r2))
+        a2d = array([[1, 2], [0, 4]], float)
+        a2dm = masked_array(a2d, [[0, 0], [1, 0]])
+        a2da = average(a2d, axis=0)
+        assert_(eq(a2da, [0.5, 3.0]))
+        a2dma = average(a2dm, axis=0)
+        assert_(eq(a2dma, [1.0, 3.0]))
+        a2dma = average(a2dm, axis=None)
+        assert_(eq(a2dma, 7. / 3.))
+        a2dma = average(a2dm, axis=1)
+        assert_(eq(a2dma, [1.5, 4.0]))
+
+    def test_testToPython(self):
+        assert_equal(1, int(array(1)))
+        assert_equal(1.0, float(array(1)))
+        assert_equal(1, int(array([[[1]]])))
+        assert_equal(1.0, float(array([[1]])))
+        assert_raises(TypeError, float, array([1, 1]))
+        assert_raises(ValueError, bool, array([0, 1]))
+        assert_raises(ValueError, bool, array([0, 0], mask=[0, 1]))
+
+    def test_testScalarArithmetic(self):
+        xm = array(0, mask=1)
+        #TODO FIXME: Find out what the following raises a warning in r8247
+        with np.errstate(divide='ignore'):
+            assert_((1 / array(0)).mask)
+        assert_((1 + xm).mask)
+        assert_((-xm).mask)
+        assert_((-xm).mask)
+        assert_(maximum(xm, xm).mask)
+        assert_(minimum(xm, xm).mask)
+        assert_(xm.filled().dtype is xm._data.dtype)
+        x = array(0, mask=0)
+        assert_(x.filled() == x._data)
+        assert_equal(str(xm), str(masked_print_option))
+
+    def test_testArrayMethods(self):
+        a = array([1, 3, 2])
+        assert_(eq(a.any(), a._data.any()))
+        assert_(eq(a.all(), a._data.all()))
+        assert_(eq(a.argmax(), a._data.argmax()))
+        assert_(eq(a.argmin(), a._data.argmin()))
+        assert_(eq(a.choose(0, 1, 2, 3, 4),
+                           a._data.choose(0, 1, 2, 3, 4)))
+        assert_(eq(a.compress([1, 0, 1]), a._data.compress([1, 0, 1])))
+        assert_(eq(a.conj(), a._data.conj()))
+        assert_(eq(a.conjugate(), a._data.conjugate()))
+        m = array([[1, 2], [3, 4]])
+        assert_(eq(m.diagonal(), m._data.diagonal()))
+        assert_(eq(a.sum(), a._data.sum()))
+        assert_(eq(a.take([1, 2]), a._data.take([1, 2])))
+        assert_(eq(m.transpose(), m._data.transpose()))
+
+    def test_testArrayAttributes(self):
+        a = array([1, 3, 2])
+        assert_equal(a.ndim, 1)
+
+    def test_testAPI(self):
+        assert_(not [m for m in dir(np.ndarray)
+                     if m not in dir(MaskedArray) and
+                     not m.startswith('_')])
+
+    def test_testSingleElementSubscript(self):
+        a = array([1, 3, 2])
+        b = array([1, 3, 2], mask=[1, 0, 1])
+        assert_equal(a[0].shape, ())
+        assert_equal(b[0].shape, ())
+        assert_equal(b[1].shape, ())
+
+    def test_assignment_by_condition(self):
+        # Test for gh-18951
+        a = array([1, 2, 3, 4], mask=[1, 0, 1, 0])
+        c = a >= 3
+        a[c] = 5
+        assert_(a[2] is masked)
+
+    def test_assignment_by_condition_2(self):
+        # gh-19721
+        a = masked_array([0, 1], mask=[False, False])
+        b = masked_array([0, 1], mask=[True, True])
+        mask = a < 1
+        b[mask] = a[mask]
+        expected_mask = [False, True]
+        assert_equal(b.mask, expected_mask)
+
+
+class TestUfuncs:
+    def setup_method(self):
+        self.d = (array([1.0, 0, -1, pi / 2] * 2, mask=[0, 1] + [0] * 6),
+                  array([1.0, 0, -1, pi / 2] * 2, mask=[1, 0] + [0] * 6),)
+
+    def test_testUfuncRegression(self):
+        f_invalid_ignore = [
+            'sqrt', 'arctanh', 'arcsin', 'arccos',
+            'arccosh', 'arctanh', 'log', 'log10', 'divide',
+            'true_divide', 'floor_divide', 'remainder', 'fmod']
+        for f in ['sqrt', 'log', 'log10', 'exp', 'conjugate',
+                  'sin', 'cos', 'tan',
+                  'arcsin', 'arccos', 'arctan',
+                  'sinh', 'cosh', 'tanh',
+                  'arcsinh',
+                  'arccosh',
+                  'arctanh',
+                  'absolute', 'fabs', 'negative',
+                  'floor', 'ceil',
+                  'logical_not',
+                  'add', 'subtract', 'multiply',
+                  'divide', 'true_divide', 'floor_divide',
+                  'remainder', 'fmod', 'hypot', 'arctan2',
+                  'equal', 'not_equal', 'less_equal', 'greater_equal',
+                  'less', 'greater',
+                  'logical_and', 'logical_or', 'logical_xor']:
+            try:
+                uf = getattr(umath, f)
+            except AttributeError:
+                uf = getattr(fromnumeric, f)
+            mf = getattr(np.ma, f)
+            args = self.d[:uf.nin]
+            with np.errstate():
+                if f in f_invalid_ignore:
+                    np.seterr(invalid='ignore')
+                if f in ['arctanh', 'log', 'log10']:
+                    np.seterr(divide='ignore')
+                ur = uf(*args)
+                mr = mf(*args)
+            assert_(eq(ur.filled(0), mr.filled(0), f))
+            assert_(eqmask(ur.mask, mr.mask))
+
+    def test_reduce(self):
+        a = self.d[0]
+        assert_(not alltrue(a, axis=0))
+        assert_(sometrue(a, axis=0))
+        assert_equal(sum(a[:3], axis=0), 0)
+        assert_equal(product(a, axis=0), 0)
+
+    def test_minmax(self):
+        a = arange(1, 13).reshape(3, 4)
+        amask = masked_where(a < 5, a)
+        assert_equal(amask.max(), a.max())
+        assert_equal(amask.min(), 5)
+        assert_((amask.max(0) == a.max(0)).all())
+        assert_((amask.min(0) == [5, 6, 7, 8]).all())
+        assert_(amask.max(1)[0].mask)
+        assert_(amask.min(1)[0].mask)
+
+    def test_nonzero(self):
+        for t in "?bhilqpBHILQPfdgFDGO":
+            x = array([1, 0, 2, 0], mask=[0, 0, 1, 1])
+            assert_(eq(nonzero(x), [0]))
+
+
+class TestArrayMethods:
+
+    def setup_method(self):
+        x = np.array([8.375, 7.545, 8.828, 8.5, 1.757, 5.928,
+                      8.43, 7.78, 9.865, 5.878, 8.979, 4.732,
+                      3.012, 6.022, 5.095, 3.116, 5.238, 3.957,
+                      6.04, 9.63, 7.712, 3.382, 4.489, 6.479,
+                      7.189, 9.645, 5.395, 4.961, 9.894, 2.893,
+                      7.357, 9.828, 6.272, 3.758, 6.693, 0.993])
+        X = x.reshape(6, 6)
+        XX = x.reshape(3, 2, 2, 3)
+
+        m = np.array([0, 1, 0, 1, 0, 0,
+                      1, 0, 1, 1, 0, 1,
+                      0, 0, 0, 1, 0, 1,
+                      0, 0, 0, 1, 1, 1,
+                      1, 0, 0, 1, 0, 0,
+                      0, 0, 1, 0, 1, 0])
+        mx = array(data=x, mask=m)
+        mX = array(data=X, mask=m.reshape(X.shape))
+        mXX = array(data=XX, mask=m.reshape(XX.shape))
+
+        self.d = (x, X, XX, m, mx, mX, mXX)
+
+    def test_trace(self):
+        (x, X, XX, m, mx, mX, mXX,) = self.d
+        mXdiag = mX.diagonal()
+        assert_equal(mX.trace(), mX.diagonal().compressed().sum())
+        assert_(eq(mX.trace(),
+                           X.trace() - sum(mXdiag.mask * X.diagonal(),
+                                           axis=0)))
+
+    def test_clip(self):
+        (x, X, XX, m, mx, mX, mXX,) = self.d
+        clipped = mx.clip(2, 8)
+        assert_(eq(clipped.mask, mx.mask))
+        assert_(eq(clipped._data, x.clip(2, 8)))
+        assert_(eq(clipped._data, mx._data.clip(2, 8)))
+
+    def test_ptp(self):
+        (x, X, XX, m, mx, mX, mXX,) = self.d
+        (n, m) = X.shape
+        assert_equal(mx.ptp(), mx.compressed().ptp())
+        rows = np.zeros(n, np.float_)
+        cols = np.zeros(m, np.float_)
+        for k in range(m):
+            cols[k] = mX[:, k].compressed().ptp()
+        for k in range(n):
+            rows[k] = mX[k].compressed().ptp()
+        assert_(eq(mX.ptp(0), cols))
+        assert_(eq(mX.ptp(1), rows))
+
+    def test_swapaxes(self):
+        (x, X, XX, m, mx, mX, mXX,) = self.d
+        mXswapped = mX.swapaxes(0, 1)
+        assert_(eq(mXswapped[-1], mX[:, -1]))
+        mXXswapped = mXX.swapaxes(0, 2)
+        assert_equal(mXXswapped.shape, (2, 2, 3, 3))
+
+    def test_cumprod(self):
+        (x, X, XX, m, mx, mX, mXX,) = self.d
+        mXcp = mX.cumprod(0)
+        assert_(eq(mXcp._data, mX.filled(1).cumprod(0)))
+        mXcp = mX.cumprod(1)
+        assert_(eq(mXcp._data, mX.filled(1).cumprod(1)))
+
+    def test_cumsum(self):
+        (x, X, XX, m, mx, mX, mXX,) = self.d
+        mXcp = mX.cumsum(0)
+        assert_(eq(mXcp._data, mX.filled(0).cumsum(0)))
+        mXcp = mX.cumsum(1)
+        assert_(eq(mXcp._data, mX.filled(0).cumsum(1)))
+
+    def test_varstd(self):
+        (x, X, XX, m, mx, mX, mXX,) = self.d
+        assert_(eq(mX.var(axis=None), mX.compressed().var()))
+        assert_(eq(mX.std(axis=None), mX.compressed().std()))
+        assert_(eq(mXX.var(axis=3).shape, XX.var(axis=3).shape))
+        assert_(eq(mX.var().shape, X.var().shape))
+        (mXvar0, mXvar1) = (mX.var(axis=0), mX.var(axis=1))
+        for k in range(6):
+            assert_(eq(mXvar1[k], mX[k].compressed().var()))
+            assert_(eq(mXvar0[k], mX[:, k].compressed().var()))
+            assert_(eq(np.sqrt(mXvar0[k]),
+                               mX[:, k].compressed().std()))
+
+
+def eqmask(m1, m2):
+    if m1 is nomask:
+        return m2 is nomask
+    if m2 is nomask:
+        return m1 is nomask
+    return (m1 == m2).all()

llava_next/lib/python3.10/site-packages/numpy/ma/testutils.py

@@ -0,0 +1,288 @@
+"""Miscellaneous functions for testing masked arrays and subclasses
+
+:author: Pierre Gerard-Marchant
+:contact: pierregm_at_uga_dot_edu
+:version: $Id: testutils.py 3529 2007-11-13 08:01:14Z jarrod.millman $
+
+"""
+import operator
+
+import numpy as np
+from numpy import ndarray, float_
+import numpy.core.umath as umath
+import numpy.testing
+from numpy.testing import (
+    assert_, assert_allclose, assert_array_almost_equal_nulp,
+    assert_raises, build_err_msg
+    )
+from .core import mask_or, getmask, masked_array, nomask, masked, filled
+
+__all__masked = [
+    'almost', 'approx', 'assert_almost_equal', 'assert_array_almost_equal',
+    'assert_array_approx_equal', 'assert_array_compare',
+    'assert_array_equal', 'assert_array_less', 'assert_close',
+    'assert_equal', 'assert_equal_records', 'assert_mask_equal',
+    'assert_not_equal', 'fail_if_array_equal',
+    ]
+
+# Include some normal test functions to avoid breaking other projects who
+# have mistakenly included them from this file. SciPy is one. That is
+# unfortunate, as some of these functions are not intended to work with
+# masked arrays. But there was no way to tell before.
+from unittest import TestCase
+__some__from_testing = [
+    'TestCase', 'assert_', 'assert_allclose', 'assert_array_almost_equal_nulp',
+    'assert_raises'
+    ]
+
+__all__ = __all__masked + __some__from_testing
+
+
+def approx(a, b, fill_value=True, rtol=1e-5, atol=1e-8):
+    """
+    Returns true if all components of a and b are equal to given tolerances.
+
+    If fill_value is True, masked values considered equal. Otherwise,
+    masked values are considered unequal.  The relative error rtol should
+    be positive and << 1.0 The absolute error atol comes into play for
+    those elements of b that are very small or zero; it says how small a
+    must be also.
+
+    """
+    m = mask_or(getmask(a), getmask(b))
+    d1 = filled(a)
+    d2 = filled(b)
+    if d1.dtype.char == "O" or d2.dtype.char == "O":
+        return np.equal(d1, d2).ravel()
+    x = filled(masked_array(d1, copy=False, mask=m), fill_value).astype(float_)
+    y = filled(masked_array(d2, copy=False, mask=m), 1).astype(float_)
+    d = np.less_equal(umath.absolute(x - y), atol + rtol * umath.absolute(y))
+    return d.ravel()
+
+
+def almost(a, b, decimal=6, fill_value=True):
+    """
+    Returns True if a and b are equal up to decimal places.
+
+    If fill_value is True, masked values considered equal. Otherwise,
+    masked values are considered unequal.
+
+    """
+    m = mask_or(getmask(a), getmask(b))
+    d1 = filled(a)
+    d2 = filled(b)
+    if d1.dtype.char == "O" or d2.dtype.char == "O":
+        return np.equal(d1, d2).ravel()
+    x = filled(masked_array(d1, copy=False, mask=m), fill_value).astype(float_)
+    y = filled(masked_array(d2, copy=False, mask=m), 1).astype(float_)
+    d = np.around(np.abs(x - y), decimal) <= 10.0 ** (-decimal)
+    return d.ravel()
+
+
+def _assert_equal_on_sequences(actual, desired, err_msg=''):
+    """
+    Asserts the equality of two non-array sequences.
+
+    """
+    assert_equal(len(actual), len(desired), err_msg)
+    for k in range(len(desired)):
+        assert_equal(actual[k], desired[k], f'item={k!r}\n{err_msg}')
+    return
+
+
+def assert_equal_records(a, b):
+    """
+    Asserts that two records are equal.
+
+    Pretty crude for now.
+
+    """
+    assert_equal(a.dtype, b.dtype)
+    for f in a.dtype.names:
+        (af, bf) = (operator.getitem(a, f), operator.getitem(b, f))
+        if not (af is masked) and not (bf is masked):
+            assert_equal(operator.getitem(a, f), operator.getitem(b, f))
+    return
+
+
+def assert_equal(actual, desired, err_msg=''):
+    """
+    Asserts that two items are equal.
+
+    """
+    # Case #1: dictionary .....
+    if isinstance(desired, dict):
+        if not isinstance(actual, dict):
+            raise AssertionError(repr(type(actual)))
+        assert_equal(len(actual), len(desired), err_msg)
+        for k, i in desired.items():
+            if k not in actual:
+                raise AssertionError(f"{k} not in {actual}")
+            assert_equal(actual[k], desired[k], f'key={k!r}\n{err_msg}')
+        return
+    # Case #2: lists .....
+    if isinstance(desired, (list, tuple)) and isinstance(actual, (list, tuple)):
+        return _assert_equal_on_sequences(actual, desired, err_msg='')
+    if not (isinstance(actual, ndarray) or isinstance(desired, ndarray)):
+        msg = build_err_msg([actual, desired], err_msg,)
+        if not desired == actual:
+            raise AssertionError(msg)
+        return
+    # Case #4. arrays or equivalent
+    if ((actual is masked) and not (desired is masked)) or \
+            ((desired is masked) and not (actual is masked)):
+        msg = build_err_msg([actual, desired],
+                            err_msg, header='', names=('x', 'y'))
+        raise ValueError(msg)
+    actual = np.asanyarray(actual)
+    desired = np.asanyarray(desired)
+    (actual_dtype, desired_dtype) = (actual.dtype, desired.dtype)
+    if actual_dtype.char == "S" and desired_dtype.char == "S":
+        return _assert_equal_on_sequences(actual.tolist(),
+                                          desired.tolist(),
+                                          err_msg='')
+    return assert_array_equal(actual, desired, err_msg)
+
+
+def fail_if_equal(actual, desired, err_msg='',):
+    """
+    Raises an assertion error if two items are equal.
+
+    """
+    if isinstance(desired, dict):
+        if not isinstance(actual, dict):
+            raise AssertionError(repr(type(actual)))
+        fail_if_equal(len(actual), len(desired), err_msg)
+        for k, i in desired.items():
+            if k not in actual:
+                raise AssertionError(repr(k))
+            fail_if_equal(actual[k], desired[k], f'key={k!r}\n{err_msg}')
+        return
+    if isinstance(desired, (list, tuple)) and isinstance(actual, (list, tuple)):
+        fail_if_equal(len(actual), len(desired), err_msg)
+        for k in range(len(desired)):
+            fail_if_equal(actual[k], desired[k], f'item={k!r}\n{err_msg}')
+        return
+    if isinstance(actual, np.ndarray) or isinstance(desired, np.ndarray):
+        return fail_if_array_equal(actual, desired, err_msg)
+    msg = build_err_msg([actual, desired], err_msg)
+    if not desired != actual:
+        raise AssertionError(msg)
+
+
+assert_not_equal = fail_if_equal
+
+
+def assert_almost_equal(actual, desired, decimal=7, err_msg='', verbose=True):
+    """
+    Asserts that two items are almost equal.
+
+    The test is equivalent to abs(desired-actual) < 0.5 * 10**(-decimal).
+
+    """
+    if isinstance(actual, np.ndarray) or isinstance(desired, np.ndarray):
+        return assert_array_almost_equal(actual, desired, decimal=decimal,
+                                         err_msg=err_msg, verbose=verbose)
+    msg = build_err_msg([actual, desired],
+                        err_msg=err_msg, verbose=verbose)
+    if not round(abs(desired - actual), decimal) == 0:
+        raise AssertionError(msg)
+
+
+assert_close = assert_almost_equal
+
+
+def assert_array_compare(comparison, x, y, err_msg='', verbose=True, header='',
+                         fill_value=True):
+    """
+    Asserts that comparison between two masked arrays is satisfied.
+
+    The comparison is elementwise.
+
+    """
+    # Allocate a common mask and refill
+    m = mask_or(getmask(x), getmask(y))
+    x = masked_array(x, copy=False, mask=m, keep_mask=False, subok=False)
+    y = masked_array(y, copy=False, mask=m, keep_mask=False, subok=False)
+    if ((x is masked) and not (y is masked)) or \
+            ((y is masked) and not (x is masked)):
+        msg = build_err_msg([x, y], err_msg=err_msg, verbose=verbose,
+                            header=header, names=('x', 'y'))
+        raise ValueError(msg)
+    # OK, now run the basic tests on filled versions
+    return np.testing.assert_array_compare(comparison,
+                                           x.filled(fill_value),
+                                           y.filled(fill_value),
+                                           err_msg=err_msg,
+                                           verbose=verbose, header=header)
+
+
+def assert_array_equal(x, y, err_msg='', verbose=True):
+    """
+    Checks the elementwise equality of two masked arrays.
+
+    """
+    assert_array_compare(operator.__eq__, x, y,
+                         err_msg=err_msg, verbose=verbose,
+                         header='Arrays are not equal')
+
+
+def fail_if_array_equal(x, y, err_msg='', verbose=True):
+    """
+    Raises an assertion error if two masked arrays are not equal elementwise.
+
+    """
+    def compare(x, y):
+        return (not np.all(approx(x, y)))
+    assert_array_compare(compare, x, y, err_msg=err_msg, verbose=verbose,
+                         header='Arrays are not equal')
+
+
+def assert_array_approx_equal(x, y, decimal=6, err_msg='', verbose=True):
+    """
+    Checks the equality of two masked arrays, up to given number odecimals.
+
+    The equality is checked elementwise.
+
+    """
+    def compare(x, y):
+        "Returns the result of the loose comparison between x and y)."
+        return approx(x, y, rtol=10. ** -decimal)
+    assert_array_compare(compare, x, y, err_msg=err_msg, verbose=verbose,
+                         header='Arrays are not almost equal')
+
+
+def assert_array_almost_equal(x, y, decimal=6, err_msg='', verbose=True):
+    """
+    Checks the equality of two masked arrays, up to given number odecimals.
+
+    The equality is checked elementwise.
+
+    """
+    def compare(x, y):
+        "Returns the result of the loose comparison between x and y)."
+        return almost(x, y, decimal)
+    assert_array_compare(compare, x, y, err_msg=err_msg, verbose=verbose,
+                         header='Arrays are not almost equal')
+
+
+def assert_array_less(x, y, err_msg='', verbose=True):
+    """
+    Checks that x is smaller than y elementwise.
+
+    """
+    assert_array_compare(operator.__lt__, x, y,
+                         err_msg=err_msg, verbose=verbose,
+                         header='Arrays are not less-ordered')
+
+
+def assert_mask_equal(m1, m2, err_msg=''):
+    """
+    Asserts the equality of two masks.
+
+    """
+    if m1 is nomask:
+        assert_(m2 is nomask)
+    if m2 is nomask:
+        assert_(m1 is nomask)
+    assert_array_equal(m1, m2, err_msg=err_msg)

llava_next/lib/python3.10/site-packages/numpy/ma/timer_comparison.py

@@ -0,0 +1,443 @@
+import timeit
+from functools import reduce
+
+import numpy as np
+from numpy import float_
+import numpy.core.fromnumeric as fromnumeric
+
+from numpy.testing import build_err_msg
+
+
+pi = np.pi
+
+class ModuleTester:
+    def __init__(self, module):
+        self.module = module
+        self.allequal = module.allequal
+        self.arange = module.arange
+        self.array = module.array
+        self.concatenate = module.concatenate
+        self.count = module.count
+        self.equal = module.equal
+        self.filled = module.filled
+        self.getmask = module.getmask
+        self.getmaskarray = module.getmaskarray
+        self.id = id
+        self.inner = module.inner
+        self.make_mask = module.make_mask
+        self.masked = module.masked
+        self.masked_array = module.masked_array
+        self.masked_values = module.masked_values
+        self.mask_or = module.mask_or
+        self.nomask = module.nomask
+        self.ones = module.ones
+        self.outer = module.outer
+        self.repeat = module.repeat
+        self.resize = module.resize
+        self.sort = module.sort
+        self.take = module.take
+        self.transpose = module.transpose
+        self.zeros = module.zeros
+        self.MaskType = module.MaskType
+        try:
+            self.umath = module.umath
+        except AttributeError:
+            self.umath = module.core.umath
+        self.testnames = []
+
+    def assert_array_compare(self, comparison, x, y, err_msg='', header='',
+                         fill_value=True):
+        """
+        Assert that a comparison of two masked arrays is satisfied elementwise.
+
+        """
+        xf = self.filled(x)
+        yf = self.filled(y)
+        m = self.mask_or(self.getmask(x), self.getmask(y))
+
+        x = self.filled(self.masked_array(xf, mask=m), fill_value)
+        y = self.filled(self.masked_array(yf, mask=m), fill_value)
+        if (x.dtype.char != "O"):
+            x = x.astype(float_)
+            if isinstance(x, np.ndarray) and x.size > 1:
+                x[np.isnan(x)] = 0
+            elif np.isnan(x):
+                x = 0
+        if (y.dtype.char != "O"):
+            y = y.astype(float_)
+            if isinstance(y, np.ndarray) and y.size > 1:
+                y[np.isnan(y)] = 0
+            elif np.isnan(y):
+                y = 0
+        try:
+            cond = (x.shape == () or y.shape == ()) or x.shape == y.shape
+            if not cond:
+                msg = build_err_msg([x, y],
+                                    err_msg
+                                    + f'\n(shapes {x.shape}, {y.shape} mismatch)',
+                                    header=header,
+                                    names=('x', 'y'))
+                assert cond, msg
+            val = comparison(x, y)
+            if m is not self.nomask and fill_value:
+                val = self.masked_array(val, mask=m)
+            if isinstance(val, bool):
+                cond = val
+                reduced = [0]
+            else:
+                reduced = val.ravel()
+                cond = reduced.all()
+                reduced = reduced.tolist()
+            if not cond:
+                match = 100-100.0*reduced.count(1)/len(reduced)
+                msg = build_err_msg([x, y],
+                                    err_msg
+                                    + '\n(mismatch %s%%)' % (match,),
+                                    header=header,
+                                    names=('x', 'y'))
+                assert cond, msg
+        except ValueError as e:
+            msg = build_err_msg([x, y], err_msg, header=header, names=('x', 'y'))
+            raise ValueError(msg) from e
+
+    def assert_array_equal(self, x, y, err_msg=''):
+        """
+        Checks the elementwise equality of two masked arrays.
+
+        """
+        self.assert_array_compare(self.equal, x, y, err_msg=err_msg,
+                                  header='Arrays are not equal')
+
+    @np.errstate(all='ignore')
+    def test_0(self):
+        """
+        Tests creation
+
+        """
+        x = np.array([1., 1., 1., -2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
+        m = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
+        xm = self.masked_array(x, mask=m)
+        xm[0]
+
+    @np.errstate(all='ignore')
+    def test_1(self):
+        """
+        Tests creation
+
+        """
+        x = np.array([1., 1., 1., -2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
+        y = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
+        m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
+        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1]
+        xm = self.masked_array(x, mask=m1)
+        ym = self.masked_array(y, mask=m2)
+        xf = np.where(m1, 1.e+20, x)
+        xm.set_fill_value(1.e+20)
+
+        assert((xm-ym).filled(0).any())
+        s = x.shape
+        assert(xm.size == reduce(lambda x, y:x*y, s))
+        assert(self.count(xm) == len(m1) - reduce(lambda x, y:x+y, m1))
+
+        for s in [(4, 3), (6, 2)]:
+            x.shape = s
+            y.shape = s
+            xm.shape = s
+            ym.shape = s
+            xf.shape = s
+            assert(self.count(xm) == len(m1) - reduce(lambda x, y:x+y, m1))
+
+    @np.errstate(all='ignore')
+    def test_2(self):
+        """
+        Tests conversions and indexing.
+
+        """
+        x1 = np.array([1, 2, 4, 3])
+        x2 = self.array(x1, mask=[1, 0, 0, 0])
+        x3 = self.array(x1, mask=[0, 1, 0, 1])
+        x4 = self.array(x1)
+        # test conversion to strings, no errors
+        str(x2)
+        repr(x2)
+        # tests of indexing
+        assert type(x2[1]) is type(x1[1])
+        assert x1[1] == x2[1]
+        x1[2] = 9
+        x2[2] = 9
+        self.assert_array_equal(x1, x2)
+        x1[1:3] = 99
+        x2[1:3] = 99
+        x2[1] = self.masked
+        x2[1:3] = self.masked
+        x2[:] = x1
+        x2[1] = self.masked
+        x3[:] = self.masked_array([1, 2, 3, 4], [0, 1, 1, 0])
+        x4[:] = self.masked_array([1, 2, 3, 4], [0, 1, 1, 0])
+        x1 = np.arange(5)*1.0
+        x2 = self.masked_values(x1, 3.0)
+        x1 = self.array([1, 'hello', 2, 3], object)
+        x2 = np.array([1, 'hello', 2, 3], object)
+        # check that no error occurs.
+        x1[1]
+        x2[1]
+        assert x1[1:1].shape == (0,)
+        # Tests copy-size
+        n = [0, 0, 1, 0, 0]
+        m = self.make_mask(n)
+        m2 = self.make_mask(m)
+        assert(m is m2)
+        m3 = self.make_mask(m, copy=1)
+        assert(m is not m3)
+
+    @np.errstate(all='ignore')
+    def test_3(self):
+        """
+        Tests resize/repeat
+
+        """
+        x4 = self.arange(4)
+        x4[2] = self.masked
+        y4 = self.resize(x4, (8,))
+        assert self.allequal(self.concatenate([x4, x4]), y4)
+        assert self.allequal(self.getmask(y4), [0, 0, 1, 0, 0, 0, 1, 0])
+        y5 = self.repeat(x4, (2, 2, 2, 2), axis=0)
+        self.assert_array_equal(y5, [0, 0, 1, 1, 2, 2, 3, 3])
+        y6 = self.repeat(x4, 2, axis=0)
+        assert self.allequal(y5, y6)
+        y7 = x4.repeat((2, 2, 2, 2), axis=0)
+        assert self.allequal(y5, y7)
+        y8 = x4.repeat(2, 0)
+        assert self.allequal(y5, y8)
+
+    @np.errstate(all='ignore')
+    def test_4(self):
+        """
+        Test of take, transpose, inner, outer products.
+
+        """
+        x = self.arange(24)
+        y = np.arange(24)
+        x[5:6] = self.masked
+        x = x.reshape(2, 3, 4)
+        y = y.reshape(2, 3, 4)
+        assert self.allequal(np.transpose(y, (2, 0, 1)), self.transpose(x, (2, 0, 1)))
+        assert self.allequal(np.take(y, (2, 0, 1), 1), self.take(x, (2, 0, 1), 1))
+        assert self.allequal(np.inner(self.filled(x, 0), self.filled(y, 0)),
+                            self.inner(x, y))
+        assert self.allequal(np.outer(self.filled(x, 0), self.filled(y, 0)),
+                            self.outer(x, y))
+        y = self.array(['abc', 1, 'def', 2, 3], object)
+        y[2] = self.masked
+        t = self.take(y, [0, 3, 4])
+        assert t[0] == 'abc'
+        assert t[1] == 2
+        assert t[2] == 3
+
+    @np.errstate(all='ignore')
+    def test_5(self):
+        """
+        Tests inplace w/ scalar
+
+        """
+        x = self.arange(10)
+        y = self.arange(10)
+        xm = self.arange(10)
+        xm[2] = self.masked
+        x += 1
+        assert self.allequal(x, y+1)
+        xm += 1
+        assert self.allequal(xm, y+1)
+
+        x = self.arange(10)
+        xm = self.arange(10)
+        xm[2] = self.masked
+        x -= 1
+        assert self.allequal(x, y-1)
+        xm -= 1
+        assert self.allequal(xm, y-1)
+
+        x = self.arange(10)*1.0
+        xm = self.arange(10)*1.0
+        xm[2] = self.masked
+        x *= 2.0
+        assert self.allequal(x, y*2)
+        xm *= 2.0
+        assert self.allequal(xm, y*2)
+
+        x = self.arange(10)*2
+        xm = self.arange(10)*2
+        xm[2] = self.masked
+        x /= 2
+        assert self.allequal(x, y)
+        xm /= 2
+        assert self.allequal(xm, y)
+
+        x = self.arange(10)*1.0
+        xm = self.arange(10)*1.0
+        xm[2] = self.masked
+        x /= 2.0
+        assert self.allequal(x, y/2.0)
+        xm /= self.arange(10)
+        self.assert_array_equal(xm, self.ones((10,)))
+
+        x = self.arange(10).astype(float_)
+        xm = self.arange(10)
+        xm[2] = self.masked
+        x += 1.
+        assert self.allequal(x, y + 1.)
+
+    @np.errstate(all='ignore')
+    def test_6(self):
+        """
+        Tests inplace w/ array
+
+        """
+        x = self.arange(10, dtype=float_)
+        y = self.arange(10)
+        xm = self.arange(10, dtype=float_)
+        xm[2] = self.masked
+        m = xm.mask
+        a = self.arange(10, dtype=float_)
+        a[-1] = self.masked
+        x += a
+        xm += a
+        assert self.allequal(x, y+a)
+        assert self.allequal(xm, y+a)
+        assert self.allequal(xm.mask, self.mask_or(m, a.mask))
+
+        x = self.arange(10, dtype=float_)
+        xm = self.arange(10, dtype=float_)
+        xm[2] = self.masked
+        m = xm.mask
+        a = self.arange(10, dtype=float_)
+        a[-1] = self.masked
+        x -= a
+        xm -= a
+        assert self.allequal(x, y-a)
+        assert self.allequal(xm, y-a)
+        assert self.allequal(xm.mask, self.mask_or(m, a.mask))
+
+        x = self.arange(10, dtype=float_)
+        xm = self.arange(10, dtype=float_)
+        xm[2] = self.masked
+        m = xm.mask
+        a = self.arange(10, dtype=float_)
+        a[-1] = self.masked
+        x *= a
+        xm *= a
+        assert self.allequal(x, y*a)
+        assert self.allequal(xm, y*a)
+        assert self.allequal(xm.mask, self.mask_or(m, a.mask))
+
+        x = self.arange(10, dtype=float_)
+        xm = self.arange(10, dtype=float_)
+        xm[2] = self.masked
+        m = xm.mask
+        a = self.arange(10, dtype=float_)
+        a[-1] = self.masked
+        x /= a
+        xm /= a
+
+    @np.errstate(all='ignore')
+    def test_7(self):
+        "Tests ufunc"
+        d = (self.array([1.0, 0, -1, pi/2]*2, mask=[0, 1]+[0]*6),
+             self.array([1.0, 0, -1, pi/2]*2, mask=[1, 0]+[0]*6),)
+        for f in ['sqrt', 'log', 'log10', 'exp', 'conjugate',
+#                  'sin', 'cos', 'tan',
+#                  'arcsin', 'arccos', 'arctan',
+#                  'sinh', 'cosh', 'tanh',
+#                  'arcsinh',
+#                  'arccosh',
+#                  'arctanh',
+#                  'absolute', 'fabs', 'negative',
+#                  # 'nonzero', 'around',
+#                  'floor', 'ceil',
+#                  # 'sometrue', 'alltrue',
+#                  'logical_not',
+#                  'add', 'subtract', 'multiply',
+#                  'divide', 'true_divide', 'floor_divide',
+#                  'remainder', 'fmod', 'hypot', 'arctan2',
+#                  'equal', 'not_equal', 'less_equal', 'greater_equal',
+#                  'less', 'greater',
+#                  'logical_and', 'logical_or', 'logical_xor',
+                  ]:
+            try:
+                uf = getattr(self.umath, f)
+            except AttributeError:
+                uf = getattr(fromnumeric, f)
+            mf = getattr(self.module, f)
+            args = d[:uf.nin]
+            ur = uf(*args)
+            mr = mf(*args)
+            self.assert_array_equal(ur.filled(0), mr.filled(0), f)
+            self.assert_array_equal(ur._mask, mr._mask)
+
+    @np.errstate(all='ignore')
+    def test_99(self):
+        # test average
+        ott = self.array([0., 1., 2., 3.], mask=[1, 0, 0, 0])
+        self.assert_array_equal(2.0, self.average(ott, axis=0))
+        self.assert_array_equal(2.0, self.average(ott, weights=[1., 1., 2., 1.]))
+        result, wts = self.average(ott, weights=[1., 1., 2., 1.], returned=1)
+        self.assert_array_equal(2.0, result)
+        assert(wts == 4.0)
+        ott[:] = self.masked
+        assert(self.average(ott, axis=0) is self.masked)
+        ott = self.array([0., 1., 2., 3.], mask=[1, 0, 0, 0])
+        ott = ott.reshape(2, 2)
+        ott[:, 1] = self.masked
+        self.assert_array_equal(self.average(ott, axis=0), [2.0, 0.0])
+        assert(self.average(ott, axis=1)[0] is self.masked)
+        self.assert_array_equal([2., 0.], self.average(ott, axis=0))
+        result, wts = self.average(ott, axis=0, returned=1)
+        self.assert_array_equal(wts, [1., 0.])
+        w1 = [0, 1, 1, 1, 1, 0]
+        w2 = [[0, 1, 1, 1, 1, 0], [1, 0, 0, 0, 0, 1]]
+        x = self.arange(6)
+        self.assert_array_equal(self.average(x, axis=0), 2.5)
+        self.assert_array_equal(self.average(x, axis=0, weights=w1), 2.5)
+        y = self.array([self.arange(6), 2.0*self.arange(6)])
+        self.assert_array_equal(self.average(y, None), np.add.reduce(np.arange(6))*3./12.)
+        self.assert_array_equal(self.average(y, axis=0), np.arange(6) * 3./2.)
+        self.assert_array_equal(self.average(y, axis=1), [self.average(x, axis=0), self.average(x, axis=0) * 2.0])
+        self.assert_array_equal(self.average(y, None, weights=w2), 20./6.)
+        self.assert_array_equal(self.average(y, axis=0, weights=w2), [0., 1., 2., 3., 4., 10.])
+        self.assert_array_equal(self.average(y, axis=1), [self.average(x, axis=0), self.average(x, axis=0) * 2.0])
+        m1 = self.zeros(6)
+        m2 = [0, 0, 1, 1, 0, 0]
+        m3 = [[0, 0, 1, 1, 0, 0], [0, 1, 1, 1, 1, 0]]
+        m4 = self.ones(6)
+        m5 = [0, 1, 1, 1, 1, 1]
+        self.assert_array_equal(self.average(self.masked_array(x, m1), axis=0), 2.5)
+        self.assert_array_equal(self.average(self.masked_array(x, m2), axis=0), 2.5)
+        self.assert_array_equal(self.average(self.masked_array(x, m5), axis=0), 0.0)
+        self.assert_array_equal(self.count(self.average(self.masked_array(x, m4), axis=0)), 0)
+        z = self.masked_array(y, m3)
+        self.assert_array_equal(self.average(z, None), 20./6.)
+        self.assert_array_equal(self.average(z, axis=0), [0., 1., 99., 99., 4.0, 7.5])
+        self.assert_array_equal(self.average(z, axis=1), [2.5, 5.0])
+        self.assert_array_equal(self.average(z, axis=0, weights=w2), [0., 1., 99., 99., 4.0, 10.0])
+
+    @np.errstate(all='ignore')
+    def test_A(self):
+        x = self.arange(24)
+        x[5:6] = self.masked
+        x = x.reshape(2, 3, 4)
+
+
+if __name__ == '__main__':
+    setup_base = ("from __main__ import ModuleTester \n"
+                  "import numpy\n"
+                  "tester = ModuleTester(module)\n")
+    setup_cur = "import numpy.ma.core as module\n" + setup_base
+    (nrepeat, nloop) = (10, 10)
+
+    for i in range(1, 8):
+        func = 'tester.test_%i()' % i
+        cur = timeit.Timer(func, setup_cur).repeat(nrepeat, nloop*10)
+        cur = np.sort(cur)
+        print("#%i" % i + 50*'.')
+        print(eval("ModuleTester.test_%i.__doc__" % i))
+        print(f'core_current : {cur[0]:.3f} - {cur[1]:.3f}')

parrot/lib/python3.10/site-packages/sympy/codegen/cutils.py

@@ -0,0 +1,8 @@
+from sympy.printing.c import C99CodePrinter
+
+def render_as_source_file(content, Printer=C99CodePrinter, settings=None):
+    """ Renders a C source file (with required #include statements) """
+    printer = Printer(settings or {})
+    code_str = printer.doprint(content)
+    includes = '\n'.join(['#include <%s>' % h for h in printer.headers])
+    return includes + '\n\n' + code_str

parrot/lib/python3.10/site-packages/sympy/core/operations.py

@@ -0,0 +1,718 @@
+from __future__ import annotations
+from operator import attrgetter
+from collections import defaultdict
+
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+from .sympify import _sympify as _sympify_, sympify
+from .basic import Basic
+from .cache import cacheit
+from .sorting import ordered
+from .logic import fuzzy_and
+from .parameters import global_parameters
+from sympy.utilities.iterables import sift
+from sympy.multipledispatch.dispatcher import (Dispatcher,
+    ambiguity_register_error_ignore_dup,
+    str_signature, RaiseNotImplementedError)
+
+
+class AssocOp(Basic):
+    """ Associative operations, can separate noncommutative and
+    commutative parts.
+
+    (a op b) op c == a op (b op c) == a op b op c.
+
+    Base class for Add and Mul.
+
+    This is an abstract base class, concrete derived classes must define
+    the attribute `identity`.
+
+    .. deprecated:: 1.7
+
+       Using arguments that aren't subclasses of :class:`~.Expr` in core
+       operators (:class:`~.Mul`, :class:`~.Add`, and :class:`~.Pow`) is
+       deprecated. See :ref:`non-expr-args-deprecated` for details.
+
+    Parameters
+    ==========
+
+    *args :
+        Arguments which are operated
+
+    evaluate : bool, optional
+        Evaluate the operation. If not passed, refer to ``global_parameters.evaluate``.
+    """
+
+    # for performance reason, we don't let is_commutative go to assumptions,
+    # and keep it right here
+    __slots__: tuple[str, ...] = ('is_commutative',)
+
+    _args_type: type[Basic] | None = None
+
+    @cacheit
+    def __new__(cls, *args, evaluate=None, _sympify=True):
+        # Allow faster processing by passing ``_sympify=False``, if all arguments
+        # are already sympified.
+        if _sympify:
+            args = list(map(_sympify_, args))
+
+        # Disallow non-Expr args in Add/Mul
+        typ = cls._args_type
+        if typ is not None:
+            from .relational import Relational
+            if any(isinstance(arg, Relational) for arg in args):
+                raise TypeError("Relational cannot be used in %s" % cls.__name__)
+
+            # This should raise TypeError once deprecation period is over:
+            for arg in args:
+                if not isinstance(arg, typ):
+                    sympy_deprecation_warning(
+                        f"""
+
+Using non-Expr arguments in {cls.__name__} is deprecated (in this case, one of
+the arguments has type {type(arg).__name__!r}).
+
+If you really did intend to use a multiplication or addition operation with
+this object, use the * or + operator instead.
+
+                        """,
+                        deprecated_since_version="1.7",
+                        active_deprecations_target="non-expr-args-deprecated",
+                        stacklevel=4,
+                    )
+
+        if evaluate is None:
+            evaluate = global_parameters.evaluate
+        if not evaluate:
+            obj = cls._from_args(args)
+            obj = cls._exec_constructor_postprocessors(obj)
+            return obj
+
+        args = [a for a in args if a is not cls.identity]
+
+        if len(args) == 0:
+            return cls.identity
+        if len(args) == 1:
+            return args[0]
+
+        c_part, nc_part, order_symbols = cls.flatten(args)
+        is_commutative = not nc_part
+        obj = cls._from_args(c_part + nc_part, is_commutative)
+        obj = cls._exec_constructor_postprocessors(obj)
+
+        if order_symbols is not None:
+            from sympy.series.order import Order
+            return Order(obj, *order_symbols)
+        return obj
+
+    @classmethod
+    def _from_args(cls, args, is_commutative=None):
+        """Create new instance with already-processed args.
+        If the args are not in canonical order, then a non-canonical
+        result will be returned, so use with caution. The order of
+        args may change if the sign of the args is changed."""
+        if len(args) == 0:
+            return cls.identity
+        elif len(args) == 1:
+            return args[0]
+
+        obj = super().__new__(cls, *args)
+        if is_commutative is None:
+            is_commutative = fuzzy_and(a.is_commutative for a in args)
+        obj.is_commutative = is_commutative
+        return obj
+
+    def _new_rawargs(self, *args, reeval=True, **kwargs):
+        """Create new instance of own class with args exactly as provided by
+        caller but returning the self class identity if args is empty.
+
+        Examples
+        ========
+
+           This is handy when we want to optimize things, e.g.
+
+               >>> from sympy import Mul, S
+               >>> from sympy.abc import x, y
+               >>> e = Mul(3, x, y)
+               >>> e.args
+               (3, x, y)
+               >>> Mul(*e.args[1:])
+               x*y
+               >>> e._new_rawargs(*e.args[1:])  # the same as above, but faster
+               x*y
+
+           Note: use this with caution. There is no checking of arguments at
+           all. This is best used when you are rebuilding an Add or Mul after
+           simply removing one or more args. If, for example, modifications,
+           result in extra 1s being inserted they will show up in the result:
+
+               >>> m = (x*y)._new_rawargs(S.One, x); m
+               1*x
+               >>> m == x
+               False
+               >>> m.is_Mul
+               True
+
+           Another issue to be aware of is that the commutativity of the result
+           is based on the commutativity of self. If you are rebuilding the
+           terms that came from a commutative object then there will be no
+           problem, but if self was non-commutative then what you are
+           rebuilding may now be commutative.
+
+           Although this routine tries to do as little as possible with the
+           input, getting the commutativity right is important, so this level
+           of safety is enforced: commutativity will always be recomputed if
+           self is non-commutative and kwarg `reeval=False` has not been
+           passed.
+        """
+        if reeval and self.is_commutative is False:
+            is_commutative = None
+        else:
+            is_commutative = self.is_commutative
+        return self._from_args(args, is_commutative)
+
+    @classmethod
+    def flatten(cls, seq):
+        """Return seq so that none of the elements are of type `cls`. This is
+        the vanilla routine that will be used if a class derived from AssocOp
+        does not define its own flatten routine."""
+        # apply associativity, no commutativity property is used
+        new_seq = []
+        while seq:
+            o = seq.pop()
+            if o.__class__ is cls:  # classes must match exactly
+                seq.extend(o.args)
+            else:
+                new_seq.append(o)
+        new_seq.reverse()
+
+        # c_part, nc_part, order_symbols
+        return [], new_seq, None
+
+    def _matches_commutative(self, expr, repl_dict=None, old=False):
+        """
+        Matches Add/Mul "pattern" to an expression "expr".
+
+        repl_dict ... a dictionary of (wild: expression) pairs, that get
+                      returned with the results
+
+        This function is the main workhorse for Add/Mul.
+
+        Examples
+        ========
+
+        >>> from sympy import symbols, Wild, sin
+        >>> a = Wild("a")
+        >>> b = Wild("b")
+        >>> c = Wild("c")
+        >>> x, y, z = symbols("x y z")
+        >>> (a+sin(b)*c)._matches_commutative(x+sin(y)*z)
+        {a_: x, b_: y, c_: z}
+
+        In the example above, "a+sin(b)*c" is the pattern, and "x+sin(y)*z" is
+        the expression.
+
+        The repl_dict contains parts that were already matched. For example
+        here:
+
+        >>> (x+sin(b)*c)._matches_commutative(x+sin(y)*z, repl_dict={a: x})
+        {a_: x, b_: y, c_: z}
+
+        the only function of the repl_dict is to return it in the
+        result, e.g. if you omit it:
+
+        >>> (x+sin(b)*c)._matches_commutative(x+sin(y)*z)
+        {b_: y, c_: z}
+
+        the "a: x" is not returned in the result, but otherwise it is
+        equivalent.
+
+        """
+        from .function import _coeff_isneg
+        # make sure expr is Expr if pattern is Expr
+        from .expr import Expr
+        if isinstance(self, Expr) and not isinstance(expr, Expr):
+            return None
+
+        if repl_dict is None:
+            repl_dict = {}
+
+        # handle simple patterns
+        if self == expr:
+            return repl_dict
+
+        d = self._matches_simple(expr, repl_dict)
+        if d is not None:
+            return d
+
+        # eliminate exact part from pattern: (2+a+w1+w2).matches(expr) -> (w1+w2).matches(expr-a-2)
+        from .function import WildFunction
+        from .symbol import Wild
+        wild_part, exact_part = sift(self.args, lambda p:
+            p.has(Wild, WildFunction) and not expr.has(p),
+            binary=True)
+        if not exact_part:
+            wild_part = list(ordered(wild_part))
+            if self.is_Add:
+                # in addition to normal ordered keys, impose
+                # sorting on Muls with leading Number to put
+                # them in order
+                wild_part = sorted(wild_part, key=lambda x:
+                    x.args[0] if x.is_Mul and x.args[0].is_Number else
+                    0)
+        else:
+            exact = self._new_rawargs(*exact_part)
+            free = expr.free_symbols
+            if free and (exact.free_symbols - free):
+                # there are symbols in the exact part that are not
+                # in the expr; but if there are no free symbols, let
+                # the matching continue
+                return None
+            newexpr = self._combine_inverse(expr, exact)
+            if not old and (expr.is_Add or expr.is_Mul):
+                check = newexpr
+                if _coeff_isneg(check):
+                    check = -check
+                if check.count_ops() > expr.count_ops():
+                    return None
+            newpattern = self._new_rawargs(*wild_part)
+            return newpattern.matches(newexpr, repl_dict)
+
+        # now to real work ;)
+        i = 0
+        saw = set()
+        while expr not in saw:
+            saw.add(expr)
+            args = tuple(ordered(self.make_args(expr)))
+            if self.is_Add and expr.is_Add:
+                # in addition to normal ordered keys, impose
+                # sorting on Muls with leading Number to put
+                # them in order
+                args = tuple(sorted(args, key=lambda x:
+                    x.args[0] if x.is_Mul and x.args[0].is_Number else
+                    0))
+            expr_list = (self.identity,) + args
+            for last_op in reversed(expr_list):
+                for w in reversed(wild_part):
+                    d1 = w.matches(last_op, repl_dict)
+                    if d1 is not None:
+                        d2 = self.xreplace(d1).matches(expr, d1)
+                        if d2 is not None:
+                            return d2
+
+            if i == 0:
+                if self.is_Mul:
+                    # make e**i look like Mul
+                    if expr.is_Pow and expr.exp.is_Integer:
+                        from .mul import Mul
+                        if expr.exp > 0:
+                            expr = Mul(*[expr.base, expr.base**(expr.exp - 1)], evaluate=False)
+                        else:
+                            expr = Mul(*[1/expr.base, expr.base**(expr.exp + 1)], evaluate=False)
+                        i += 1
+                        continue
+
+                elif self.is_Add:
+                    # make i*e look like Add
+                    c, e = expr.as_coeff_Mul()
+                    if abs(c) > 1:
+                        from .add import Add
+                        if c > 0:
+                            expr = Add(*[e, (c - 1)*e], evaluate=False)
+                        else:
+                            expr = Add(*[-e, (c + 1)*e], evaluate=False)
+                        i += 1
+                        continue
+
+                    # try collection on non-Wild symbols
+                    from sympy.simplify.radsimp import collect
+                    was = expr
+                    did = set()
+                    for w in reversed(wild_part):
+                        c, w = w.as_coeff_mul(Wild)
+                        free = c.free_symbols - did
+                        if free:
+                            did.update(free)
+                            expr = collect(expr, free)
+                    if expr != was:
+                        i += 0
+                        continue
+
+                break  # if we didn't continue, there is nothing more to do
+
+        return
+
+    def _has_matcher(self):
+        """Helper for .has() that checks for containment of
+        subexpressions within an expr by using sets of args
+        of similar nodes, e.g. x + 1 in x + y + 1 checks
+        to see that {x, 1} & {x, y, 1} == {x, 1}
+        """
+        def _ncsplit(expr):
+            # this is not the same as args_cnc because here
+            # we don't assume expr is a Mul -- hence deal with args --
+            # and always return a set.
+            cpart, ncpart = sift(expr.args,
+                lambda arg: arg.is_commutative is True, binary=True)
+            return set(cpart), ncpart
+
+        c, nc = _ncsplit(self)
+        cls = self.__class__
+
+        def is_in(expr):
+            if isinstance(expr, cls):
+                if expr == self:
+                    return True
+                _c, _nc = _ncsplit(expr)
+                if (c & _c) == c:
+                    if not nc:
+                        return True
+                    elif len(nc) <= len(_nc):
+                        for i in range(len(_nc) - len(nc) + 1):
+                            if _nc[i:i + len(nc)] == nc:
+                                return True
+            return False
+        return is_in
+
+    def _eval_evalf(self, prec):
+        """
+        Evaluate the parts of self that are numbers; if the whole thing
+        was a number with no functions it would have been evaluated, but
+        it wasn't so we must judiciously extract the numbers and reconstruct
+        the object. This is *not* simply replacing numbers with evaluated
+        numbers. Numbers should be handled in the largest pure-number
+        expression as possible. So the code below separates ``self`` into
+        number and non-number parts and evaluates the number parts and
+        walks the args of the non-number part recursively (doing the same
+        thing).
+        """
+        from .add import Add
+        from .mul import Mul
+        from .symbol import Symbol
+        from .function import AppliedUndef
+        if isinstance(self, (Mul, Add)):
+            x, tail = self.as_independent(Symbol, AppliedUndef)
+            # if x is an AssocOp Function then the _evalf below will
+            # call _eval_evalf (here) so we must break the recursion
+            if not (tail is self.identity or
+                    isinstance(x, AssocOp) and x.is_Function or
+                    x is self.identity and isinstance(tail, AssocOp)):
+                # here, we have a number so we just call to _evalf with prec;
+                # prec is not the same as n, it is the binary precision so
+                # that's why we don't call to evalf.
+                x = x._evalf(prec) if x is not self.identity else self.identity
+                args = []
+                tail_args = tuple(self.func.make_args(tail))
+                for a in tail_args:
+                    # here we call to _eval_evalf since we don't know what we
+                    # are dealing with and all other _eval_evalf routines should
+                    # be doing the same thing (i.e. taking binary prec and
+                    # finding the evalf-able args)
+                    newa = a._eval_evalf(prec)
+                    if newa is None:
+                        args.append(a)
+                    else:
+                        args.append(newa)
+                return self.func(x, *args)
+
+        # this is the same as above, but there were no pure-number args to
+        # deal with
+        args = []
+        for a in self.args:
+            newa = a._eval_evalf(prec)
+            if newa is None:
+                args.append(a)
+            else:
+                args.append(newa)
+        return self.func(*args)
+
+    @classmethod
+    def make_args(cls, expr):
+        """
+        Return a sequence of elements `args` such that cls(*args) == expr
+
+        Examples
+        ========
+
+        >>> from sympy import Symbol, Mul, Add
+        >>> x, y = map(Symbol, 'xy')
+
+        >>> Mul.make_args(x*y)
+        (x, y)
+        >>> Add.make_args(x*y)
+        (x*y,)
+        >>> set(Add.make_args(x*y + y)) == set([y, x*y])
+        True
+
+        """
+        if isinstance(expr, cls):
+            return expr.args
+        else:
+            return (sympify(expr),)
+
+    def doit(self, **hints):
+        if hints.get('deep', True):
+            terms = [term.doit(**hints) for term in self.args]
+        else:
+            terms = self.args
+        return self.func(*terms, evaluate=True)
+
+class ShortCircuit(Exception):
+    pass
+
+
+class LatticeOp(AssocOp):
+    """
+    Join/meet operations of an algebraic lattice[1].
+
+    Explanation
+    ===========
+
+    These binary operations are associative (op(op(a, b), c) = op(a, op(b, c))),
+    commutative (op(a, b) = op(b, a)) and idempotent (op(a, a) = op(a) = a).
+    Common examples are AND, OR, Union, Intersection, max or min. They have an
+    identity element (op(identity, a) = a) and an absorbing element
+    conventionally called zero (op(zero, a) = zero).
+
+    This is an abstract base class, concrete derived classes must declare
+    attributes zero and identity. All defining properties are then respected.
+
+    Examples
+    ========
+
+    >>> from sympy import Integer
+    >>> from sympy.core.operations import LatticeOp
+    >>> class my_join(LatticeOp):
+    ...     zero = Integer(0)
+    ...     identity = Integer(1)
+    >>> my_join(2, 3) == my_join(3, 2)
+    True
+    >>> my_join(2, my_join(3, 4)) == my_join(2, 3, 4)
+    True
+    >>> my_join(0, 1, 4, 2, 3, 4)
+    0
+    >>> my_join(1, 2)
+    2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Lattice_%28order%29
+    """
+
+    is_commutative = True
+
+    def __new__(cls, *args, **options):
+        args = (_sympify_(arg) for arg in args)
+
+        try:
+            # /!\ args is a generator and _new_args_filter
+            # must be careful to handle as such; this
+            # is done so short-circuiting can be done
+            # without having to sympify all values
+            _args = frozenset(cls._new_args_filter(args))
+        except ShortCircuit:
+            return sympify(cls.zero)
+        if not _args:
+            return sympify(cls.identity)
+        elif len(_args) == 1:
+            return set(_args).pop()
+        else:
+            # XXX in almost every other case for __new__, *_args is
+            # passed along, but the expectation here is for _args
+            obj = super(AssocOp, cls).__new__(cls, *ordered(_args))
+            obj._argset = _args
+            return obj
+
+    @classmethod
+    def _new_args_filter(cls, arg_sequence, call_cls=None):
+        """Generator filtering args"""
+        ncls = call_cls or cls
+        for arg in arg_sequence:
+            if arg == ncls.zero:
+                raise ShortCircuit(arg)
+            elif arg == ncls.identity:
+                continue
+            elif arg.func == ncls:
+                yield from arg.args
+            else:
+                yield arg
+
+    @classmethod
+    def make_args(cls, expr):
+        """
+        Return a set of args such that cls(*arg_set) == expr.
+        """
+        if isinstance(expr, cls):
+            return expr._argset
+        else:
+            return frozenset([sympify(expr)])
+
+
+class AssocOpDispatcher:
+    """
+    Handler dispatcher for associative operators
+
+    .. notes::
+       This approach is experimental, and can be replaced or deleted in the future.
+       See https://github.com/sympy/sympy/pull/19463.
+
+    Explanation
+    ===========
+
+    If arguments of different types are passed, the classes which handle the operation for each type
+    are collected. Then, a class which performs the operation is selected by recursive binary dispatching.
+    Dispatching relation can be registered by ``register_handlerclass`` method.
+
+    Priority registration is unordered. You cannot make ``A*B`` and ``B*A`` refer to
+    different handler classes. All logic dealing with the order of arguments must be implemented
+    in the handler class.
+
+    Examples
+    ========
+
+    >>> from sympy import Add, Expr, Symbol
+    >>> from sympy.core.add import add
+
+    >>> class NewExpr(Expr):
+    ...     @property
+    ...     def _add_handler(self):
+    ...         return NewAdd
+    >>> class NewAdd(NewExpr, Add):
+    ...     pass
+    >>> add.register_handlerclass((Add, NewAdd), NewAdd)
+
+    >>> a, b = Symbol('a'), NewExpr()
+    >>> add(a, b) == NewAdd(a, b)
+    True
+
+    """
+    def __init__(self, name, doc=None):
+        self.name = name
+        self.doc = doc
+        self.handlerattr = "_%s_handler" % name
+        self._handlergetter = attrgetter(self.handlerattr)
+        self._dispatcher = Dispatcher(name)
+
+    def __repr__(self):
+        return "<dispatched %s>" % self.name
+
+    def register_handlerclass(self, classes, typ, on_ambiguity=ambiguity_register_error_ignore_dup):
+        """
+        Register the handler class for two classes, in both straight and reversed order.
+
+        Paramteters
+        ===========
+
+        classes : tuple of two types
+            Classes who are compared with each other.
+
+        typ:
+            Class which is registered to represent *cls1* and *cls2*.
+            Handler method of *self* must be implemented in this class.
+        """
+        if not len(classes) == 2:
+            raise RuntimeError(
+                "Only binary dispatch is supported, but got %s types: <%s>." % (
+                len(classes), str_signature(classes)
+            ))
+        if len(set(classes)) == 1:
+            raise RuntimeError(
+                "Duplicate types <%s> cannot be dispatched." % str_signature(classes)
+            )
+        self._dispatcher.add(tuple(classes), typ, on_ambiguity=on_ambiguity)
+        self._dispatcher.add(tuple(reversed(classes)), typ, on_ambiguity=on_ambiguity)
+
+    @cacheit
+    def __call__(self, *args, _sympify=True, **kwargs):
+        """
+        Parameters
+        ==========
+
+        *args :
+            Arguments which are operated
+        """
+        if _sympify:
+            args = tuple(map(_sympify_, args))
+        handlers = frozenset(map(self._handlergetter, args))
+
+        # no need to sympify again
+        return self.dispatch(handlers)(*args, _sympify=False, **kwargs)
+
+    @cacheit
+    def dispatch(self, handlers):
+        """
+        Select the handler class, and return its handler method.
+        """
+
+        # Quick exit for the case where all handlers are same
+        if len(handlers) == 1:
+            h, = handlers
+            if not isinstance(h, type):
+                raise RuntimeError("Handler {!r} is not a type.".format(h))
+            return h
+
+        # Recursively select with registered binary priority
+        for i, typ in enumerate(handlers):
+
+            if not isinstance(typ, type):
+                raise RuntimeError("Handler {!r} is not a type.".format(typ))
+
+            if i == 0:
+                handler = typ
+            else:
+                prev_handler = handler
+                handler = self._dispatcher.dispatch(prev_handler, typ)
+
+                if not isinstance(handler, type):
+                    raise RuntimeError(
+                        "Dispatcher for {!r} and {!r} must return a type, but got {!r}".format(
+                        prev_handler, typ, handler
+                    ))
+
+        # return handler class
+        return handler
+
+    @property
+    def __doc__(self):
+        docs = [
+            "Multiply dispatched associative operator: %s" % self.name,
+            "Note that support for this is experimental, see the docs for :class:`AssocOpDispatcher` for details"
+        ]
+
+        if self.doc:
+            docs.append(self.doc)
+
+        s = "Registered handler classes\n"
+        s += '=' * len(s)
+        docs.append(s)
+
+        amb_sigs = []
+
+        typ_sigs = defaultdict(list)
+        for sigs in self._dispatcher.ordering[::-1]:
+            key = self._dispatcher.funcs[sigs]
+            typ_sigs[key].append(sigs)
+
+        for typ, sigs in typ_sigs.items():
+
+            sigs_str = ', '.join('<%s>' % str_signature(sig) for sig in sigs)
+
+            if isinstance(typ, RaiseNotImplementedError):
+                amb_sigs.append(sigs_str)
+                continue
+
+            s = 'Inputs: %s\n' % sigs_str
+            s += '-' * len(s) + '\n'
+            s += typ.__name__
+            docs.append(s)
+
+        if amb_sigs:
+            s = "Ambiguous handler classes\n"
+            s += '=' * len(s)
+            docs.append(s)
+
+            s = '\n'.join(amb_sigs)
+            docs.append(s)
+
+        return '\n\n'.join(docs)

parrot/lib/python3.10/site-packages/sympy/core/random.py

@@ -0,0 +1,227 @@
+"""
+When you need to use random numbers in SymPy library code, import from here
+so there is only one generator working for SymPy. Imports from here should
+behave the same as if they were being imported from Python's random module.
+But only the routines currently used in SymPy are included here. To use others
+import ``rng`` and access the method directly. For example, to capture the
+current state of the generator use ``rng.getstate()``.
+
+There is intentionally no Random to import from here. If you want
+to control the state of the generator, import ``seed`` and call it
+with or without an argument to set the state.
+
+Examples
+========
+
+>>> from sympy.core.random import random, seed
+>>> assert random() < 1
+>>> seed(1); a = random()
+>>> b = random()
+>>> seed(1); c = random()
+>>> assert a == c
+>>> assert a != b  # remote possibility this will fail
+
+"""
+from sympy.utilities.iterables import is_sequence
+from sympy.utilities.misc import as_int
+
+import random as _random
+rng = _random.Random()
+
+choice = rng.choice
+random = rng.random
+randint = rng.randint
+randrange = rng.randrange
+sample = rng.sample
+# seed = rng.seed
+shuffle = rng.shuffle
+uniform = rng.uniform
+
+_assumptions_rng = _random.Random()
+_assumptions_shuffle = _assumptions_rng.shuffle
+
+
+def seed(a=None, version=2):
+    rng.seed(a=a, version=version)
+    _assumptions_rng.seed(a=a, version=version)
+
+
+def random_complex_number(a=2, b=-1, c=3, d=1, rational=False, tolerance=None):
+    """
+    Return a random complex number.
+
+    To reduce chance of hitting branch cuts or anything, we guarantee
+    b <= Im z <= d, a <= Re z <= c
+
+    When rational is True, a rational approximation to a random number
+    is obtained within specified tolerance, if any.
+    """
+    from sympy.core.numbers import I
+    from sympy.simplify.simplify import nsimplify
+    A, B = uniform(a, c), uniform(b, d)
+    if not rational:
+        return A + I*B
+    return (nsimplify(A, rational=True, tolerance=tolerance) +
+        I*nsimplify(B, rational=True, tolerance=tolerance))
+
+
+def verify_numerically(f, g, z=None, tol=1.0e-6, a=2, b=-1, c=3, d=1):
+    """
+    Test numerically that f and g agree when evaluated in the argument z.
+
+    If z is None, all symbols will be tested. This routine does not test
+    whether there are Floats present with precision higher than 15 digits
+    so if there are, your results may not be what you expect due to round-
+    off errors.
+
+    Examples
+    ========
+
+    >>> from sympy import sin, cos
+    >>> from sympy.abc import x
+    >>> from sympy.core.random import verify_numerically as tn
+    >>> tn(sin(x)**2 + cos(x)**2, 1, x)
+    True
+    """
+    from sympy.core.symbol import Symbol
+    from sympy.core.sympify import sympify
+    from sympy.core.numbers import comp
+    f, g = (sympify(i) for i in (f, g))
+    if z is None:
+        z = f.free_symbols | g.free_symbols
+    elif isinstance(z, Symbol):
+        z = [z]
+    reps = list(zip(z, [random_complex_number(a, b, c, d) for _ in z]))
+    z1 = f.subs(reps).n()
+    z2 = g.subs(reps).n()
+    return comp(z1, z2, tol)
+
+
+def test_derivative_numerically(f, z, tol=1.0e-6, a=2, b=-1, c=3, d=1):
+    """
+    Test numerically that the symbolically computed derivative of f
+    with respect to z is correct.
+
+    This routine does not test whether there are Floats present with
+    precision higher than 15 digits so if there are, your results may
+    not be what you expect due to round-off errors.
+
+    Examples
+    ========
+
+    >>> from sympy import sin
+    >>> from sympy.abc import x
+    >>> from sympy.core.random import test_derivative_numerically as td
+    >>> td(sin(x), x)
+    True
+    """
+    from sympy.core.numbers import comp
+    from sympy.core.function import Derivative
+    z0 = random_complex_number(a, b, c, d)
+    f1 = f.diff(z).subs(z, z0)
+    f2 = Derivative(f, z).doit_numerically(z0)
+    return comp(f1.n(), f2.n(), tol)
+
+
+def _randrange(seed=None):
+    """Return a randrange generator.
+
+    ``seed`` can be
+
+    * None - return randomly seeded generator
+    * int - return a generator seeded with the int
+    * list - the values to be returned will be taken from the list
+      in the order given; the provided list is not modified.
+
+    Examples
+    ========
+
+    >>> from sympy.core.random import _randrange
+    >>> rr = _randrange()
+    >>> rr(1000) # doctest: +SKIP
+    999
+    >>> rr = _randrange(3)
+    >>> rr(1000) # doctest: +SKIP
+    238
+    >>> rr = _randrange([0, 5, 1, 3, 4])
+    >>> rr(3), rr(3)
+    (0, 1)
+    """
+    if seed is None:
+        return randrange
+    elif isinstance(seed, int):
+        rng.seed(seed)
+        return randrange
+    elif is_sequence(seed):
+        seed = list(seed)  # make a copy
+        seed.reverse()
+
+        def give(a, b=None, seq=seed):
+            if b is None:
+                a, b = 0, a
+            a, b = as_int(a), as_int(b)
+            w = b - a
+            if w < 1:
+                raise ValueError('_randrange got empty range')
+            try:
+                x = seq.pop()
+            except IndexError:
+                raise ValueError('_randrange sequence was too short')
+            if a <= x < b:
+                return x
+            else:
+                return give(a, b, seq)
+        return give
+    else:
+        raise ValueError('_randrange got an unexpected seed')
+
+
+def _randint(seed=None):
+    """Return a randint generator.
+
+    ``seed`` can be
+
+    * None - return randomly seeded generator
+    * int - return a generator seeded with the int
+    * list - the values to be returned will be taken from the list
+      in the order given; the provided list is not modified.
+
+    Examples
+    ========
+
+    >>> from sympy.core.random import _randint
+    >>> ri = _randint()
+    >>> ri(1, 1000) # doctest: +SKIP
+    999
+    >>> ri = _randint(3)
+    >>> ri(1, 1000) # doctest: +SKIP
+    238
+    >>> ri = _randint([0, 5, 1, 2, 4])
+    >>> ri(1, 3), ri(1, 3)
+    (1, 2)
+    """
+    if seed is None:
+        return randint
+    elif isinstance(seed, int):
+        rng.seed(seed)
+        return randint
+    elif is_sequence(seed):
+        seed = list(seed)  # make a copy
+        seed.reverse()
+
+        def give(a, b, seq=seed):
+            a, b = as_int(a), as_int(b)
+            w = b - a
+            if w < 0:
+                raise ValueError('_randint got empty range')
+            try:
+                x = seq.pop()
+            except IndexError:
+                raise ValueError('_randint sequence was too short')
+            if a <= x <= b:
+                return x
+            else:
+                return give(a, b, seq)
+        return give
+    else:
+        raise ValueError('_randint got an unexpected seed')

parrot/lib/python3.10/site-packages/sympy/core/sorting.py

@@ -0,0 +1,312 @@
+from collections import defaultdict
+
+from .sympify import sympify, SympifyError
+from sympy.utilities.iterables import iterable, uniq
+
+
+__all__ = ['default_sort_key', 'ordered']
+
+
+def default_sort_key(item, order=None):
+    """Return a key that can be used for sorting.
+
+    The key has the structure:
+
+    (class_key, (len(args), args), exponent.sort_key(), coefficient)
+
+    This key is supplied by the sort_key routine of Basic objects when
+    ``item`` is a Basic object or an object (other than a string) that
+    sympifies to a Basic object. Otherwise, this function produces the
+    key.
+
+    The ``order`` argument is passed along to the sort_key routine and is
+    used to determine how the terms *within* an expression are ordered.
+    (See examples below) ``order`` options are: 'lex', 'grlex', 'grevlex',
+    and reversed values of the same (e.g. 'rev-lex'). The default order
+    value is None (which translates to 'lex').
+
+    Examples
+    ========
+
+    >>> from sympy import S, I, default_sort_key, sin, cos, sqrt
+    >>> from sympy.core.function import UndefinedFunction
+    >>> from sympy.abc import x
+
+    The following are equivalent ways of getting the key for an object:
+
+    >>> x.sort_key() == default_sort_key(x)
+    True
+
+    Here are some examples of the key that is produced:
+
+    >>> default_sort_key(UndefinedFunction('f'))
+    ((0, 0, 'UndefinedFunction'), (1, ('f',)), ((1, 0, 'Number'),
+        (0, ()), (), 1), 1)
+    >>> default_sort_key('1')
+    ((0, 0, 'str'), (1, ('1',)), ((1, 0, 'Number'), (0, ()), (), 1), 1)
+    >>> default_sort_key(S.One)
+    ((1, 0, 'Number'), (0, ()), (), 1)
+    >>> default_sort_key(2)
+    ((1, 0, 'Number'), (0, ()), (), 2)
+
+    While sort_key is a method only defined for SymPy objects,
+    default_sort_key will accept anything as an argument so it is
+    more robust as a sorting key. For the following, using key=
+    lambda i: i.sort_key() would fail because 2 does not have a sort_key
+    method; that's why default_sort_key is used. Note, that it also
+    handles sympification of non-string items likes ints:
+
+    >>> a = [2, I, -I]
+    >>> sorted(a, key=default_sort_key)
+    [2, -I, I]
+
+    The returned key can be used anywhere that a key can be specified for
+    a function, e.g. sort, min, max, etc...:
+
+    >>> a.sort(key=default_sort_key); a[0]
+    2
+    >>> min(a, key=default_sort_key)
+    2
+
+    Notes
+    =====
+
+    The key returned is useful for getting items into a canonical order
+    that will be the same across platforms. It is not directly useful for
+    sorting lists of expressions:
+
+    >>> a, b = x, 1/x
+
+    Since ``a`` has only 1 term, its value of sort_key is unaffected by
+    ``order``:
+
+    >>> a.sort_key() == a.sort_key('rev-lex')
+    True
+
+    If ``a`` and ``b`` are combined then the key will differ because there
+    are terms that can be ordered:
+
+    >>> eq = a + b
+    >>> eq.sort_key() == eq.sort_key('rev-lex')
+    False
+    >>> eq.as_ordered_terms()
+    [x, 1/x]
+    >>> eq.as_ordered_terms('rev-lex')
+    [1/x, x]
+
+    But since the keys for each of these terms are independent of ``order``'s
+    value, they do not sort differently when they appear separately in a list:
+
+    >>> sorted(eq.args, key=default_sort_key)
+    [1/x, x]
+    >>> sorted(eq.args, key=lambda i: default_sort_key(i, order='rev-lex'))
+    [1/x, x]
+
+    The order of terms obtained when using these keys is the order that would
+    be obtained if those terms were *factors* in a product.
+
+    Although it is useful for quickly putting expressions in canonical order,
+    it does not sort expressions based on their complexity defined by the
+    number of operations, power of variables and others:
+
+    >>> sorted([sin(x)*cos(x), sin(x)], key=default_sort_key)
+    [sin(x)*cos(x), sin(x)]
+    >>> sorted([x, x**2, sqrt(x), x**3], key=default_sort_key)
+    [sqrt(x), x, x**2, x**3]
+
+    See Also
+    ========
+
+    ordered, sympy.core.expr.Expr.as_ordered_factors, sympy.core.expr.Expr.as_ordered_terms
+
+    """
+    from .basic import Basic
+    from .singleton import S
+
+    if isinstance(item, Basic):
+        return item.sort_key(order=order)
+
+    if iterable(item, exclude=str):
+        if isinstance(item, dict):
+            args = item.items()
+            unordered = True
+        elif isinstance(item, set):
+            args = item
+            unordered = True
+        else:
+            # e.g. tuple, list
+            args = list(item)
+            unordered = False
+
+        args = [default_sort_key(arg, order=order) for arg in args]
+
+        if unordered:
+            # e.g. dict, set
+            args = sorted(args)
+
+        cls_index, args = 10, (len(args), tuple(args))
+    else:
+        if not isinstance(item, str):
+            try:
+                item = sympify(item, strict=True)
+            except SympifyError:
+                # e.g. lambda x: x
+                pass
+            else:
+                if isinstance(item, Basic):
+                    # e.g int -> Integer
+                    return default_sort_key(item)
+                # e.g. UndefinedFunction
+
+        # e.g. str
+        cls_index, args = 0, (1, (str(item),))
+
+    return (cls_index, 0, item.__class__.__name__
+            ), args, S.One.sort_key(), S.One
+
+
+def _node_count(e):
+    # this not only counts nodes, it affirms that the
+    # args are Basic (i.e. have an args property). If
+    # some object has a non-Basic arg, it needs to be
+    # fixed since it is intended that all Basic args
+    # are of Basic type (though this is not easy to enforce).
+    if e.is_Float:
+        return 0.5
+    return 1 + sum(map(_node_count, e.args))
+
+
+def _nodes(e):
+    """
+    A helper for ordered() which returns the node count of ``e`` which
+    for Basic objects is the number of Basic nodes in the expression tree
+    but for other objects is 1 (unless the object is an iterable or dict
+    for which the sum of nodes is returned).
+    """
+    from .basic import Basic
+    from .function import Derivative
+
+    if isinstance(e, Basic):
+        if isinstance(e, Derivative):
+            return _nodes(e.expr) + sum(i[1] if i[1].is_Number else
+                _nodes(i[1]) for i in e.variable_count)
+        return _node_count(e)
+    elif iterable(e):
+        return 1 + sum(_nodes(ei) for ei in e)
+    elif isinstance(e, dict):
+        return 1 + sum(_nodes(k) + _nodes(v) for k, v in e.items())
+    else:
+        return 1
+
+
+def ordered(seq, keys=None, default=True, warn=False):
+    """Return an iterator of the seq where keys are used to break ties
+    in a conservative fashion: if, after applying a key, there are no
+    ties then no other keys will be computed.
+
+    Two default keys will be applied if 1) keys are not provided or
+    2) the given keys do not resolve all ties (but only if ``default``
+    is True). The two keys are ``_nodes`` (which places smaller
+    expressions before large) and ``default_sort_key`` which (if the
+    ``sort_key`` for an object is defined properly) should resolve
+    any ties. This strategy is similar to sorting done by
+    ``Basic.compare``, but differs in that ``ordered`` never makes a
+    decision based on an objects name.
+
+    If ``warn`` is True then an error will be raised if there were no
+    keys remaining to break ties. This can be used if it was expected that
+    there should be no ties between items that are not identical.
+
+    Examples
+    ========
+
+    >>> from sympy import ordered, count_ops
+    >>> from sympy.abc import x, y
+
+    The count_ops is not sufficient to break ties in this list and the first
+    two items appear in their original order (i.e. the sorting is stable):
+
+    >>> list(ordered([y + 2, x + 2, x**2 + y + 3],
+    ...    count_ops, default=False, warn=False))
+    ...
+    [y + 2, x + 2, x**2 + y + 3]
+
+    The default_sort_key allows the tie to be broken:
+
+    >>> list(ordered([y + 2, x + 2, x**2 + y + 3]))
+    ...
+    [x + 2, y + 2, x**2 + y + 3]
+
+    Here, sequences are sorted by length, then sum:
+
+    >>> seq, keys = [[[1, 2, 1], [0, 3, 1], [1, 1, 3], [2], [1]], [
+    ...    lambda x: len(x),
+    ...    lambda x: sum(x)]]
+    ...
+    >>> list(ordered(seq, keys, default=False, warn=False))
+    [[1], [2], [1, 2, 1], [0, 3, 1], [1, 1, 3]]
+
+    If ``warn`` is True, an error will be raised if there were not
+    enough keys to break ties:
+
+    >>> list(ordered(seq, keys, default=False, warn=True))
+    Traceback (most recent call last):
+    ...
+    ValueError: not enough keys to break ties
+
+
+    Notes
+    =====
+
+    The decorated sort is one of the fastest ways to sort a sequence for
+    which special item comparison is desired: the sequence is decorated,
+    sorted on the basis of the decoration (e.g. making all letters lower
+    case) and then undecorated. If one wants to break ties for items that
+    have the same decorated value, a second key can be used. But if the
+    second key is expensive to compute then it is inefficient to decorate
+    all items with both keys: only those items having identical first key
+    values need to be decorated. This function applies keys successively
+    only when needed to break ties. By yielding an iterator, use of the
+    tie-breaker is delayed as long as possible.
+
+    This function is best used in cases when use of the first key is
+    expected to be a good hashing function; if there are no unique hashes
+    from application of a key, then that key should not have been used. The
+    exception, however, is that even if there are many collisions, if the
+    first group is small and one does not need to process all items in the
+    list then time will not be wasted sorting what one was not interested
+    in. For example, if one were looking for the minimum in a list and
+    there were several criteria used to define the sort order, then this
+    function would be good at returning that quickly if the first group
+    of candidates is small relative to the number of items being processed.
+
+    """
+
+    d = defaultdict(list)
+    if keys:
+        if isinstance(keys, (list, tuple)):
+            keys = list(keys)
+            f = keys.pop(0)
+        else:
+            f = keys
+            keys = []
+        for a in seq:
+            d[f(a)].append(a)
+    else:
+        if not default:
+            raise ValueError('if default=False then keys must be provided')
+        d[None].extend(seq)
+
+    for k, value in sorted(d.items()):
+        if len(value) > 1:
+            if keys:
+                value = ordered(value, keys, default, warn)
+            elif default:
+                value = ordered(value, (_nodes, default_sort_key,),
+                               default=False, warn=warn)
+            elif warn:
+                u = list(uniq(value))
+                if len(u) > 1:
+                    raise ValueError(
+                        'not enough keys to break ties: %s' % u)
+        yield from value

parrot/lib/python3.10/site-packages/sympy/holonomic/__init__.py

@@ -0,0 +1,18 @@
+r"""
+The :py:mod:`~sympy.holonomic` module is intended to deal with holonomic functions along
+with various operations on them like addition, multiplication, composition,
+integration and differentiation. The module also implements various kinds of
+conversions such as converting holonomic functions to a different form and the
+other way around.
+"""
+
+from .holonomic import (DifferentialOperator, HolonomicFunction, DifferentialOperators,
+    from_hyper, from_meijerg, expr_to_holonomic)
+from .recurrence import RecurrenceOperators, RecurrenceOperator, HolonomicSequence
+
+__all__ = [
+    'DifferentialOperator', 'HolonomicFunction', 'DifferentialOperators',
+    'from_hyper', 'from_meijerg', 'expr_to_holonomic',
+
+    'RecurrenceOperators', 'RecurrenceOperator', 'HolonomicSequence',
+]

parrot/lib/python3.10/site-packages/sympy/holonomic/holonomic.py

@@ -0,0 +1,2790 @@
+"""
+This module implements Holonomic Functions and
+various operations on them.
+"""
+
+from sympy.core import Add, Mul, Pow
+from sympy.core.numbers import (NaN, Infinity, NegativeInfinity, Float, I, pi,
+        equal_valued, int_valued)
+from sympy.core.singleton import S
+from sympy.core.sorting import ordered
+from sympy.core.symbol import Dummy, Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import binomial, factorial, rf
+from sympy.functions.elementary.exponential import exp_polar, exp, log
+from sympy.functions.elementary.hyperbolic import (cosh, sinh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin, sinc)
+from sympy.functions.special.error_functions import (Ci, Shi, Si, erf, erfc, erfi)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.hyper import hyper, meijerg
+from sympy.integrals import meijerint
+from sympy.matrices import Matrix
+from sympy.polys.rings import PolyElement
+from sympy.polys.fields import FracElement
+from sympy.polys.domains import QQ, RR
+from sympy.polys.polyclasses import DMF
+from sympy.polys.polyroots import roots
+from sympy.polys.polytools import Poly
+from sympy.polys.matrices import DomainMatrix
+from sympy.printing import sstr
+from sympy.series.limits import limit
+from sympy.series.order import Order
+from sympy.simplify.hyperexpand import hyperexpand
+from sympy.simplify.simplify import nsimplify
+from sympy.solvers.solvers import solve
+
+from .recurrence import HolonomicSequence, RecurrenceOperator, RecurrenceOperators
+from .holonomicerrors import (NotPowerSeriesError, NotHyperSeriesError,
+    SingularityError, NotHolonomicError)
+
+
+def _find_nonzero_solution(r, homosys):
+    ones = lambda shape: DomainMatrix.ones(shape, r.domain)
+    particular, nullspace = r._solve(homosys)
+    nullity = nullspace.shape[0]
+    nullpart = ones((1, nullity)) * nullspace
+    sol = (particular + nullpart).transpose()
+    return sol
+
+
+
+def DifferentialOperators(base, generator):
+    r"""
+    This function is used to create annihilators using ``Dx``.
+
+    Explanation
+    ===========
+
+    Returns an Algebra of Differential Operators also called Weyl Algebra
+    and the operator for differentiation i.e. the ``Dx`` operator.
+
+    Parameters
+    ==========
+
+    base:
+        Base polynomial ring for the algebra.
+        The base polynomial ring is the ring of polynomials in :math:`x` that
+        will appear as coefficients in the operators.
+    generator:
+        Generator of the algebra which can
+        be either a noncommutative ``Symbol`` or a string. e.g. "Dx" or "D".
+
+    Examples
+    ========
+
+    >>> from sympy import ZZ
+    >>> from sympy.abc import x
+    >>> from sympy.holonomic.holonomic import DifferentialOperators
+    >>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x), 'Dx')
+    >>> R
+    Univariate Differential Operator Algebra in intermediate Dx over the base ring ZZ[x]
+    >>> Dx*x
+    (1) + (x)*Dx
+    """
+
+    ring = DifferentialOperatorAlgebra(base, generator)
+    return (ring, ring.derivative_operator)
+
+
+class DifferentialOperatorAlgebra:
+    r"""
+    An Ore Algebra is a set of noncommutative polynomials in the
+    intermediate ``Dx`` and coefficients in a base polynomial ring :math:`A`.
+    It follows the commutation rule:
+
+    .. math ::
+       Dxa = \sigma(a)Dx + \delta(a)
+
+    for :math:`a \subset A`.
+
+    Where :math:`\sigma: A \Rightarrow A` is an endomorphism and :math:`\delta: A \rightarrow A`
+    is a skew-derivation i.e. :math:`\delta(ab) = \delta(a) b + \sigma(a) \delta(b)`.
+
+    If one takes the sigma as identity map and delta as the standard derivation
+    then it becomes the algebra of Differential Operators also called
+    a Weyl Algebra i.e. an algebra whose elements are Differential Operators.
+
+    This class represents a Weyl Algebra and serves as the parent ring for
+    Differential Operators.
+
+    Examples
+    ========
+
+    >>> from sympy import ZZ
+    >>> from sympy import symbols
+    >>> from sympy.holonomic.holonomic import DifferentialOperators
+    >>> x = symbols('x')
+    >>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x), 'Dx')
+    >>> R
+    Univariate Differential Operator Algebra in intermediate Dx over the base ring
+    ZZ[x]
+
+    See Also
+    ========
+
+    DifferentialOperator
+    """
+
+    def __init__(self, base, generator):
+        # the base polynomial ring for the algebra
+        self.base = base
+        # the operator representing differentiation i.e. `Dx`
+        self.derivative_operator = DifferentialOperator(
+            [base.zero, base.one], self)
+
+        if generator is None:
+            self.gen_symbol = Symbol('Dx', commutative=False)
+        else:
+            if isinstance(generator, str):
+                self.gen_symbol = Symbol(generator, commutative=False)
+            elif isinstance(generator, Symbol):
+                self.gen_symbol = generator
+
+    def __str__(self):
+        string = 'Univariate Differential Operator Algebra in intermediate '\
+            + sstr(self.gen_symbol) + ' over the base ring ' + \
+            (self.base).__str__()
+
+        return string
+
+    __repr__ = __str__
+
+    def __eq__(self, other):
+        return self.base == other.base and \
+               self.gen_symbol == other.gen_symbol
+
+
+class DifferentialOperator:
+    """
+    Differential Operators are elements of Weyl Algebra. The Operators
+    are defined by a list of polynomials in the base ring and the
+    parent ring of the Operator i.e. the algebra it belongs to.
+
+    Explanation
+    ===========
+
+    Takes a list of polynomials for each power of ``Dx`` and the
+    parent ring which must be an instance of DifferentialOperatorAlgebra.
+
+    A Differential Operator can be created easily using
+    the operator ``Dx``. See examples below.
+
+    Examples
+    ========
+
+    >>> from sympy.holonomic.holonomic import DifferentialOperator, DifferentialOperators
+    >>> from sympy import ZZ
+    >>> from sympy import symbols
+    >>> x = symbols('x')
+    >>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x),'Dx')
+
+    >>> DifferentialOperator([0, 1, x**2], R)
+    (1)*Dx + (x**2)*Dx**2
+
+    >>> (x*Dx*x + 1 - Dx**2)**2
+    (2*x**2 + 2*x + 1) + (4*x**3 + 2*x**2 - 4)*Dx + (x**4 - 6*x - 2)*Dx**2 + (-2*x**2)*Dx**3 + (1)*Dx**4
+
+    See Also
+    ========
+
+    DifferentialOperatorAlgebra
+    """
+
+    _op_priority = 20
+
+    def __init__(self, list_of_poly, parent):
+        """
+        Parameters
+        ==========
+
+        list_of_poly:
+            List of polynomials belonging to the base ring of the algebra.
+        parent:
+            Parent algebra of the operator.
+        """
+
+        # the parent ring for this operator
+        # must be an DifferentialOperatorAlgebra object
+        self.parent = parent
+        base = self.parent.base
+        self.x = base.gens[0] if isinstance(base.gens[0], Symbol) else base.gens[0][0]
+        # sequence of polynomials in x for each power of Dx
+        # the list should not have trailing zeroes
+        # represents the operator
+        # convert the expressions into ring elements using from_sympy
+        for i, j in enumerate(list_of_poly):
+            if not isinstance(j, base.dtype):
+                list_of_poly[i] = base.from_sympy(sympify(j))
+            else:
+                list_of_poly[i] = base.from_sympy(base.to_sympy(j))
+
+        self.listofpoly = list_of_poly
+        # highest power of `Dx`
+        self.order = len(self.listofpoly) - 1
+
+    def __mul__(self, other):
+        """
+        Multiplies two DifferentialOperator and returns another
+        DifferentialOperator instance using the commutation rule
+        Dx*a = a*Dx + a'
+        """
+
+        listofself = self.listofpoly
+        if isinstance(other, DifferentialOperator):
+            listofother = other.listofpoly
+        elif isinstance(other, self.parent.base.dtype):
+            listofother = [other]
+        else:
+            listofother = [self.parent.base.from_sympy(sympify(other))]
+
+        # multiplies a polynomial `b` with a list of polynomials
+        def _mul_dmp_diffop(b, listofother):
+            if isinstance(listofother, list):
+                return [i * b for i in listofother]
+            return [b * listofother]
+
+        sol = _mul_dmp_diffop(listofself[0], listofother)
+
+        # compute Dx^i * b
+        def _mul_Dxi_b(b):
+            sol1 = [self.parent.base.zero]
+            sol2 = []
+
+            if isinstance(b, list):
+                for i in b:
+                    sol1.append(i)
+                    sol2.append(i.diff())
+            else:
+                sol1.append(self.parent.base.from_sympy(b))
+                sol2.append(self.parent.base.from_sympy(b).diff())
+
+            return _add_lists(sol1, sol2)
+
+        for i in range(1, len(listofself)):
+            # find Dx^i * b in ith iteration
+            listofother = _mul_Dxi_b(listofother)
+            # solution = solution + listofself[i] * (Dx^i * b)
+            sol = _add_lists(sol, _mul_dmp_diffop(listofself[i], listofother))
+
+        return DifferentialOperator(sol, self.parent)
+
+    def __rmul__(self, other):
+        if not isinstance(other, DifferentialOperator):
+
+            if not isinstance(other, self.parent.base.dtype):
+                other = (self.parent.base).from_sympy(sympify(other))
+
+            sol = [other * j for j in self.listofpoly]
+            return DifferentialOperator(sol, self.parent)
+
+    def __add__(self, other):
+        if isinstance(other, DifferentialOperator):
+
+            sol = _add_lists(self.listofpoly, other.listofpoly)
+            return DifferentialOperator(sol, self.parent)
+
+        list_self = self.listofpoly
+        if not isinstance(other, self.parent.base.dtype):
+            list_other = [((self.parent).base).from_sympy(sympify(other))]
+        else:
+            list_other = [other]
+        sol = [list_self[0] + list_other[0]] + list_self[1:]
+        return DifferentialOperator(sol, self.parent)
+
+    __radd__ = __add__
+
+    def __sub__(self, other):
+        return self + (-1) * other
+
+    def __rsub__(self, other):
+        return (-1) * self + other
+
+    def __neg__(self):
+        return -1 * self
+
+    def __truediv__(self, other):
+        return self * (S.One / other)
+
+    def __pow__(self, n):
+        if n == 1:
+            return self
+        result = DifferentialOperator([self.parent.base.one], self.parent)
+        if n == 0:
+            return result
+        # if self is `Dx`
+        if self.listofpoly == self.parent.derivative_operator.listofpoly:
+            sol = [self.parent.base.zero]*n + [self.parent.base.one]
+            return DifferentialOperator(sol, self.parent)
+        x = self
+        while True:
+            if n % 2:
+                result *= x
+            n >>= 1
+            if not n:
+                break
+            x *= x
+        return result
+
+    def __str__(self):
+        listofpoly = self.listofpoly
+        print_str = ''
+
+        for i, j in enumerate(listofpoly):
+            if j == self.parent.base.zero:
+                continue
+
+            j = self.parent.base.to_sympy(j)
+
+            if i == 0:
+                print_str += '(' + sstr(j) + ')'
+                continue
+
+            if print_str:
+                print_str += ' + '
+
+            if i == 1:
+                print_str += '(' + sstr(j) + ')*%s' %(self.parent.gen_symbol)
+                continue
+
+            print_str += '(' + sstr(j) + ')' + '*%s**' %(self.parent.gen_symbol) + sstr(i)
+
+        return print_str
+
+    __repr__ = __str__
+
+    def __eq__(self, other):
+        if isinstance(other, DifferentialOperator):
+            return self.listofpoly == other.listofpoly and \
+                   self.parent == other.parent
+        return self.listofpoly[0] == other and \
+            all(i is self.parent.base.zero for i in self.listofpoly[1:])
+
+    def is_singular(self, x0):
+        """
+        Checks if the differential equation is singular at x0.
+        """
+
+        base = self.parent.base
+        return x0 in roots(base.to_sympy(self.listofpoly[-1]), self.x)
+
+
+class HolonomicFunction:
+    r"""
+    A Holonomic Function is a solution to a linear homogeneous ordinary
+    differential equation with polynomial coefficients. This differential
+    equation can also be represented by an annihilator i.e. a Differential
+    Operator ``L`` such that :math:`L.f = 0`. For uniqueness of these functions,
+    initial conditions can also be provided along with the annihilator.
+
+    Explanation
+    ===========
+
+    Holonomic functions have closure properties and thus forms a ring.
+    Given two Holonomic Functions f and g, their sum, product,
+    integral and derivative is also a Holonomic Function.
+
+    For ordinary points initial condition should be a vector of values of
+    the derivatives i.e. :math:`[y(x_0), y'(x_0), y''(x_0) ... ]`.
+
+    For regular singular points initial conditions can also be provided in this
+    format:
+    :math:`{s0: [C_0, C_1, ...], s1: [C^1_0, C^1_1, ...], ...}`
+    where s0, s1, ... are the roots of indicial equation and vectors
+    :math:`[C_0, C_1, ...], [C^0_0, C^0_1, ...], ...` are the corresponding initial
+    terms of the associated power series. See Examples below.
+
+    Examples
+    ========
+
+    >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
+    >>> from sympy import QQ
+    >>> from sympy import symbols, S
+    >>> x = symbols('x')
+    >>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx')
+
+    >>> p = HolonomicFunction(Dx - 1, x, 0, [1])  # e^x
+    >>> q = HolonomicFunction(Dx**2 + 1, x, 0, [0, 1])  # sin(x)
+
+    >>> p + q  # annihilator of e^x + sin(x)
+    HolonomicFunction((-1) + (1)*Dx + (-1)*Dx**2 + (1)*Dx**3, x, 0, [1, 2, 1])
+
+    >>> p * q  # annihilator of e^x * sin(x)
+    HolonomicFunction((2) + (-2)*Dx + (1)*Dx**2, x, 0, [0, 1])
+
+    An example of initial conditions for regular singular points,
+    the indicial equation has only one root `1/2`.
+
+    >>> HolonomicFunction(-S(1)/2 + x*Dx, x, 0, {S(1)/2: [1]})
+    HolonomicFunction((-1/2) + (x)*Dx, x, 0, {1/2: [1]})
+
+    >>> HolonomicFunction(-S(1)/2 + x*Dx, x, 0, {S(1)/2: [1]}).to_expr()
+    sqrt(x)
+
+    To plot a Holonomic Function, one can use `.evalf()` for numerical
+    computation. Here's an example on `sin(x)**2/x` using numpy and matplotlib.
+
+    >>> import sympy.holonomic # doctest: +SKIP
+    >>> from sympy import var, sin # doctest: +SKIP
+    >>> import matplotlib.pyplot as plt # doctest: +SKIP
+    >>> import numpy as np # doctest: +SKIP
+    >>> var("x") # doctest: +SKIP
+    >>> r = np.linspace(1, 5, 100) # doctest: +SKIP
+    >>> y = sympy.holonomic.expr_to_holonomic(sin(x)**2/x, x0=1).evalf(r) # doctest: +SKIP
+    >>> plt.plot(r, y, label="holonomic function") # doctest: +SKIP
+    >>> plt.show() # doctest: +SKIP
+
+    """
+
+    _op_priority = 20
+
+    def __init__(self, annihilator, x, x0=0, y0=None):
+        """
+
+        Parameters
+        ==========
+
+        annihilator:
+            Annihilator of the Holonomic Function, represented by a
+            `DifferentialOperator` object.
+        x:
+            Variable of the function.
+        x0:
+            The point at which initial conditions are stored.
+            Generally an integer.
+        y0:
+            The initial condition. The proper format for the initial condition
+            is described in class docstring. To make the function unique,
+            length of the vector `y0` should be equal to or greater than the
+            order of differential equation.
+        """
+
+        # initial condition
+        self.y0 = y0
+        # the point for initial conditions, default is zero.
+        self.x0 = x0
+        # differential operator L such that L.f = 0
+        self.annihilator = annihilator
+        self.x = x
+
+    def __str__(self):
+        if self._have_init_cond():
+            str_sol = 'HolonomicFunction(%s, %s, %s, %s)' % (str(self.annihilator),\
+                sstr(self.x), sstr(self.x0), sstr(self.y0))
+        else:
+            str_sol = 'HolonomicFunction(%s, %s)' % (str(self.annihilator),\
+                sstr(self.x))
+
+        return str_sol
+
+    __repr__ = __str__
+
+    def unify(self, other):
+        """
+        Unifies the base polynomial ring of a given two Holonomic
+        Functions.
+        """
+
+        R1 = self.annihilator.parent.base
+        R2 = other.annihilator.parent.base
+
+        dom1 = R1.dom
+        dom2 = R2.dom
+
+        if R1 == R2:
+            return (self, other)
+
+        R = (dom1.unify(dom2)).old_poly_ring(self.x)
+
+        newparent, _ = DifferentialOperators(R, str(self.annihilator.parent.gen_symbol))
+
+        sol1 = [R1.to_sympy(i) for i in self.annihilator.listofpoly]
+        sol2 = [R2.to_sympy(i) for i in other.annihilator.listofpoly]
+
+        sol1 = DifferentialOperator(sol1, newparent)
+        sol2 = DifferentialOperator(sol2, newparent)
+
+        sol1 = HolonomicFunction(sol1, self.x, self.x0, self.y0)
+        sol2 = HolonomicFunction(sol2, other.x, other.x0, other.y0)
+
+        return (sol1, sol2)
+
+    def is_singularics(self):
+        """
+        Returns True if the function have singular initial condition
+        in the dictionary format.
+
+        Returns False if the function have ordinary initial condition
+        in the list format.
+
+        Returns None for all other cases.
+        """
+
+        if isinstance(self.y0, dict):
+            return True
+        elif isinstance(self.y0, list):
+            return False
+
+    def _have_init_cond(self):
+        """
+        Checks if the function have initial condition.
+        """
+        return bool(self.y0)
+
+    def _singularics_to_ord(self):
+        """
+        Converts a singular initial condition to ordinary if possible.
+        """
+        a = list(self.y0)[0]
+        b = self.y0[a]
+
+        if len(self.y0) == 1 and a == int(a) and a > 0:
+            a = int(a)
+            y0 = [S.Zero] * a
+            y0 += [j * factorial(a + i) for i, j in enumerate(b)]
+
+            return HolonomicFunction(self.annihilator, self.x, self.x0, y0)
+
+    def __add__(self, other):
+        # if the ground domains are different
+        if self.annihilator.parent.base != other.annihilator.parent.base:
+            a, b = self.unify(other)
+            return a + b
+
+        deg1 = self.annihilator.order
+        deg2 = other.annihilator.order
+        dim = max(deg1, deg2)
+        R = self.annihilator.parent.base
+        K = R.get_field()
+
+        rowsself = [self.annihilator]
+        rowsother = [other.annihilator]
+        gen = self.annihilator.parent.derivative_operator
+
+        # constructing annihilators up to order dim
+        for i in range(dim - deg1):
+            diff1 = (gen * rowsself[-1])
+            rowsself.append(diff1)
+
+        for i in range(dim - deg2):
+            diff2 = (gen * rowsother[-1])
+            rowsother.append(diff2)
+
+        row = rowsself + rowsother
+
+        # constructing the matrix of the ansatz
+        r = []
+
+        for expr in row:
+            p = []
+            for i in range(dim + 1):
+                if i >= len(expr.listofpoly):
+                    p.append(K.zero)
+                else:
+                    p.append(K.new(expr.listofpoly[i].to_list()))
+            r.append(p)
+
+        # solving the linear system using gauss jordan solver
+        r = DomainMatrix(r, (len(row), dim+1), K).transpose()
+        homosys = DomainMatrix.zeros((dim+1, 1), K)
+        sol = _find_nonzero_solution(r, homosys)
+
+        # if a solution is not obtained then increasing the order by 1 in each
+        # iteration
+        while sol.is_zero_matrix:
+            dim += 1
+
+            diff1 = (gen * rowsself[-1])
+            rowsself.append(diff1)
+
+            diff2 = (gen * rowsother[-1])
+            rowsother.append(diff2)
+
+            row = rowsself + rowsother
+            r = []
+
+            for expr in row:
+                p = []
+                for i in range(dim + 1):
+                    if i >= len(expr.listofpoly):
+                        p.append(K.zero)
+                    else:
+                        p.append(K.new(expr.listofpoly[i].to_list()))
+                r.append(p)
+
+            # solving the linear system using gauss jordan solver
+            r = DomainMatrix(r, (len(row), dim+1), K).transpose()
+            homosys = DomainMatrix.zeros((dim+1, 1), K)
+            sol = _find_nonzero_solution(r, homosys)
+
+        # taking only the coefficients needed to multiply with `self`
+        # can be also be done the other way by taking R.H.S and multiplying with
+        # `other`
+        sol = sol.flat()[:dim + 1 - deg1]
+        sol1 = _normalize(sol, self.annihilator.parent)
+        # annihilator of the solution
+        sol = sol1 * (self.annihilator)
+        sol = _normalize(sol.listofpoly, self.annihilator.parent, negative=False)
+
+        if not (self._have_init_cond() and other._have_init_cond()):
+            return HolonomicFunction(sol, self.x)
+
+        # both the functions have ordinary initial conditions
+        if self.is_singularics() == False and other.is_singularics() == False:
+
+            # directly add the corresponding value
+            if self.x0 == other.x0:
+                # try to extended the initial conditions
+                # using the annihilator
+                y1 = _extend_y0(self, sol.order)
+                y2 = _extend_y0(other, sol.order)
+                y0 = [a + b for a, b in zip(y1, y2)]
+                return HolonomicFunction(sol, self.x, self.x0, y0)
+
+            # change the initial conditions to a same point
+            selfat0 = self.annihilator.is_singular(0)
+            otherat0 = other.annihilator.is_singular(0)
+            if self.x0 == 0 and not selfat0 and not otherat0:
+                return self + other.change_ics(0)
+            if other.x0 == 0 and not selfat0 and not otherat0:
+                return self.change_ics(0) + other
+
+            selfatx0 = self.annihilator.is_singular(self.x0)
+            otheratx0 = other.annihilator.is_singular(self.x0)
+            if not selfatx0 and not otheratx0:
+                return self + other.change_ics(self.x0)
+            return self.change_ics(other.x0) + other
+
+        if self.x0 != other.x0:
+            return HolonomicFunction(sol, self.x)
+
+        # if the functions have singular_ics
+        y1 = None
+        y2 = None
+
+        if self.is_singularics() == False and other.is_singularics() == True:
+            # convert the ordinary initial condition to singular.
+            _y0 = [j / factorial(i) for i, j in enumerate(self.y0)]
+            y1 = {S.Zero: _y0}
+            y2 = other.y0
+        elif self.is_singularics() == True and other.is_singularics() == False:
+            _y0 = [j / factorial(i) for i, j in enumerate(other.y0)]
+            y1 = self.y0
+            y2 = {S.Zero: _y0}
+        elif self.is_singularics() == True and other.is_singularics() == True:
+            y1 = self.y0
+            y2 = other.y0
+
+        # computing singular initial condition for the result
+        # taking union of the series terms of both functions
+        y0 = {}
+        for i in y1:
+            # add corresponding initial terms if the power
+            # on `x` is same
+            if i in y2:
+                y0[i] = [a + b for a, b in zip(y1[i], y2[i])]
+            else:
+                y0[i] = y1[i]
+        for i in y2:
+            if i not in y1:
+                y0[i] = y2[i]
+        return HolonomicFunction(sol, self.x, self.x0, y0)
+
+    def integrate(self, limits, initcond=False):
+        """
+        Integrates the given holonomic function.
+
+        Examples
+        ========
+
+        >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
+        >>> from sympy import QQ
+        >>> from sympy import symbols
+        >>> x = symbols('x')
+        >>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx')
+        >>> HolonomicFunction(Dx - 1, x, 0, [1]).integrate((x, 0, x))  # e^x - 1
+        HolonomicFunction((-1)*Dx + (1)*Dx**2, x, 0, [0, 1])
+        >>> HolonomicFunction(Dx**2 + 1, x, 0, [1, 0]).integrate((x, 0, x))
+        HolonomicFunction((1)*Dx + (1)*Dx**3, x, 0, [0, 1, 0])
+        """
+
+        # to get the annihilator, just multiply by Dx from right
+        D = self.annihilator.parent.derivative_operator
+
+        # if the function have initial conditions of the series format
+        if self.is_singularics() == True:
+
+            r = self._singularics_to_ord()
+            if r:
+                return r.integrate(limits, initcond=initcond)
+
+            # computing singular initial condition for the function
+            # produced after integration.
+            y0 = {}
+            for i in self.y0:
+                c = self.y0[i]
+                c2 = []
+                for j, cj in enumerate(c):
+                    if cj == 0:
+                        c2.append(S.Zero)
+
+                    # if power on `x` is -1, the integration becomes log(x)
+                    # TODO: Implement this case
+                    elif i + j + 1 == 0:
+                        raise NotImplementedError("logarithmic terms in the series are not supported")
+                    else:
+                        c2.append(cj / S(i + j + 1))
+                y0[i + 1] = c2
+
+            if hasattr(limits, "__iter__"):
+                raise NotImplementedError("Definite integration for singular initial conditions")
+
+            return HolonomicFunction(self.annihilator * D, self.x, self.x0, y0)
+
+        # if no initial conditions are available for the function
+        if not self._have_init_cond():
+            if initcond:
+                return HolonomicFunction(self.annihilator * D, self.x, self.x0, [S.Zero])
+            return HolonomicFunction(self.annihilator * D, self.x)
+
+        # definite integral
+        # initial conditions for the answer will be stored at point `a`,
+        # where `a` is the lower limit of the integrand
+        if hasattr(limits, "__iter__"):
+
+            if len(limits) == 3 and limits[0] == self.x:
+                x0 = self.x0
+                a = limits[1]
+                b = limits[2]
+                definite = True
+
+        else:
+            definite = False
+
+        y0 = [S.Zero]
+        y0 += self.y0
+
+        indefinite_integral = HolonomicFunction(self.annihilator * D, self.x, self.x0, y0)
+
+        if not definite:
+            return indefinite_integral
+
+        # use evalf to get the values at `a`
+        if x0 != a:
+            try:
+                indefinite_expr = indefinite_integral.to_expr()
+            except (NotHyperSeriesError, NotPowerSeriesError):
+                indefinite_expr = None
+
+            if indefinite_expr:
+                lower = indefinite_expr.subs(self.x, a)
+                if isinstance(lower, NaN):
+                    lower = indefinite_expr.limit(self.x, a)
+            else:
+                lower = indefinite_integral.evalf(a)
+
+            if b == self.x:
+                y0[0] = y0[0] - lower
+                return HolonomicFunction(self.annihilator * D, self.x, x0, y0)
+
+            elif S(b).is_Number:
+                if indefinite_expr:
+                    upper = indefinite_expr.subs(self.x, b)
+                    if isinstance(upper, NaN):
+                        upper = indefinite_expr.limit(self.x, b)
+                else:
+                    upper = indefinite_integral.evalf(b)
+
+                return upper - lower
+
+
+        # if the upper limit is `x`, the answer will be a function
+        if b == self.x:
+            return HolonomicFunction(self.annihilator * D, self.x, a, y0)
+
+        # if the upper limits is a Number, a numerical value will be returned
+        elif S(b).is_Number:
+            try:
+                s = HolonomicFunction(self.annihilator * D, self.x, a,\
+                    y0).to_expr()
+                indefinite = s.subs(self.x, b)
+                if not isinstance(indefinite, NaN):
+                    return indefinite
+                else:
+                    return s.limit(self.x, b)
+            except (NotHyperSeriesError, NotPowerSeriesError):
+                return HolonomicFunction(self.annihilator * D, self.x, a, y0).evalf(b)
+
+        return HolonomicFunction(self.annihilator * D, self.x)
+
+    def diff(self, *args, **kwargs):
+        r"""
+        Differentiation of the given Holonomic function.
+
+        Examples
+        ========
+
+        >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
+        >>> from sympy import ZZ
+        >>> from sympy import symbols
+        >>> x = symbols('x')
+        >>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x),'Dx')
+        >>> HolonomicFunction(Dx**2 + 1, x, 0, [0, 1]).diff().to_expr()
+        cos(x)
+        >>> HolonomicFunction(Dx - 2, x, 0, [1]).diff().to_expr()
+        2*exp(2*x)
+
+        See Also
+        ========
+
+        integrate
+        """
+        kwargs.setdefault('evaluate', True)
+        if args:
+            if args[0] != self.x:
+                return S.Zero
+            elif len(args) == 2:
+                sol = self
+                for i in range(args[1]):
+                    sol = sol.diff(args[0])
+                return sol
+
+        ann = self.annihilator
+
+        # if the function is constant.
+        if ann.listofpoly[0] == ann.parent.base.zero and ann.order == 1:
+            return S.Zero
+
+        # if the coefficient of y in the differential equation is zero.
+        # a shifting is done to compute the answer in this case.
+        elif ann.listofpoly[0] == ann.parent.base.zero:
+
+            sol = DifferentialOperator(ann.listofpoly[1:], ann.parent)
+
+            if self._have_init_cond():
+                # if ordinary initial condition
+                if self.is_singularics() == False:
+                    return HolonomicFunction(sol, self.x, self.x0, self.y0[1:])
+                # TODO: support for singular initial condition
+                return HolonomicFunction(sol, self.x)
+            else:
+                return HolonomicFunction(sol, self.x)
+
+        # the general algorithm
+        R = ann.parent.base
+        K = R.get_field()
+
+        seq_dmf = [K.new(i.to_list()) for i in ann.listofpoly]
+
+        # -y = a1*y'/a0 + a2*y''/a0 ... + an*y^n/a0
+        rhs = [i / seq_dmf[0] for i in seq_dmf[1:]]
+        rhs.insert(0, K.zero)
+
+        # differentiate both lhs and rhs
+        sol = _derivate_diff_eq(rhs, K)
+
+        # add the term y' in lhs to rhs
+        sol = _add_lists(sol, [K.zero, K.one])
+
+        sol = _normalize(sol[1:], self.annihilator.parent, negative=False)
+
+        if not self._have_init_cond() or self.is_singularics() == True:
+            return HolonomicFunction(sol, self.x)
+
+        y0 = _extend_y0(self, sol.order + 1)[1:]
+        return HolonomicFunction(sol, self.x, self.x0, y0)
+
+    def __eq__(self, other):
+        if self.annihilator != other.annihilator or self.x != other.x:
+            return False
+        if self._have_init_cond() and other._have_init_cond():
+            return self.x0 == other.x0 and self.y0 == other.y0
+        return True
+
+    def __mul__(self, other):
+        ann_self = self.annihilator
+
+        if not isinstance(other, HolonomicFunction):
+            other = sympify(other)
+
+            if other.has(self.x):
+                raise NotImplementedError(" Can't multiply a HolonomicFunction and expressions/functions.")
+
+            if not self._have_init_cond():
+                return self
+            y0 = _extend_y0(self, ann_self.order)
+            y1 = [(Poly.new(j, self.x) * other).rep for j in y0]
+            return HolonomicFunction(ann_self, self.x, self.x0, y1)
+
+        if self.annihilator.parent.base != other.annihilator.parent.base:
+            a, b = self.unify(other)
+            return a * b
+
+        ann_other = other.annihilator
+
+        a = ann_self.order
+        b = ann_other.order
+
+        R = ann_self.parent.base
+        K = R.get_field()
+
+        list_self = [K.new(j.to_list()) for j in ann_self.listofpoly]
+        list_other = [K.new(j.to_list()) for j in ann_other.listofpoly]
+
+        # will be used to reduce the degree
+        self_red = [-list_self[i] / list_self[a] for i in range(a)]
+
+        other_red = [-list_other[i] / list_other[b] for i in range(b)]
+
+        # coeff_mull[i][j] is the coefficient of Dx^i(f).Dx^j(g)
+        coeff_mul = [[K.zero for i in range(b + 1)] for j in range(a + 1)]
+        coeff_mul[0][0] = K.one
+
+        # making the ansatz
+        lin_sys_elements = [[coeff_mul[i][j] for i in range(a) for j in range(b)]]
+        lin_sys = DomainMatrix(lin_sys_elements, (1, a*b), K).transpose()
+
+        homo_sys = DomainMatrix.zeros((a*b, 1), K)
+
+        sol = _find_nonzero_solution(lin_sys, homo_sys)
+
+        # until a non trivial solution is found
+        while sol.is_zero_matrix:
+
+            # updating the coefficients Dx^i(f).Dx^j(g) for next degree
+            for i in range(a - 1, -1, -1):
+                for j in range(b - 1, -1, -1):
+                    coeff_mul[i][j + 1] += coeff_mul[i][j]
+                    coeff_mul[i + 1][j] += coeff_mul[i][j]
+                    if isinstance(coeff_mul[i][j], K.dtype):
+                        coeff_mul[i][j] = DMFdiff(coeff_mul[i][j], K)
+                    else:
+                        coeff_mul[i][j] = coeff_mul[i][j].diff(self.x)
+
+            # reduce the terms to lower power using annihilators of f, g
+            for i in range(a + 1):
+                if coeff_mul[i][b].is_zero:
+                    continue
+                for j in range(b):
+                    coeff_mul[i][j] += other_red[j] * coeff_mul[i][b]
+                coeff_mul[i][b] = K.zero
+
+            # not d2 + 1, as that is already covered in previous loop
+            for j in range(b):
+                if coeff_mul[a][j] == 0:
+                    continue
+                for i in range(a):
+                    coeff_mul[i][j] += self_red[i] * coeff_mul[a][j]
+                coeff_mul[a][j] = K.zero
+
+            lin_sys_elements.append([coeff_mul[i][j] for i in range(a) for j in range(b)])
+            lin_sys = DomainMatrix(lin_sys_elements, (len(lin_sys_elements), a*b), K).transpose()
+
+            sol = _find_nonzero_solution(lin_sys, homo_sys)
+
+        sol_ann = _normalize(sol.flat(), self.annihilator.parent, negative=False)
+
+        if not (self._have_init_cond() and other._have_init_cond()):
+            return HolonomicFunction(sol_ann, self.x)
+
+        if self.is_singularics() == False and other.is_singularics() == False:
+
+            # if both the conditions are at same point
+            if self.x0 == other.x0:
+
+                # try to find more initial conditions
+                y0_self = _extend_y0(self, sol_ann.order)
+                y0_other = _extend_y0(other, sol_ann.order)
+                # h(x0) = f(x0) * g(x0)
+                y0 = [y0_self[0] * y0_other[0]]
+
+                # coefficient of Dx^j(f)*Dx^i(g) in Dx^i(fg)
+                for i in range(1, min(len(y0_self), len(y0_other))):
+                    coeff = [[0 for i in range(i + 1)] for j in range(i + 1)]
+                    for j in range(i + 1):
+                        for k in range(i + 1):
+                            if j + k == i:
+                                coeff[j][k] = binomial(i, j)
+
+                    sol = 0
+                    for j in range(i + 1):
+                        for k in range(i + 1):
+                            sol += coeff[j][k]* y0_self[j] * y0_other[k]
+
+                    y0.append(sol)
+
+                return HolonomicFunction(sol_ann, self.x, self.x0, y0)
+
+            # if the points are different, consider one
+            selfat0 = self.annihilator.is_singular(0)
+            otherat0 = other.annihilator.is_singular(0)
+
+            if self.x0 == 0 and not selfat0 and not otherat0:
+                return self * other.change_ics(0)
+            if other.x0 == 0 and not selfat0 and not otherat0:
+                return self.change_ics(0) * other
+
+            selfatx0 = self.annihilator.is_singular(self.x0)
+            otheratx0 = other.annihilator.is_singular(self.x0)
+            if not selfatx0 and not otheratx0:
+                return self * other.change_ics(self.x0)
+            return self.change_ics(other.x0) * other
+
+        if self.x0 != other.x0:
+            return HolonomicFunction(sol_ann, self.x)
+
+        # if the functions have singular_ics
+        y1 = None
+        y2 = None
+
+        if self.is_singularics() == False and other.is_singularics() == True:
+            _y0 = [j / factorial(i) for i, j in enumerate(self.y0)]
+            y1 = {S.Zero: _y0}
+            y2 = other.y0
+        elif self.is_singularics() == True and other.is_singularics() == False:
+            _y0 = [j / factorial(i) for i, j in enumerate(other.y0)]
+            y1 = self.y0
+            y2 = {S.Zero: _y0}
+        elif self.is_singularics() == True and other.is_singularics() == True:
+            y1 = self.y0
+            y2 = other.y0
+
+        y0 = {}
+        # multiply every possible pair of the series terms
+        for i in y1:
+            for j in y2:
+                k = min(len(y1[i]), len(y2[j]))
+                c = [sum((y1[i][b] * y2[j][a - b] for b in range(a + 1)),
+                         start=S.Zero) for a in range(k)]
+                if not i + j in y0:
+                    y0[i + j] = c
+                else:
+                    y0[i + j] = [a + b for a, b in zip(c, y0[i + j])]
+        return HolonomicFunction(sol_ann, self.x, self.x0, y0)
+
+    __rmul__ = __mul__
+
+    def __sub__(self, other):
+        return self + other * -1
+
+    def __rsub__(self, other):
+        return self * -1 + other
+
+    def __neg__(self):
+        return -1 * self
+
+    def __truediv__(self, other):
+        return self * (S.One / other)
+
+    def __pow__(self, n):
+        if self.annihilator.order <= 1:
+            ann = self.annihilator
+            parent = ann.parent
+
+            if self.y0 is None:
+                y0 = None
+            else:
+                y0 = [list(self.y0)[0] ** n]
+
+            p0 = ann.listofpoly[0]
+            p1 = ann.listofpoly[1]
+
+            p0 = (Poly.new(p0, self.x) * n).rep
+
+            sol = [parent.base.to_sympy(i) for i in [p0, p1]]
+            dd = DifferentialOperator(sol, parent)
+            return HolonomicFunction(dd, self.x, self.x0, y0)
+        if n < 0:
+            raise NotHolonomicError("Negative Power on a Holonomic Function")
+        Dx = self.annihilator.parent.derivative_operator
+        result = HolonomicFunction(Dx, self.x, S.Zero, [S.One])
+        if n == 0:
+            return result
+        x = self
+        while True:
+            if n % 2:
+                result *= x
+            n >>= 1
+            if not n:
+                break
+            x *= x
+        return result
+
+    def degree(self):
+        """
+        Returns the highest power of `x` in the annihilator.
+        """
+        return max(i.degree() for i in self.annihilator.listofpoly)
+
+    def composition(self, expr, *args, **kwargs):
+        """
+        Returns function after composition of a holonomic
+        function with an algebraic function. The method cannot compute
+        initial conditions for the result by itself, so they can be also be
+        provided.
+
+        Examples
+        ========
+
+        >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
+        >>> from sympy import QQ
+        >>> from sympy import symbols
+        >>> x = symbols('x')
+        >>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx')
+        >>> HolonomicFunction(Dx - 1, x).composition(x**2, 0, [1])  # e^(x**2)
+        HolonomicFunction((-2*x) + (1)*Dx, x, 0, [1])
+        >>> HolonomicFunction(Dx**2 + 1, x).composition(x**2 - 1, 1, [1, 0])
+        HolonomicFunction((4*x**3) + (-1)*Dx + (x)*Dx**2, x, 1, [1, 0])
+
+        See Also
+        ========
+
+        from_hyper
+        """
+
+        R = self.annihilator.parent
+        a = self.annihilator.order
+        diff = expr.diff(self.x)
+        listofpoly = self.annihilator.listofpoly
+
+        for i, j in enumerate(listofpoly):
+            if isinstance(j, self.annihilator.parent.base.dtype):
+                listofpoly[i] = self.annihilator.parent.base.to_sympy(j)
+
+        r = listofpoly[a].subs({self.x:expr})
+        subs = [-listofpoly[i].subs({self.x:expr}) / r for i in range (a)]
+        coeffs = [S.Zero for i in range(a)]  # coeffs[i] == coeff of (D^i f)(a) in D^k (f(a))
+        coeffs[0] = S.One
+        system = [coeffs]
+        homogeneous = Matrix([[S.Zero for i in range(a)]]).transpose()
+        while True:
+            coeffs_next = [p.diff(self.x) for p in coeffs]
+            for i in range(a - 1):
+                coeffs_next[i + 1] += (coeffs[i] * diff)
+            for i in range(a):
+                coeffs_next[i] += (coeffs[-1] * subs[i] * diff)
+            coeffs = coeffs_next
+            # check for linear relations
+            system.append(coeffs)
+            sol, taus = (Matrix(system).transpose()
+                ).gauss_jordan_solve(homogeneous)
+            if sol.is_zero_matrix is not True:
+                break
+
+        tau = list(taus)[0]
+        sol = sol.subs(tau, 1)
+        sol = _normalize(sol[0:], R, negative=False)
+
+        # if initial conditions are given for the resulting function
+        if args:
+            return HolonomicFunction(sol, self.x, args[0], args[1])
+        return HolonomicFunction(sol, self.x)
+
+    def to_sequence(self, lb=True):
+        r"""
+        Finds recurrence relation for the coefficients in the series expansion
+        of the function about :math:`x_0`, where :math:`x_0` is the point at
+        which the initial condition is stored.
+
+        Explanation
+        ===========
+
+        If the point :math:`x_0` is ordinary, solution of the form :math:`[(R, n_0)]`
+        is returned. Where :math:`R` is the recurrence relation and :math:`n_0` is the
+        smallest ``n`` for which the recurrence holds true.
+
+        If the point :math:`x_0` is regular singular, a list of solutions in
+        the format :math:`(R, p, n_0)` is returned, i.e. `[(R, p, n_0), ... ]`.
+        Each tuple in this vector represents a recurrence relation :math:`R`
+        associated with a root of the indicial equation ``p``. Conditions of
+        a different format can also be provided in this case, see the
+        docstring of HolonomicFunction class.
+
+        If it's not possible to numerically compute a initial condition,
+        it is returned as a symbol :math:`C_j`, denoting the coefficient of
+        :math:`(x - x_0)^j` in the power series about :math:`x_0`.
+
+        Examples
+        ========
+
+        >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
+        >>> from sympy import QQ
+        >>> from sympy import symbols, S
+        >>> x = symbols('x')
+        >>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx')
+        >>> HolonomicFunction(Dx - 1, x, 0, [1]).to_sequence()
+        [(HolonomicSequence((-1) + (n + 1)Sn, n), u(0) = 1, 0)]
+        >>> HolonomicFunction((1 + x)*Dx**2 + Dx, x, 0, [0, 1]).to_sequence()
+        [(HolonomicSequence((n**2) + (n**2 + n)Sn, n), u(0) = 0, u(1) = 1, u(2) = -1/2, 2)]
+        >>> HolonomicFunction(-S(1)/2 + x*Dx, x, 0, {S(1)/2: [1]}).to_sequence()
+        [(HolonomicSequence((n), n), u(0) = 1, 1/2, 1)]
+
+        See Also
+        ========
+
+        HolonomicFunction.series
+
+        References
+        ==========
+
+        .. [1] https://hal.inria.fr/inria-00070025/document
+        .. [2] https://www3.risc.jku.at/publications/download/risc_2244/DIPLFORM.pdf
+
+        """
+
+        if self.x0 != 0:
+            return self.shift_x(self.x0).to_sequence()
+
+        # check whether a power series exists if the point is singular
+        if self.annihilator.is_singular(self.x0):
+            return self._frobenius(lb=lb)
+
+        dict1 = {}
+        n = Symbol('n', integer=True)
+        dom = self.annihilator.parent.base.dom
+        R, _ = RecurrenceOperators(dom.old_poly_ring(n), 'Sn')
+
+        # substituting each term of the form `x^k Dx^j` in the
+        # annihilator, according to the formula below:
+        # x^k Dx^j = Sum(rf(n + 1 - k, j) * a(n + j - k) * x^n, (n, k, oo))
+        # for explanation see [2].
+        for i, j in enumerate(self.annihilator.listofpoly):
+
+            listofdmp = j.all_coeffs()
+            degree = len(listofdmp) - 1
+
+            for k in range(degree + 1):
+                coeff = listofdmp[degree - k]
+
+                if coeff == 0:
+                    continue
+
+                if (i - k, k) in dict1:
+                    dict1[(i - k, k)] += (dom.to_sympy(coeff) * rf(n - k + 1, i))
+                else:
+                    dict1[(i - k, k)] = (dom.to_sympy(coeff) * rf(n - k + 1, i))
+
+
+        sol = []
+        keylist = [i[0] for i in dict1]
+        lower = min(keylist)
+        upper = max(keylist)
+        degree = self.degree()
+
+        # the recurrence relation holds for all values of
+        # n greater than smallest_n, i.e. n >= smallest_n
+        smallest_n = lower + degree
+        dummys = {}
+        eqs = []
+        unknowns = []
+
+        # an appropriate shift of the recurrence
+        for j in range(lower, upper + 1):
+            if j in keylist:
+                temp = sum((v.subs(n, n - lower)
+                           for k, v in dict1.items() if k[0] == j),
+                           start=S.Zero)
+                sol.append(temp)
+            else:
+                sol.append(S.Zero)
+
+        # the recurrence relation
+        sol = RecurrenceOperator(sol, R)
+
+        # computing the initial conditions for recurrence
+        order = sol.order
+        all_roots = roots(R.base.to_sympy(sol.listofpoly[-1]), n, filter='Z')
+        all_roots = all_roots.keys()
+
+        if all_roots:
+            max_root = max(all_roots) + 1
+            smallest_n = max(max_root, smallest_n)
+        order += smallest_n
+
+        y0 = _extend_y0(self, order)
+        # u(n) = y^n(0)/factorial(n)
+        u0 = [j / factorial(i) for i, j in enumerate(y0)]
+
+        # if sufficient conditions can't be computed then
+        # try to use the series method i.e.
+        # equate the coefficients of x^k in the equation formed by
+        # substituting the series in differential equation, to zero.
+        if len(u0) < order:
+
+            for i in range(degree):
+                eq = S.Zero
+
+                for j in dict1:
+
+                    if i + j[0] < 0:
+                        dummys[i + j[0]] = S.Zero
+
+                    elif i + j[0] < len(u0):
+                        dummys[i + j[0]] = u0[i + j[0]]
+
+                    elif not i + j[0] in dummys:
+                        dummys[i + j[0]] = Symbol('C_%s' %(i + j[0]))
+                        unknowns.append(dummys[i + j[0]])
+
+                    if j[1] <= i:
+                        eq += dict1[j].subs(n, i) * dummys[i + j[0]]
+
+                eqs.append(eq)
+
+            # solve the system of equations formed
+            soleqs = solve(eqs, *unknowns)
+
+            if isinstance(soleqs, dict):
+
+                for i in range(len(u0), order):
+
+                    if i not in dummys:
+                        dummys[i] = Symbol('C_%s' %i)
+
+                    if dummys[i] in soleqs:
+                        u0.append(soleqs[dummys[i]])
+
+                    else:
+                        u0.append(dummys[i])
+
+                if lb:
+                    return [(HolonomicSequence(sol, u0), smallest_n)]
+                return [HolonomicSequence(sol, u0)]
+
+            for i in range(len(u0), order):
+
+                if i not in dummys:
+                    dummys[i] = Symbol('C_%s' %i)
+
+                s = False
+                for j in soleqs:
+                    if dummys[i] in j:
+                        u0.append(j[dummys[i]])
+                        s = True
+                if not s:
+                    u0.append(dummys[i])
+
+        if lb:
+            return [(HolonomicSequence(sol, u0), smallest_n)]
+
+        return [HolonomicSequence(sol, u0)]
+
+    def _frobenius(self, lb=True):
+        # compute the roots of indicial equation
+        indicialroots = self._indicial()
+
+        reals = []
+        compl = []
+        for i in ordered(indicialroots.keys()):
+            if i.is_real:
+                reals.extend([i] * indicialroots[i])
+            else:
+                a, b = i.as_real_imag()
+                compl.extend([(i, a, b)] * indicialroots[i])
+
+        # sort the roots for a fixed ordering of solution
+        compl.sort(key=lambda x : x[1])
+        compl.sort(key=lambda x : x[2])
+        reals.sort()
+
+        # grouping the roots, roots differ by an integer are put in the same group.
+        grp = []
+
+        for i in reals:
+            if len(grp) == 0:
+                grp.append([i])
+                continue
+            for j in grp:
+                if int_valued(j[0] - i):
+                    j.append(i)
+                    break
+            else:
+                grp.append([i])
+
+        # True if none of the roots differ by an integer i.e.
+        # each element in group have only one member
+        independent = all(len(i) == 1 for i in grp)
+
+        allpos = all(i >= 0 for i in reals)
+        allint = all(int_valued(i) for i in reals)
+
+        # if initial conditions are provided
+        # then use them.
+        if self.is_singularics() == True:
+            rootstoconsider = []
+            for i in ordered(self.y0.keys()):
+                for j in ordered(indicialroots.keys()):
+                    if equal_valued(j, i):
+                        rootstoconsider.append(i)
+
+        elif allpos and allint:
+            rootstoconsider = [min(reals)]
+
+        elif independent:
+            rootstoconsider = [i[0] for i in grp] + [j[0] for j in compl]
+
+        elif not allint:
+            rootstoconsider = [i for i in reals if not int(i) == i]
+
+        elif not allpos:
+
+            if not self._have_init_cond() or S(self.y0[0]).is_finite ==  False:
+                rootstoconsider = [min(reals)]
+
+            else:
+                posroots = [i for i in reals if i >= 0]
+                rootstoconsider = [min(posroots)]
+
+        n = Symbol('n', integer=True)
+        dom = self.annihilator.parent.base.dom
+        R, _ = RecurrenceOperators(dom.old_poly_ring(n), 'Sn')
+
+        finalsol = []
+        char = ord('C')
+
+        for p in rootstoconsider:
+            dict1 = {}
+
+            for i, j in enumerate(self.annihilator.listofpoly):
+
+                listofdmp = j.all_coeffs()
+                degree = len(listofdmp) - 1
+
+                for k in range(degree + 1):
+                    coeff = listofdmp[degree - k]
+
+                    if coeff == 0:
+                        continue
+
+                    if (i - k, k - i) in dict1:
+                        dict1[(i - k, k - i)] += (dom.to_sympy(coeff) * rf(n - k + 1 + p, i))
+                    else:
+                        dict1[(i - k, k - i)] = (dom.to_sympy(coeff) * rf(n - k + 1 + p, i))
+
+            sol = []
+            keylist = [i[0] for i in dict1]
+            lower = min(keylist)
+            upper = max(keylist)
+            degree = max(i[1] for i in dict1)
+            degree2 = min(i[1] for i in dict1)
+
+            smallest_n = lower + degree
+            dummys = {}
+            eqs = []
+            unknowns = []
+
+            for j in range(lower, upper + 1):
+                if j in keylist:
+                    temp = sum((v.subs(n, n - lower)
+                               for k, v in dict1.items() if k[0] == j),
+                               start=S.Zero)
+                    sol.append(temp)
+                else:
+                    sol.append(S.Zero)
+
+            # the recurrence relation
+            sol = RecurrenceOperator(sol, R)
+
+            # computing the initial conditions for recurrence
+            order = sol.order
+            all_roots = roots(R.base.to_sympy(sol.listofpoly[-1]), n, filter='Z')
+            all_roots = all_roots.keys()
+
+            if all_roots:
+                max_root = max(all_roots) + 1
+                smallest_n = max(max_root, smallest_n)
+            order += smallest_n
+
+            u0 = []
+
+            if self.is_singularics() == True:
+                u0 = self.y0[p]
+
+            elif self.is_singularics() == False and p >= 0 and int(p) == p and len(rootstoconsider) == 1:
+                y0 = _extend_y0(self, order + int(p))
+                # u(n) = y^n(0)/factorial(n)
+                if len(y0) > int(p):
+                    u0 = [y0[i] / factorial(i) for i in range(int(p), len(y0))]
+
+            if len(u0) < order:
+
+                for i in range(degree2, degree):
+                    eq = S.Zero
+
+                    for j in dict1:
+                        if i + j[0] < 0:
+                            dummys[i + j[0]] = S.Zero
+
+                        elif i + j[0] < len(u0):
+                            dummys[i + j[0]] = u0[i + j[0]]
+
+                        elif not i + j[0] in dummys:
+                            letter = chr(char) + '_%s' %(i + j[0])
+                            dummys[i + j[0]] = Symbol(letter)
+                            unknowns.append(dummys[i + j[0]])
+
+                        if j[1] <= i:
+                            eq += dict1[j].subs(n, i) * dummys[i + j[0]]
+
+                    eqs.append(eq)
+
+                # solve the system of equations formed
+                soleqs = solve(eqs, *unknowns)
+
+                if isinstance(soleqs, dict):
+
+                    for i in range(len(u0), order):
+
+                        if i not in dummys:
+                            letter = chr(char) + '_%s' %i
+                            dummys[i] = Symbol(letter)
+
+                        if dummys[i] in soleqs:
+                            u0.append(soleqs[dummys[i]])
+
+                        else:
+                            u0.append(dummys[i])
+
+                    if lb:
+                        finalsol.append((HolonomicSequence(sol, u0), p, smallest_n))
+                        continue
+                    else:
+                        finalsol.append((HolonomicSequence(sol, u0), p))
+                        continue
+
+                for i in range(len(u0), order):
+
+                    if i not in dummys:
+                        letter = chr(char) + '_%s' %i
+                        dummys[i] = Symbol(letter)
+
+                    s = False
+                    for j in soleqs:
+                        if dummys[i] in j:
+                            u0.append(j[dummys[i]])
+                            s = True
+                    if not s:
+                        u0.append(dummys[i])
+            if lb:
+                finalsol.append((HolonomicSequence(sol, u0), p, smallest_n))
+
+            else:
+                finalsol.append((HolonomicSequence(sol, u0), p))
+            char += 1
+        return finalsol
+
+    def series(self, n=6, coefficient=False, order=True, _recur=None):
+        r"""
+        Finds the power series expansion of given holonomic function about :math:`x_0`.
+
+        Explanation
+        ===========
+
+        A list of series might be returned if :math:`x_0` is a regular point with
+        multiple roots of the indicial equation.
+
+        Examples
+        ========
+
+        >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
+        >>> from sympy import QQ
+        >>> from sympy import symbols
+        >>> x = symbols('x')
+        >>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx')
+        >>> HolonomicFunction(Dx - 1, x, 0, [1]).series()  # e^x
+        1 + x + x**2/2 + x**3/6 + x**4/24 + x**5/120 + O(x**6)
+        >>> HolonomicFunction(Dx**2 + 1, x, 0, [0, 1]).series(n=8)  # sin(x)
+        x - x**3/6 + x**5/120 - x**7/5040 + O(x**8)
+
+        See Also
+        ========
+
+        HolonomicFunction.to_sequence
+        """
+
+        if _recur is None:
+            recurrence = self.to_sequence()
+        else:
+            recurrence = _recur
+
+        if isinstance(recurrence, tuple) and len(recurrence) == 2:
+            recurrence = recurrence[0]
+            constantpower = 0
+        elif isinstance(recurrence, tuple) and len(recurrence) == 3:
+            constantpower = recurrence[1]
+            recurrence = recurrence[0]
+
+        elif len(recurrence) == 1 and len(recurrence[0]) == 2:
+            recurrence = recurrence[0][0]
+            constantpower = 0
+        elif len(recurrence) == 1 and len(recurrence[0]) == 3:
+            constantpower = recurrence[0][1]
+            recurrence = recurrence[0][0]
+        else:
+            return [self.series(_recur=i) for i in recurrence]
+
+        n = n - int(constantpower)
+        l = len(recurrence.u0) - 1
+        k = recurrence.recurrence.order
+        x = self.x
+        x0 = self.x0
+        seq_dmp = recurrence.recurrence.listofpoly
+        R = recurrence.recurrence.parent.base
+        K = R.get_field()
+        seq = [K.new(j.to_list()) for j in seq_dmp]
+        sub = [-seq[i] / seq[k] for i in range(k)]
+        sol = list(recurrence.u0)
+
+        if l + 1 < n:
+            # use the initial conditions to find the next term
+            for i in range(l + 1 - k, n - k):
+                coeff = sum((DMFsubs(sub[j], i) * sol[i + j]
+                            for j in range(k) if i + j >= 0), start=S.Zero)
+                sol.append(coeff)
+
+        if coefficient:
+            return sol
+
+        ser = sum((x**(i + constantpower) * j for i, j in enumerate(sol)),
+                  start=S.Zero)
+        if order:
+            ser += Order(x**(n + int(constantpower)), x)
+        if x0 != 0:
+            return ser.subs(x, x - x0)
+        return ser
+
+    def _indicial(self):
+        """
+        Computes roots of the Indicial equation.
+        """
+
+        if self.x0 != 0:
+            return self.shift_x(self.x0)._indicial()
+
+        list_coeff = self.annihilator.listofpoly
+        R = self.annihilator.parent.base
+        x = self.x
+        s = R.zero
+        y = R.one
+
+        def _pole_degree(poly):
+            root_all = roots(R.to_sympy(poly), x, filter='Z')
+            if 0 in root_all.keys():
+                return root_all[0]
+            else:
+                return 0
+
+        degree = max(j.degree() for j in list_coeff)
+        inf = 10 * (max(1, degree) + max(1, self.annihilator.order))
+
+        deg = lambda q: inf if q.is_zero else _pole_degree(q)
+        b = min(deg(q) - j for j, q in enumerate(list_coeff))
+
+        for i, j in enumerate(list_coeff):
+            listofdmp = j.all_coeffs()
+            degree = len(listofdmp) - 1
+            if 0 <= i + b <= degree:
+                s = s + listofdmp[degree - i - b] * y
+            y *= R.from_sympy(x - i)
+
+        return roots(R.to_sympy(s), x)
+
+    def evalf(self, points, method='RK4', h=0.05, derivatives=False):
+        r"""
+        Finds numerical value of a holonomic function using numerical methods.
+        (RK4 by default). A set of points (real or complex) must be provided
+        which will be the path for the numerical integration.
+
+        Explanation
+        ===========
+
+        The path should be given as a list :math:`[x_1, x_2, \dots x_n]`. The numerical
+        values will be computed at each point in this order
+        :math:`x_1 \rightarrow x_2 \rightarrow x_3 \dots \rightarrow x_n`.
+
+        Returns values of the function at :math:`x_1, x_2, \dots x_n` in a list.
+
+        Examples
+        ========
+
+        >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
+        >>> from sympy import QQ
+        >>> from sympy import symbols
+        >>> x = symbols('x')
+        >>> R, Dx = DifferentialOperators(QQ.old_poly_ring(x),'Dx')
+
+        A straight line on the real axis from (0 to 1)
+
+        >>> r = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]
+
+        Runge-Kutta 4th order on e^x from 0.1 to 1.
+        Exact solution at 1 is 2.71828182845905
+
+        >>> HolonomicFunction(Dx - 1, x, 0, [1]).evalf(r)
+        [1.10517083333333, 1.22140257085069, 1.34985849706254, 1.49182424008069,
+        1.64872063859684, 1.82211796209193, 2.01375162659678, 2.22553956329232,
+        2.45960141378007, 2.71827974413517]
+
+        Euler's method for the same
+
+        >>> HolonomicFunction(Dx - 1, x, 0, [1]).evalf(r, method='Euler')
+        [1.1, 1.21, 1.331, 1.4641, 1.61051, 1.771561, 1.9487171, 2.14358881,
+        2.357947691, 2.5937424601]
+
+        One can also observe that the value obtained using Runge-Kutta 4th order
+        is much more accurate than Euler's method.
+        """
+
+        from sympy.holonomic.numerical import _evalf
+        lp = False
+
+        # if a point `b` is given instead of a mesh
+        if not hasattr(points, "__iter__"):
+            lp = True
+            b = S(points)
+            if self.x0 == b:
+                return _evalf(self, [b], method=method, derivatives=derivatives)[-1]
+
+            if not b.is_Number:
+                raise NotImplementedError
+
+            a = self.x0
+            if a > b:
+                h = -h
+            n = int((b - a) / h)
+            points = [a + h]
+            for i in range(n - 1):
+                points.append(points[-1] + h)
+
+        for i in roots(self.annihilator.parent.base.to_sympy(self.annihilator.listofpoly[-1]), self.x):
+            if i == self.x0 or i in points:
+                raise SingularityError(self, i)
+
+        if lp:
+            return _evalf(self, points, method=method, derivatives=derivatives)[-1]
+        return _evalf(self, points, method=method, derivatives=derivatives)
+
+    def change_x(self, z):
+        """
+        Changes only the variable of Holonomic Function, for internal
+        purposes. For composition use HolonomicFunction.composition()
+        """
+
+        dom = self.annihilator.parent.base.dom
+        R = dom.old_poly_ring(z)
+        parent, _ = DifferentialOperators(R, 'Dx')
+        sol = [R(j.to_list()) for j in self.annihilator.listofpoly]
+        sol =  DifferentialOperator(sol, parent)
+        return HolonomicFunction(sol, z, self.x0, self.y0)
+
+    def shift_x(self, a):
+        """
+        Substitute `x + a` for `x`.
+        """
+
+        x = self.x
+        listaftershift = self.annihilator.listofpoly
+        base = self.annihilator.parent.base
+
+        sol = [base.from_sympy(base.to_sympy(i).subs(x, x + a)) for i in listaftershift]
+        sol = DifferentialOperator(sol, self.annihilator.parent)
+        x0 = self.x0 - a
+        if not self._have_init_cond():
+            return HolonomicFunction(sol, x)
+        return HolonomicFunction(sol, x, x0, self.y0)
+
+    def to_hyper(self, as_list=False, _recur=None):
+        r"""
+        Returns a hypergeometric function (or linear combination of them)
+        representing the given holonomic function.
+
+        Explanation
+        ===========
+
+        Returns an answer of the form:
+        `a_1 \cdot x^{b_1} \cdot{hyper()} + a_2 \cdot x^{b_2} \cdot{hyper()} \dots`
+
+        This is very useful as one can now use ``hyperexpand`` to find the
+        symbolic expressions/functions.
+
+        Examples
+        ========
+
+        >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
+        >>> from sympy import ZZ
+        >>> from sympy import symbols
+        >>> x = symbols('x')
+        >>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x),'Dx')
+        >>> # sin(x)
+        >>> HolonomicFunction(Dx**2 + 1, x, 0, [0, 1]).to_hyper()
+        x*hyper((), (3/2,), -x**2/4)
+        >>> # exp(x)
+        >>> HolonomicFunction(Dx - 1, x, 0, [1]).to_hyper()
+        hyper((), (), x)
+
+        See Also
+        ========
+
+        from_hyper, from_meijerg
+        """
+
+        if _recur is None:
+            recurrence = self.to_sequence()
+        else:
+            recurrence = _recur
+
+        if isinstance(recurrence, tuple) and len(recurrence) == 2:
+            smallest_n = recurrence[1]
+            recurrence = recurrence[0]
+            constantpower = 0
+        elif isinstance(recurrence, tuple) and len(recurrence) == 3:
+            smallest_n = recurrence[2]
+            constantpower = recurrence[1]
+            recurrence = recurrence[0]
+        elif len(recurrence) == 1 and len(recurrence[0]) == 2:
+            smallest_n = recurrence[0][1]
+            recurrence = recurrence[0][0]
+            constantpower = 0
+        elif len(recurrence) == 1 and len(recurrence[0]) == 3:
+            smallest_n = recurrence[0][2]
+            constantpower = recurrence[0][1]
+            recurrence = recurrence[0][0]
+        else:
+            sol = self.to_hyper(as_list=as_list, _recur=recurrence[0])
+            for i in recurrence[1:]:
+                sol += self.to_hyper(as_list=as_list, _recur=i)
+            return sol
+
+        u0 = recurrence.u0
+        r = recurrence.recurrence
+        x = self.x
+        x0 = self.x0
+
+        # order of the recurrence relation
+        m = r.order
+
+        # when no recurrence exists, and the power series have finite terms
+        if m == 0:
+            nonzeroterms = roots(r.parent.base.to_sympy(r.listofpoly[0]), recurrence.n, filter='R')
+
+            sol = S.Zero
+            for j, i in enumerate(nonzeroterms):
+
+                if i < 0 or not int_valued(i):
+                    continue
+
+                i = int(i)
+                if i < len(u0):
+                    if isinstance(u0[i], (PolyElement, FracElement)):
+                        u0[i] = u0[i].as_expr()
+                    sol += u0[i] * x**i
+
+                else:
+                    sol += Symbol('C_%s' %j) * x**i
+
+            if isinstance(sol, (PolyElement, FracElement)):
+                sol = sol.as_expr() * x**constantpower
+            else:
+                sol = sol * x**constantpower
+            if as_list:
+                if x0 != 0:
+                    return [(sol.subs(x, x - x0), )]
+                return [(sol, )]
+            if x0 != 0:
+                return sol.subs(x, x - x0)
+            return sol
+
+        if smallest_n + m > len(u0):
+            raise NotImplementedError("Can't compute sufficient Initial Conditions")
+
+        # check if the recurrence represents a hypergeometric series
+        if any(i != r.parent.base.zero for i in r.listofpoly[1:-1]):
+            raise NotHyperSeriesError(self, self.x0)
+
+        a = r.listofpoly[0]
+        b = r.listofpoly[-1]
+
+        # the constant multiple of argument of hypergeometric function
+        if isinstance(a.LC(), (PolyElement, FracElement)):
+            c = - (S(a.LC().as_expr()) * m**(a.degree())) / (S(b.LC().as_expr()) * m**(b.degree()))
+        else:
+            c = - (S(a.LC()) * m**(a.degree())) / (S(b.LC()) * m**(b.degree()))
+
+        sol = 0
+
+        arg1 = roots(r.parent.base.to_sympy(a), recurrence.n)
+        arg2 = roots(r.parent.base.to_sympy(b), recurrence.n)
+
+        # iterate through the initial conditions to find
+        # the hypergeometric representation of the given
+        # function.
+        # The answer will be a linear combination
+        # of different hypergeometric series which satisfies
+        # the recurrence.
+        if as_list:
+            listofsol = []
+        for i in range(smallest_n + m):
+
+            # if the recurrence relation doesn't hold for `n = i`,
+            # then a Hypergeometric representation doesn't exist.
+            # add the algebraic term a * x**i to the solution,
+            # where a is u0[i]
+            if i < smallest_n:
+                if as_list:
+                    listofsol.append(((S(u0[i]) * x**(i+constantpower)).subs(x, x-x0), ))
+                else:
+                    sol += S(u0[i]) * x**i
+                continue
+
+            # if the coefficient u0[i] is zero, then the
+            # independent hypergeomtric series starting with
+            # x**i is not a part of the answer.
+            if S(u0[i]) == 0:
+                continue
+
+            ap = []
+            bq = []
+
+            # substitute m * n + i for n
+            for k in ordered(arg1.keys()):
+                ap.extend([nsimplify((i - k) / m)] * arg1[k])
+
+            for k in ordered(arg2.keys()):
+                bq.extend([nsimplify((i - k) / m)] * arg2[k])
+
+            # convention of (k + 1) in the denominator
+            if 1 in bq:
+                bq.remove(1)
+            else:
+                ap.append(1)
+            if as_list:
+                listofsol.append(((S(u0[i])*x**(i+constantpower)).subs(x, x-x0), (hyper(ap, bq, c*x**m)).subs(x, x-x0)))
+            else:
+                sol += S(u0[i]) * hyper(ap, bq, c * x**m) * x**i
+        if as_list:
+            return listofsol
+        sol = sol * x**constantpower
+        if x0 != 0:
+            return sol.subs(x, x - x0)
+
+        return sol
+
+    def to_expr(self):
+        """
+        Converts a Holonomic Function back to elementary functions.
+
+        Examples
+        ========
+
+        >>> from sympy.holonomic.holonomic import HolonomicFunction, DifferentialOperators
+        >>> from sympy import ZZ
+        >>> from sympy import symbols, S
+        >>> x = symbols('x')
+        >>> R, Dx = DifferentialOperators(ZZ.old_poly_ring(x),'Dx')
+        >>> HolonomicFunction(x**2*Dx**2 + x*Dx + (x**2 - 1), x, 0, [0, S(1)/2]).to_expr()
+        besselj(1, x)
+        >>> HolonomicFunction((1 + x)*Dx**3 + Dx**2, x, 0, [1, 1, 1]).to_expr()
+        x*log(x + 1) + log(x + 1) + 1
+
+        """
+
+        return hyperexpand(self.to_hyper()).simplify()
+
+    def change_ics(self, b, lenics=None):
+        """
+        Changes the point `x0` to ``b`` for initial conditions.
+
+        Examples
+        ========
+
+        >>> from sympy.holonomic import expr_to_holonomic
+        >>> from sympy import symbols, sin, exp
+        >>> x = symbols('x')
+
+        >>> expr_to_holonomic(sin(x)).change_ics(1)
+        HolonomicFunction((1) + (1)*Dx**2, x, 1, [sin(1), cos(1)])
+
+        >>> expr_to_holonomic(exp(x)).change_ics(2)
+        HolonomicFunction((-1) + (1)*Dx, x, 2, [exp(2)])
+        """
+
+        symbolic = True
+
+        if lenics is None and len(self.y0) > self.annihilator.order:
+            lenics = len(self.y0)
+        dom = self.annihilator.parent.base.domain
+
+        try:
+            sol = expr_to_holonomic(self.to_expr(), x=self.x, x0=b, lenics=lenics, domain=dom)
+        except (NotPowerSeriesError, NotHyperSeriesError):
+            symbolic = False
+
+        if symbolic and sol.x0 == b:
+            return sol
+
+        y0 = self.evalf(b, derivatives=True)
+        return HolonomicFunction(self.annihilator, self.x, b, y0)
+
+    def to_meijerg(self):
+        """
+        Returns a linear combination of Meijer G-functions.
+
+        Examples
+        ========
+
+        >>> from sympy.holonomic import expr_to_holonomic
+        >>> from sympy import sin, cos, hyperexpand, log, symbols
+        >>> x = symbols('x')
+        >>> hyperexpand(expr_to_holonomic(cos(x) + sin(x)).to_meijerg())
+        sin(x) + cos(x)
+        >>> hyperexpand(expr_to_holonomic(log(x)).to_meijerg()).simplify()
+        log(x)
+
+        See Also
+        ========
+
+        to_hyper
+        """
+
+        # convert to hypergeometric first
+        rep = self.to_hyper(as_list=True)
+        sol = S.Zero
+
+        for i in rep:
+            if len(i) == 1:
+                sol += i[0]
+
+            elif len(i) == 2:
+                sol += i[0] * _hyper_to_meijerg(i[1])
+
+        return sol
+
+
+def from_hyper(func, x0=0, evalf=False):
+    r"""
+    Converts a hypergeometric function to holonomic.
+    ``func`` is the Hypergeometric Function and ``x0`` is the point at
+    which initial conditions are required.
+
+    Examples
+    ========
+
+    >>> from sympy.holonomic.holonomic import from_hyper
+    >>> from sympy import symbols, hyper, S
+    >>> x = symbols('x')
+    >>> from_hyper(hyper([], [S(3)/2], x**2/4))
+    HolonomicFunction((-x) + (2)*Dx + (x)*Dx**2, x, 1, [sinh(1), -sinh(1) + cosh(1)])
+    """
+
+    a = func.ap
+    b = func.bq
+    z = func.args[2]
+    x = z.atoms(Symbol).pop()
+    R, Dx = DifferentialOperators(QQ.old_poly_ring(x), 'Dx')
+
+    # generalized hypergeometric differential equation
+    xDx = x*Dx
+    r1 = 1
+    for ai in a:  # XXX gives sympify error if Mul is used with list of all factors
+        r1 *= xDx + ai
+    xDx_1 = xDx - 1
+    # r2 = Mul(*([Dx] + [xDx_1 + bi for bi in b]))  # XXX gives sympify error
+    r2 = Dx
+    for bi in b:
+        r2 *= xDx_1 + bi
+    sol = r1 - r2
+
+    simp = hyperexpand(func)
+
+    if simp in (Infinity, NegativeInfinity):
+        return HolonomicFunction(sol, x).composition(z)
+
+    def _find_conditions(simp, x, x0, order, evalf=False):
+        y0 = []
+        for i in range(order):
+            if evalf:
+                val = simp.subs(x, x0).evalf()
+            else:
+                val = simp.subs(x, x0)
+            # return None if it is Infinite or NaN
+            if val.is_finite is False or isinstance(val, NaN):
+                return None
+            y0.append(val)
+            simp = simp.diff(x)
+        return y0
+
+    # if the function is known symbolically
+    if not isinstance(simp, hyper):
+        y0 = _find_conditions(simp, x, x0, sol.order)
+        while not y0:
+            # if values don't exist at 0, then try to find initial
+            # conditions at 1. If it doesn't exist at 1 too then
+            # try 2 and so on.
+            x0 += 1
+            y0 = _find_conditions(simp, x, x0, sol.order)
+
+        return HolonomicFunction(sol, x).composition(z, x0, y0)
+
+    if isinstance(simp, hyper):
+        x0 = 1
+        # use evalf if the function can't be simplified
+        y0 = _find_conditions(simp, x, x0, sol.order, evalf)
+        while not y0:
+            x0 += 1
+            y0 = _find_conditions(simp, x, x0, sol.order, evalf)
+        return HolonomicFunction(sol, x).composition(z, x0, y0)
+
+    return HolonomicFunction(sol, x).composition(z)
+
+
+def from_meijerg(func, x0=0, evalf=False, initcond=True, domain=QQ):
+    """
+    Converts a Meijer G-function to Holonomic.
+    ``func`` is the G-Function and ``x0`` is the point at
+    which initial conditions are required.
+
+    Examples
+    ========
+
+    >>> from sympy.holonomic.holonomic import from_meijerg
+    >>> from sympy import symbols, meijerg, S
+    >>> x = symbols('x')
+    >>> from_meijerg(meijerg(([], []), ([S(1)/2], [0]), x**2/4))
+    HolonomicFunction((1) + (1)*Dx**2, x, 0, [0, 1/sqrt(pi)])
+    """
+
+    a = func.ap
+    b = func.bq
+    n = len(func.an)
+    m = len(func.bm)
+    p = len(a)
+    z = func.args[2]
+    x = z.atoms(Symbol).pop()
+    R, Dx = DifferentialOperators(domain.old_poly_ring(x), 'Dx')
+
+    # compute the differential equation satisfied by the
+    # Meijer G-function.
+    xDx = x*Dx
+    xDx1 = xDx + 1
+    r1 = x*(-1)**(m + n - p)
+    for ai in a:  # XXX gives sympify error if args given in list
+        r1 *= xDx1 - ai
+    # r2 = Mul(*[xDx - bi for bi in b])  # gives sympify error
+    r2 = 1
+    for bi in b:
+        r2 *= xDx - bi
+    sol = r1 - r2
+
+    if not initcond:
+        return HolonomicFunction(sol, x).composition(z)
+
+    simp = hyperexpand(func)
+
+    if simp in (Infinity, NegativeInfinity):
+        return HolonomicFunction(sol, x).composition(z)
+
+    def _find_conditions(simp, x, x0, order, evalf=False):
+        y0 = []
+        for i in range(order):
+            if evalf:
+                val = simp.subs(x, x0).evalf()
+            else:
+                val = simp.subs(x, x0)
+            if val.is_finite is False or isinstance(val, NaN):
+                return None
+            y0.append(val)
+            simp = simp.diff(x)
+        return y0
+
+    # computing initial conditions
+    if not isinstance(simp, meijerg):
+        y0 = _find_conditions(simp, x, x0, sol.order)
+        while not y0:
+            x0 += 1
+            y0 = _find_conditions(simp, x, x0, sol.order)
+
+        return HolonomicFunction(sol, x).composition(z, x0, y0)
+
+    if isinstance(simp, meijerg):
+        x0 = 1
+        y0 = _find_conditions(simp, x, x0, sol.order, evalf)
+        while not y0:
+            x0 += 1
+            y0 = _find_conditions(simp, x, x0, sol.order, evalf)
+
+        return HolonomicFunction(sol, x).composition(z, x0, y0)
+
+    return HolonomicFunction(sol, x).composition(z)
+
+
+x_1 = Dummy('x_1')
+_lookup_table = None
+domain_for_table = None
+from sympy.integrals.meijerint import _mytype
+
+
+def expr_to_holonomic(func, x=None, x0=0, y0=None, lenics=None, domain=None, initcond=True):
+    """
+    Converts a function or an expression to a holonomic function.
+
+    Parameters
+    ==========
+
+    func:
+        The expression to be converted.
+    x:
+        variable for the function.
+    x0:
+        point at which initial condition must be computed.
+    y0:
+        One can optionally provide initial condition if the method
+        is not able to do it automatically.
+    lenics:
+        Number of terms in the initial condition. By default it is
+        equal to the order of the annihilator.
+    domain:
+        Ground domain for the polynomials in ``x`` appearing as coefficients
+        in the annihilator.
+    initcond:
+        Set it false if you do not want the initial conditions to be computed.
+
+    Examples
+    ========
+
+    >>> from sympy.holonomic.holonomic import expr_to_holonomic
+    >>> from sympy import sin, exp, symbols
+    >>> x = symbols('x')
+    >>> expr_to_holonomic(sin(x))
+    HolonomicFunction((1) + (1)*Dx**2, x, 0, [0, 1])
+    >>> expr_to_holonomic(exp(x))
+    HolonomicFunction((-1) + (1)*Dx, x, 0, [1])
+
+    See Also
+    ========
+
+    sympy.integrals.meijerint._rewrite1, _convert_poly_rat_alg, _create_table
+    """
+    func = sympify(func)
+    syms = func.free_symbols
+
+    if not x:
+        if len(syms) == 1:
+            x= syms.pop()
+        else:
+            raise ValueError("Specify the variable for the function")
+    elif x in syms:
+        syms.remove(x)
+
+    extra_syms = list(syms)
+
+    if domain is None:
+        if func.has(Float):
+            domain = RR
+        else:
+            domain = QQ
+        if len(extra_syms) != 0:
+            domain = domain[extra_syms].get_field()
+
+    # try to convert if the function is polynomial or rational
+    solpoly = _convert_poly_rat_alg(func, x, x0=x0, y0=y0, lenics=lenics, domain=domain, initcond=initcond)
+    if solpoly:
+        return solpoly
+
+    # create the lookup table
+    global _lookup_table, domain_for_table
+    if not _lookup_table:
+        domain_for_table = domain
+        _lookup_table = {}
+        _create_table(_lookup_table, domain=domain)
+    elif domain != domain_for_table:
+        domain_for_table = domain
+        _lookup_table = {}
+        _create_table(_lookup_table, domain=domain)
+
+    # use the table directly to convert to Holonomic
+    if func.is_Function:
+        f = func.subs(x, x_1)
+        t = _mytype(f, x_1)
+        if t in _lookup_table:
+            l = _lookup_table[t]
+            sol = l[0][1].change_x(x)
+        else:
+            sol = _convert_meijerint(func, x, initcond=False, domain=domain)
+            if not sol:
+                raise NotImplementedError
+            if y0:
+                sol.y0 = y0
+            if y0 or not initcond:
+                sol.x0 = x0
+                return sol
+            if not lenics:
+                lenics = sol.annihilator.order
+            _y0 = _find_conditions(func, x, x0, lenics)
+            while not _y0:
+                x0 += 1
+                _y0 = _find_conditions(func, x, x0, lenics)
+            return HolonomicFunction(sol.annihilator, x, x0, _y0)
+
+        if y0 or not initcond:
+            sol = sol.composition(func.args[0])
+            if y0:
+                sol.y0 = y0
+            sol.x0 = x0
+            return sol
+        if not lenics:
+            lenics = sol.annihilator.order
+
+        _y0 = _find_conditions(func, x, x0, lenics)
+        while not _y0:
+            x0 += 1
+            _y0 = _find_conditions(func, x, x0, lenics)
+        return sol.composition(func.args[0], x0, _y0)
+
+    # iterate through the expression recursively
+    args = func.args
+    f = func.func
+    sol = expr_to_holonomic(args[0], x=x, initcond=False, domain=domain)
+
+    if f is Add:
+        for i in range(1, len(args)):
+            sol += expr_to_holonomic(args[i], x=x, initcond=False, domain=domain)
+
+    elif f is Mul:
+        for i in range(1, len(args)):
+            sol *= expr_to_holonomic(args[i], x=x, initcond=False, domain=domain)
+
+    elif f is Pow:
+        sol = sol**args[1]
+    sol.x0 = x0
+    if not sol:
+        raise NotImplementedError
+    if y0:
+        sol.y0 = y0
+    if y0 or not initcond:
+        return sol
+    if sol.y0:
+        return sol
+    if not lenics:
+        lenics = sol.annihilator.order
+    if sol.annihilator.is_singular(x0):
+        r = sol._indicial()
+        l = list(r)
+        if len(r) == 1 and r[l[0]] == S.One:
+            r = l[0]
+            g = func / (x - x0)**r
+            singular_ics = _find_conditions(g, x, x0, lenics)
+            singular_ics = [j / factorial(i) for i, j in enumerate(singular_ics)]
+            y0 = {r:singular_ics}
+            return HolonomicFunction(sol.annihilator, x, x0, y0)
+
+    _y0 = _find_conditions(func, x, x0, lenics)
+    while not _y0:
+        x0 += 1
+        _y0 = _find_conditions(func, x, x0, lenics)
+
+    return HolonomicFunction(sol.annihilator, x, x0, _y0)
+
+
+## Some helper functions ##
+
+def _normalize(list_of, parent, negative=True):
+    """
+    Normalize a given annihilator
+    """
+
+    num = []
+    denom = []
+    base = parent.base
+    K = base.get_field()
+    lcm_denom = base.from_sympy(S.One)
+    list_of_coeff = []
+
+    # convert polynomials to the elements of associated
+    # fraction field
+    for i, j in enumerate(list_of):
+        if isinstance(j, base.dtype):
+            list_of_coeff.append(K.new(j.to_list()))
+        elif not isinstance(j, K.dtype):
+            list_of_coeff.append(K.from_sympy(sympify(j)))
+        else:
+            list_of_coeff.append(j)
+
+        # corresponding numerators of the sequence of polynomials
+        num.append(list_of_coeff[i].numer())
+
+        # corresponding denominators
+        denom.append(list_of_coeff[i].denom())
+
+    # lcm of denominators in the coefficients
+    for i in denom:
+        lcm_denom = i.lcm(lcm_denom)
+
+    if negative:
+        lcm_denom = -lcm_denom
+
+    lcm_denom = K.new(lcm_denom.to_list())
+
+    # multiply the coefficients with lcm
+    for i, j in enumerate(list_of_coeff):
+        list_of_coeff[i] = j * lcm_denom
+
+    gcd_numer = base((list_of_coeff[-1].numer() / list_of_coeff[-1].denom()).to_list())
+
+    # gcd of numerators in the coefficients
+    for i in num:
+        gcd_numer = i.gcd(gcd_numer)
+
+    gcd_numer = K.new(gcd_numer.to_list())
+
+    # divide all the coefficients by the gcd
+    for i, j in enumerate(list_of_coeff):
+        frac_ans = j / gcd_numer
+        list_of_coeff[i] = base((frac_ans.numer() / frac_ans.denom()).to_list())
+
+    return DifferentialOperator(list_of_coeff, parent)
+
+
+def _derivate_diff_eq(listofpoly, K):
+    """
+    Let a differential equation a0(x)y(x) + a1(x)y'(x) + ... = 0
+    where a0, a1,... are polynomials or rational functions. The function
+    returns b0, b1, b2... such that the differential equation
+    b0(x)y(x) + b1(x)y'(x) +... = 0 is formed after differentiating the
+    former equation.
+    """
+
+    sol = []
+    a = len(listofpoly) - 1
+    sol.append(DMFdiff(listofpoly[0], K))
+
+    for i, j in enumerate(listofpoly[1:]):
+        sol.append(DMFdiff(j, K) + listofpoly[i])
+
+    sol.append(listofpoly[a])
+    return sol
+
+
+def _hyper_to_meijerg(func):
+    """
+    Converts a `hyper` to meijerg.
+    """
+    ap = func.ap
+    bq = func.bq
+
+    if any(i <= 0 and int(i) == i for i in ap):
+        return hyperexpand(func)
+
+    z = func.args[2]
+
+    # parameters of the `meijerg` function.
+    an = (1 - i for i in ap)
+    anp = ()
+    bm = (S.Zero, )
+    bmq = (1 - i for i in bq)
+
+    k = S.One
+
+    for i in bq:
+        k = k * gamma(i)
+
+    for i in ap:
+        k = k / gamma(i)
+
+    return k * meijerg(an, anp, bm, bmq, -z)
+
+
+def _add_lists(list1, list2):
+    """Takes polynomial sequences of two annihilators a and b and returns
+    the list of polynomials of sum of a and b.
+    """
+    if len(list1) <= len(list2):
+        sol = [a + b for a, b in zip(list1, list2)] + list2[len(list1):]
+    else:
+        sol = [a + b for a, b in zip(list1, list2)] + list1[len(list2):]
+    return sol
+
+
+def _extend_y0(Holonomic, n):
+    """
+    Tries to find more initial conditions by substituting the initial
+    value point in the differential equation.
+    """
+
+    if Holonomic.annihilator.is_singular(Holonomic.x0) or Holonomic.is_singularics() == True:
+        return Holonomic.y0
+
+    annihilator = Holonomic.annihilator
+    a = annihilator.order
+
+    listofpoly = []
+
+    y0 = Holonomic.y0
+    R = annihilator.parent.base
+    K = R.get_field()
+
+    for j in annihilator.listofpoly:
+        if isinstance(j, annihilator.parent.base.dtype):
+            listofpoly.append(K.new(j.to_list()))
+
+    if len(y0) < a or n <= len(y0):
+        return y0
+    list_red = [-listofpoly[i] / listofpoly[a]
+                for i in range(a)]
+    y1 = y0[:min(len(y0), a)]
+    for _ in range(n - a):
+        sol = 0
+        for a, b in zip(y1, list_red):
+            r = DMFsubs(b, Holonomic.x0)
+            if not getattr(r, 'is_finite', True):
+                return y0
+            if isinstance(r, (PolyElement, FracElement)):
+                r = r.as_expr()
+            sol += a * r
+        y1.append(sol)
+        list_red = _derivate_diff_eq(list_red, K)
+    return y0 + y1[len(y0):]
+
+
+def DMFdiff(frac, K):
+    # differentiate a DMF object represented as p/q
+    if not isinstance(frac, DMF):
+        return frac.diff()
+
+    p = K.numer(frac)
+    q = K.denom(frac)
+    sol_num = - p * q.diff() + q * p.diff()
+    sol_denom = q**2
+    return K((sol_num.to_list(), sol_denom.to_list()))
+
+
+def DMFsubs(frac, x0, mpm=False):
+    # substitute the point x0 in DMF object of the form p/q
+    if not isinstance(frac, DMF):
+        return frac
+
+    p = frac.num
+    q = frac.den
+    sol_p = S.Zero
+    sol_q = S.Zero
+
+    if mpm:
+        from mpmath import mp
+
+    for i, j in enumerate(reversed(p)):
+        if mpm:
+            j = sympify(j)._to_mpmath(mp.prec)
+        sol_p += j * x0**i
+
+    for i, j in enumerate(reversed(q)):
+        if mpm:
+            j = sympify(j)._to_mpmath(mp.prec)
+        sol_q += j * x0**i
+
+    if isinstance(sol_p, (PolyElement, FracElement)):
+        sol_p = sol_p.as_expr()
+    if isinstance(sol_q, (PolyElement, FracElement)):
+        sol_q = sol_q.as_expr()
+
+    return sol_p / sol_q
+
+
+def _convert_poly_rat_alg(func, x, x0=0, y0=None, lenics=None, domain=QQ, initcond=True):
+    """
+    Converts polynomials, rationals and algebraic functions to holonomic.
+    """
+
+    ispoly = func.is_polynomial()
+    if not ispoly:
+        israt = func.is_rational_function()
+    else:
+        israt = True
+
+    if not (ispoly or israt):
+        basepoly, ratexp = func.as_base_exp()
+        if basepoly.is_polynomial() and ratexp.is_Number:
+            if isinstance(ratexp, Float):
+                ratexp = nsimplify(ratexp)
+            m, n = ratexp.p, ratexp.q
+            is_alg = True
+        else:
+            is_alg = False
+    else:
+        is_alg = True
+
+    if not (ispoly or israt or is_alg):
+        return None
+
+    R = domain.old_poly_ring(x)
+    _, Dx = DifferentialOperators(R, 'Dx')
+
+    # if the function is constant
+    if not func.has(x):
+        return HolonomicFunction(Dx, x, 0, [func])
+
+    if ispoly:
+        # differential equation satisfied by polynomial
+        sol = func * Dx - func.diff(x)
+        sol = _normalize(sol.listofpoly, sol.parent, negative=False)
+        is_singular = sol.is_singular(x0)
+
+        # try to compute the conditions for singular points
+        if y0 is None and x0 == 0 and is_singular:
+            rep = R.from_sympy(func).to_list()
+            for i, j in enumerate(reversed(rep)):
+                if j == 0:
+                    continue
+                coeff = list(reversed(rep))[i:]
+                indicial = i
+                break
+            for i, j in enumerate(coeff):
+                if isinstance(j, (PolyElement, FracElement)):
+                    coeff[i] = j.as_expr()
+            y0 = {indicial: S(coeff)}
+
+    elif israt:
+        p, q = func.as_numer_denom()
+        # differential equation satisfied by rational
+        sol = p * q * Dx + p * q.diff(x) - q * p.diff(x)
+        sol = _normalize(sol.listofpoly, sol.parent, negative=False)
+
+    elif is_alg:
+        sol = n * (x / m) * Dx - 1
+        sol = HolonomicFunction(sol, x).composition(basepoly).annihilator
+        is_singular = sol.is_singular(x0)
+
+        # try to compute the conditions for singular points
+        if y0 is None and x0 == 0 and is_singular and \
+            (lenics is None or lenics <= 1):
+            rep = R.from_sympy(basepoly).to_list()
+            for i, j in enumerate(reversed(rep)):
+                if j == 0:
+                    continue
+                if isinstance(j, (PolyElement, FracElement)):
+                    j = j.as_expr()
+
+                coeff = S(j)**ratexp
+                indicial = S(i) * ratexp
+                break
+            if isinstance(coeff, (PolyElement, FracElement)):
+                coeff = coeff.as_expr()
+            y0 = {indicial: S([coeff])}
+
+    if y0 or not initcond:
+        return HolonomicFunction(sol, x, x0, y0)
+
+    if not lenics:
+        lenics = sol.order
+
+    if sol.is_singular(x0):
+        r = HolonomicFunction(sol, x, x0)._indicial()
+        l = list(r)
+        if len(r) == 1 and r[l[0]] == S.One:
+            r = l[0]
+            g = func / (x - x0)**r
+            singular_ics = _find_conditions(g, x, x0, lenics)
+            singular_ics = [j / factorial(i) for i, j in enumerate(singular_ics)]
+            y0 = {r:singular_ics}
+            return HolonomicFunction(sol, x, x0, y0)
+
+    y0 = _find_conditions(func, x, x0, lenics)
+    while not y0:
+        x0 += 1
+        y0 = _find_conditions(func, x, x0, lenics)
+
+    return HolonomicFunction(sol, x, x0, y0)
+
+
+def _convert_meijerint(func, x, initcond=True, domain=QQ):
+    args = meijerint._rewrite1(func, x)
+
+    if args:
+        fac, po, g, _ = args
+    else:
+        return None
+
+    # lists for sum of meijerg functions
+    fac_list = [fac * i[0] for i in g]
+    t = po.as_base_exp()
+    s = t[1] if t[0] == x else S.Zero
+    po_list = [s + i[1] for i in g]
+    G_list = [i[2] for i in g]
+
+    # finds meijerg representation of x**s * meijerg(a1 ... ap, b1 ... bq, z)
+    def _shift(func, s):
+        z = func.args[-1]
+        if z.has(I):
+            z = z.subs(exp_polar, exp)
+
+        d = z.collect(x, evaluate=False)
+        b = list(d)[0]
+        a = d[b]
+
+        t = b.as_base_exp()
+        b = t[1] if t[0] == x else S.Zero
+        r = s / b
+        an = (i + r for i in func.args[0][0])
+        ap = (i + r for i in func.args[0][1])
+        bm = (i + r for i in func.args[1][0])
+        bq = (i + r for i in func.args[1][1])
+
+        return a**-r, meijerg((an, ap), (bm, bq), z)
+
+    coeff, m = _shift(G_list[0], po_list[0])
+    sol = fac_list[0] * coeff * from_meijerg(m, initcond=initcond, domain=domain)
+
+    # add all the meijerg functions after converting to holonomic
+    for i in range(1, len(G_list)):
+        coeff, m = _shift(G_list[i], po_list[i])
+        sol += fac_list[i] * coeff * from_meijerg(m, initcond=initcond, domain=domain)
+
+    return sol
+
+
+def _create_table(table, domain=QQ):
+    """
+    Creates the look-up table. For a similar implementation
+    see meijerint._create_lookup_table.
+    """
+
+    def add(formula, annihilator, arg, x0=0, y0=()):
+        """
+        Adds a formula in the dictionary
+        """
+        table.setdefault(_mytype(formula, x_1), []).append((formula,
+            HolonomicFunction(annihilator, arg, x0, y0)))
+
+    R = domain.old_poly_ring(x_1)
+    _, Dx = DifferentialOperators(R, 'Dx')
+
+    # add some basic functions
+    add(sin(x_1), Dx**2 + 1, x_1, 0, [0, 1])
+    add(cos(x_1), Dx**2 + 1, x_1, 0, [1, 0])
+    add(exp(x_1), Dx - 1, x_1, 0, 1)
+    add(log(x_1), Dx + x_1*Dx**2, x_1, 1, [0, 1])
+
+    add(erf(x_1), 2*x_1*Dx + Dx**2, x_1, 0, [0, 2/sqrt(pi)])
+    add(erfc(x_1), 2*x_1*Dx + Dx**2, x_1, 0, [1, -2/sqrt(pi)])
+    add(erfi(x_1), -2*x_1*Dx + Dx**2, x_1, 0, [0, 2/sqrt(pi)])
+
+    add(sinh(x_1), Dx**2 - 1, x_1, 0, [0, 1])
+    add(cosh(x_1), Dx**2 - 1, x_1, 0, [1, 0])
+
+    add(sinc(x_1), x_1 + 2*Dx + x_1*Dx**2, x_1)
+
+    add(Si(x_1), x_1*Dx + 2*Dx**2 + x_1*Dx**3, x_1)
+    add(Ci(x_1), x_1*Dx + 2*Dx**2 + x_1*Dx**3, x_1)
+
+    add(Shi(x_1), -x_1*Dx + 2*Dx**2 + x_1*Dx**3, x_1)
+
+
+def _find_conditions(func, x, x0, order):
+    y0 = []
+    for i in range(order):
+        val = func.subs(x, x0)
+        if isinstance(val, NaN):
+            val = limit(func, x, x0)
+        if val.is_finite is False or isinstance(val, NaN):
+            return None
+        y0.append(val)
+        func = func.diff(x)
+    return y0

parrot/lib/python3.10/site-packages/sympy/holonomic/holonomicerrors.py

@@ -0,0 +1,49 @@
+""" Common Exceptions for `holonomic` module. """
+
+class BaseHolonomicError(Exception):
+
+    def new(self, *args):
+        raise NotImplementedError("abstract base class")
+
+class NotPowerSeriesError(BaseHolonomicError):
+
+    def __init__(self, holonomic, x0):
+        self.holonomic = holonomic
+        self.x0 = x0
+
+    def __str__(self):
+        s = 'A Power Series does not exists for '
+        s += str(self.holonomic)
+        s += ' about %s.' %self.x0
+        return s
+
+class NotHolonomicError(BaseHolonomicError):
+
+    def __init__(self, m):
+        self.m = m
+
+    def __str__(self):
+        return self.m
+
+class SingularityError(BaseHolonomicError):
+
+    def __init__(self, holonomic, x0):
+        self.holonomic = holonomic
+        self.x0 = x0
+
+    def __str__(self):
+        s = str(self.holonomic)
+        s += ' has a singularity at %s.' %self.x0
+        return s
+
+class NotHyperSeriesError(BaseHolonomicError):
+
+    def __init__(self, holonomic, x0):
+        self.holonomic = holonomic
+        self.x0 = x0
+
+    def __str__(self):
+        s = 'Power series expansion of '
+        s += str(self.holonomic)
+        s += ' about %s is not hypergeometric' %self.x0
+        return s

parrot/lib/python3.10/site-packages/sympy/holonomic/numerical.py

@@ -0,0 +1,109 @@
+"""Numerical Methods for Holonomic Functions"""
+
+from sympy.core.sympify import sympify
+from sympy.holonomic.holonomic import DMFsubs
+
+from mpmath import mp
+
+
+def _evalf(func, points, derivatives=False, method='RK4'):
+    """
+    Numerical methods for numerical integration along a given set of
+    points in the complex plane.
+    """
+
+    ann = func.annihilator
+    a = ann.order
+    R = ann.parent.base
+    K = R.get_field()
+
+    if method == 'Euler':
+        meth = _euler
+    else:
+        meth = _rk4
+
+    dmf = []
+    for j in ann.listofpoly:
+        dmf.append(K.new(j.to_list()))
+
+    red = [-dmf[i] / dmf[a] for i in range(a)]
+
+    y0 = func.y0
+    if len(y0) < a:
+        raise TypeError("Not Enough Initial Conditions")
+    x0 = func.x0
+    sol = [meth(red, x0, points[0], y0, a)]
+
+    for i, j in enumerate(points[1:]):
+        sol.append(meth(red, points[i], j, sol[-1], a))
+
+    if not derivatives:
+        return [sympify(i[0]) for i in sol]
+    else:
+        return sympify(sol)
+
+
+def _euler(red, x0, x1, y0, a):
+    """
+    Euler's method for numerical integration.
+    From x0 to x1 with initial values given at x0 as vector y0.
+    """
+
+    A = sympify(x0)._to_mpmath(mp.prec)
+    B = sympify(x1)._to_mpmath(mp.prec)
+    y_0 = [sympify(i)._to_mpmath(mp.prec) for i in y0]
+    h = B - A
+    f_0 = y_0[1:]
+    f_0_n = 0
+
+    for i in range(a):
+        f_0_n += sympify(DMFsubs(red[i], A, mpm=True))._to_mpmath(mp.prec) * y_0[i]
+    f_0.append(f_0_n)
+
+    sol = []
+    for i in range(a):
+        sol.append(y_0[i] + h * f_0[i])
+
+    return sol
+
+
+def _rk4(red, x0, x1, y0, a):
+    """
+    Runge-Kutta 4th order numerical method.
+    """
+
+    A = sympify(x0)._to_mpmath(mp.prec)
+    B = sympify(x1)._to_mpmath(mp.prec)
+    y_0 = [sympify(i)._to_mpmath(mp.prec) for i in y0]
+    h = B - A
+
+    f_0_n = 0
+    f_1_n = 0
+    f_2_n = 0
+    f_3_n = 0
+
+    f_0 = y_0[1:]
+    for i in range(a):
+        f_0_n += sympify(DMFsubs(red[i], A, mpm=True))._to_mpmath(mp.prec) * y_0[i]
+    f_0.append(f_0_n)
+
+    f_1 = [y_0[i] + f_0[i]*h/2 for i in range(1, a)]
+    for i in range(a):
+        f_1_n += sympify(DMFsubs(red[i], A + h/2, mpm=True))._to_mpmath(mp.prec) * (y_0[i] + f_0[i]*h/2)
+    f_1.append(f_1_n)
+
+    f_2 = [y_0[i] + f_1[i]*h/2 for i in range(1, a)]
+    for i in range(a):
+        f_2_n += sympify(DMFsubs(red[i], A + h/2, mpm=True))._to_mpmath(mp.prec) * (y_0[i] + f_1[i]*h/2)
+    f_2.append(f_2_n)
+
+    f_3 = [y_0[i] + f_2[i]*h for i in range(1, a)]
+    for i in range(a):
+        f_3_n += sympify(DMFsubs(red[i], A + h, mpm=True))._to_mpmath(mp.prec) * (y_0[i] + f_2[i]*h)
+    f_3.append(f_3_n)
+
+    sol = []
+    for i in range(a):
+        sol.append(y_0[i] + h * (f_0[i]+2*f_1[i]+2*f_2[i]+f_3[i])/6)
+
+    return sol

parrot/lib/python3.10/site-packages/sympy/holonomic/recurrence.py

@@ -0,0 +1,365 @@
+"""Recurrence Operators"""
+
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.printing import sstr
+from sympy.core.sympify import sympify
+
+
+def RecurrenceOperators(base, generator):
+    """
+    Returns an Algebra of Recurrence Operators and the operator for
+    shifting i.e. the `Sn` operator.
+    The first argument needs to be the base polynomial ring for the algebra
+    and the second argument must be a generator which can be either a
+    noncommutative Symbol or a string.
+
+    Examples
+    ========
+
+    >>> from sympy import ZZ
+    >>> from sympy import symbols
+    >>> from sympy.holonomic.recurrence import RecurrenceOperators
+    >>> n = symbols('n', integer=True)
+    >>> R, Sn = RecurrenceOperators(ZZ.old_poly_ring(n), 'Sn')
+    """
+
+    ring = RecurrenceOperatorAlgebra(base, generator)
+    return (ring, ring.shift_operator)
+
+
+class RecurrenceOperatorAlgebra:
+    """
+    A Recurrence Operator Algebra is a set of noncommutative polynomials
+    in intermediate `Sn` and coefficients in a base ring A. It follows the
+    commutation rule:
+    Sn * a(n) = a(n + 1) * Sn
+
+    This class represents a Recurrence Operator Algebra and serves as the parent ring
+    for Recurrence Operators.
+
+    Examples
+    ========
+
+    >>> from sympy import ZZ
+    >>> from sympy import symbols
+    >>> from sympy.holonomic.recurrence import RecurrenceOperators
+    >>> n = symbols('n', integer=True)
+    >>> R, Sn = RecurrenceOperators(ZZ.old_poly_ring(n), 'Sn')
+    >>> R
+    Univariate Recurrence Operator Algebra in intermediate Sn over the base ring
+    ZZ[n]
+
+    See Also
+    ========
+
+    RecurrenceOperator
+    """
+
+    def __init__(self, base, generator):
+        # the base ring for the algebra
+        self.base = base
+        # the operator representing shift i.e. `Sn`
+        self.shift_operator = RecurrenceOperator(
+            [base.zero, base.one], self)
+
+        if generator is None:
+            self.gen_symbol = symbols('Sn', commutative=False)
+        else:
+            if isinstance(generator, str):
+                self.gen_symbol = symbols(generator, commutative=False)
+            elif isinstance(generator, Symbol):
+                self.gen_symbol = generator
+
+    def __str__(self):
+        string = 'Univariate Recurrence Operator Algebra in intermediate '\
+            + sstr(self.gen_symbol) + ' over the base ring ' + \
+            (self.base).__str__()
+
+        return string
+
+    __repr__ = __str__
+
+    def __eq__(self, other):
+        if self.base == other.base and self.gen_symbol == other.gen_symbol:
+            return True
+        else:
+            return False
+
+
+def _add_lists(list1, list2):
+    if len(list1) <= len(list2):
+        sol = [a + b for a, b in zip(list1, list2)] + list2[len(list1):]
+    else:
+        sol = [a + b for a, b in zip(list1, list2)] + list1[len(list2):]
+    return sol
+
+
+class RecurrenceOperator:
+    """
+    The Recurrence Operators are defined by a list of polynomials
+    in the base ring and the parent ring of the Operator.
+
+    Explanation
+    ===========
+
+    Takes a list of polynomials for each power of Sn and the
+    parent ring which must be an instance of RecurrenceOperatorAlgebra.
+
+    A Recurrence Operator can be created easily using
+    the operator `Sn`. See examples below.
+
+    Examples
+    ========
+
+    >>> from sympy.holonomic.recurrence import RecurrenceOperator, RecurrenceOperators
+    >>> from sympy import ZZ
+    >>> from sympy import symbols
+    >>> n = symbols('n', integer=True)
+    >>> R, Sn = RecurrenceOperators(ZZ.old_poly_ring(n),'Sn')
+
+    >>> RecurrenceOperator([0, 1, n**2], R)
+    (1)Sn + (n**2)Sn**2
+
+    >>> Sn*n
+    (n + 1)Sn
+
+    >>> n*Sn*n + 1 - Sn**2*n
+    (1) + (n**2 + n)Sn + (-n - 2)Sn**2
+
+    See Also
+    ========
+
+    DifferentialOperatorAlgebra
+    """
+
+    _op_priority = 20
+
+    def __init__(self, list_of_poly, parent):
+        # the parent ring for this operator
+        # must be an RecurrenceOperatorAlgebra object
+        self.parent = parent
+        # sequence of polynomials in n for each power of Sn
+        # represents the operator
+        # convert the expressions into ring elements using from_sympy
+        if isinstance(list_of_poly, list):
+            for i, j in enumerate(list_of_poly):
+                if isinstance(j, int):
+                    list_of_poly[i] = self.parent.base.from_sympy(S(j))
+                elif not isinstance(j, self.parent.base.dtype):
+                    list_of_poly[i] = self.parent.base.from_sympy(j)
+
+            self.listofpoly = list_of_poly
+        self.order = len(self.listofpoly) - 1
+
+    def __mul__(self, other):
+        """
+        Multiplies two Operators and returns another
+        RecurrenceOperator instance using the commutation rule
+        Sn * a(n) = a(n + 1) * Sn
+        """
+
+        listofself = self.listofpoly
+        base = self.parent.base
+
+        if not isinstance(other, RecurrenceOperator):
+            if not isinstance(other, self.parent.base.dtype):
+                listofother = [self.parent.base.from_sympy(sympify(other))]
+
+            else:
+                listofother = [other]
+        else:
+            listofother = other.listofpoly
+        # multiply a polynomial `b` with a list of polynomials
+
+        def _mul_dmp_diffop(b, listofother):
+            if isinstance(listofother, list):
+                sol = []
+                for i in listofother:
+                    sol.append(i * b)
+                return sol
+            else:
+                return [b * listofother]
+
+        sol = _mul_dmp_diffop(listofself[0], listofother)
+
+        # compute Sn^i * b
+        def _mul_Sni_b(b):
+            sol = [base.zero]
+
+            if isinstance(b, list):
+                for i in b:
+                    j = base.to_sympy(i).subs(base.gens[0], base.gens[0] + S.One)
+                    sol.append(base.from_sympy(j))
+
+            else:
+                j = b.subs(base.gens[0], base.gens[0] + S.One)
+                sol.append(base.from_sympy(j))
+
+            return sol
+
+        for i in range(1, len(listofself)):
+            # find Sn^i * b in ith iteration
+            listofother = _mul_Sni_b(listofother)
+            # solution = solution + listofself[i] * (Sn^i * b)
+            sol = _add_lists(sol, _mul_dmp_diffop(listofself[i], listofother))
+
+        return RecurrenceOperator(sol, self.parent)
+
+    def __rmul__(self, other):
+        if not isinstance(other, RecurrenceOperator):
+
+            if isinstance(other, int):
+                other = S(other)
+
+            if not isinstance(other, self.parent.base.dtype):
+                other = (self.parent.base).from_sympy(other)
+
+            sol = []
+            for j in self.listofpoly:
+                sol.append(other * j)
+
+            return RecurrenceOperator(sol, self.parent)
+
+    def __add__(self, other):
+        if isinstance(other, RecurrenceOperator):
+
+            sol = _add_lists(self.listofpoly, other.listofpoly)
+            return RecurrenceOperator(sol, self.parent)
+
+        else:
+
+            if isinstance(other, int):
+                other = S(other)
+            list_self = self.listofpoly
+            if not isinstance(other, self.parent.base.dtype):
+                list_other = [((self.parent).base).from_sympy(other)]
+            else:
+                list_other = [other]
+            sol = []
+            sol.append(list_self[0] + list_other[0])
+            sol += list_self[1:]
+
+            return RecurrenceOperator(sol, self.parent)
+
+    __radd__ = __add__
+
+    def __sub__(self, other):
+        return self + (-1) * other
+
+    def __rsub__(self, other):
+        return (-1) * self + other
+
+    def __pow__(self, n):
+        if n == 1:
+            return self
+        result = RecurrenceOperator([self.parent.base.one], self.parent)
+        if n == 0:
+            return result
+        # if self is `Sn`
+        if self.listofpoly == self.parent.shift_operator.listofpoly:
+            sol = [self.parent.base.zero] * n + [self.parent.base.one]
+            return RecurrenceOperator(sol, self.parent)
+        x = self
+        while True:
+            if n % 2:
+                result *= x
+            n >>= 1
+            if not n:
+                break
+            x *= x
+        return result
+
+    def __str__(self):
+        listofpoly = self.listofpoly
+        print_str = ''
+
+        for i, j in enumerate(listofpoly):
+            if j == self.parent.base.zero:
+                continue
+
+            j = self.parent.base.to_sympy(j)
+
+            if i == 0:
+                print_str += '(' + sstr(j) + ')'
+                continue
+
+            if print_str:
+                print_str += ' + '
+
+            if i == 1:
+                print_str += '(' + sstr(j) + ')Sn'
+                continue
+
+            print_str += '(' + sstr(j) + ')' + 'Sn**' + sstr(i)
+
+        return print_str
+
+    __repr__ = __str__
+
+    def __eq__(self, other):
+        if isinstance(other, RecurrenceOperator):
+            if self.listofpoly == other.listofpoly and self.parent == other.parent:
+                return True
+            else:
+                return False
+        else:
+            if self.listofpoly[0] == other:
+                for i in self.listofpoly[1:]:
+                    if i is not self.parent.base.zero:
+                        return False
+                return True
+            else:
+                return False
+
+
+class HolonomicSequence:
+    """
+    A Holonomic Sequence is a type of sequence satisfying a linear homogeneous
+    recurrence relation with Polynomial coefficients. Alternatively, A sequence
+    is Holonomic if and only if its generating function is a Holonomic Function.
+    """
+
+    def __init__(self, recurrence, u0=[]):
+        self.recurrence = recurrence
+        if not isinstance(u0, list):
+            self.u0 = [u0]
+        else:
+            self.u0 = u0
+
+        if len(self.u0) == 0:
+            self._have_init_cond = False
+        else:
+            self._have_init_cond = True
+        self.n = recurrence.parent.base.gens[0]
+
+    def __repr__(self):
+        str_sol = 'HolonomicSequence(%s, %s)' % ((self.recurrence).__repr__(), sstr(self.n))
+        if not self._have_init_cond:
+            return str_sol
+        else:
+            cond_str = ''
+            seq_str = 0
+            for i in self.u0:
+                cond_str += ', u(%s) = %s' % (sstr(seq_str), sstr(i))
+                seq_str += 1
+
+            sol = str_sol + cond_str
+            return sol
+
+    __str__ = __repr__
+
+    def __eq__(self, other):
+        if self.recurrence == other.recurrence:
+            if self.n == other.n:
+                if self._have_init_cond and other._have_init_cond:
+                    if self.u0 == other.u0:
+                        return True
+                    else:
+                        return False
+                else:
+                    return True
+            else:
+                return False
+        else:
+            return False

parrot/lib/python3.10/site-packages/sympy/holonomic/tests/test_recurrence.py

@@ -0,0 +1,41 @@
+from sympy.holonomic.recurrence import RecurrenceOperators, RecurrenceOperator
+from sympy.core.symbol import symbols
+from sympy.polys.domains.rationalfield import QQ
+
+
+def test_RecurrenceOperator():
+    n = symbols('n', integer=True)
+    R, Sn = RecurrenceOperators(QQ.old_poly_ring(n), 'Sn')
+    assert Sn*n == (n + 1)*Sn
+    assert Sn*n**2 == (n**2+1+2*n)*Sn
+    assert Sn**2*n**2 == (n**2 + 4*n + 4)*Sn**2
+    p = (Sn**3*n**2 + Sn*n)**2
+    q = (n**2 + 3*n + 2)*Sn**2 + (2*n**3 + 19*n**2 + 57*n + 52)*Sn**4 + (n**4 + 18*n**3 + \
+        117*n**2 + 324*n + 324)*Sn**6
+    assert p == q
+
+
+def test_RecurrenceOperatorEqPoly():
+    n = symbols('n', integer=True)
+    R, Sn = RecurrenceOperators(QQ.old_poly_ring(n), 'Sn')
+    rr = RecurrenceOperator([n**2, 0, 0], R)
+    rr2 = RecurrenceOperator([n**2, 1, n], R)
+    assert not rr == rr2
+
+    # polynomial comparison issue, see https://github.com/sympy/sympy/pull/15799
+    # should work once that is solved
+    # d = rr.listofpoly[0]
+    # assert rr == d
+
+    d2 = rr2.listofpoly[0]
+    assert not rr2 == d2
+
+
+def test_RecurrenceOperatorPow():
+    n = symbols('n', integer=True)
+    R, _ = RecurrenceOperators(QQ.old_poly_ring(n), 'Sn')
+    rr = RecurrenceOperator([n**2, 0, 0], R)
+    a = RecurrenceOperator([R.base.one], R)
+    for m in range(10):
+        assert a == rr**m
+        a *= rr

parrot/lib/python3.10/site-packages/sympy/stats/__init__.py

@@ -0,0 +1,202 @@
+"""
+SymPy statistics module
+
+Introduces a random variable type into the SymPy language.
+
+Random variables may be declared using prebuilt functions such as
+Normal, Exponential, Coin, Die, etc...  or built with functions like FiniteRV.
+
+Queries on random expressions can be made using the functions
+
+========================= =============================
+    Expression                    Meaning
+------------------------- -----------------------------
+ ``P(condition)``          Probability
+ ``E(expression)``         Expected value
+ ``H(expression)``         Entropy
+ ``variance(expression)``  Variance
+ ``density(expression)``   Probability Density Function
+ ``sample(expression)``    Produce a realization
+ ``where(condition)``      Where the condition is true
+========================= =============================
+
+Examples
+========
+
+>>> from sympy.stats import P, E, variance, Die, Normal
+>>> from sympy import simplify
+>>> X, Y = Die('X', 6), Die('Y', 6) # Define two six sided dice
+>>> Z = Normal('Z', 0, 1) # Declare a Normal random variable with mean 0, std 1
+>>> P(X>3) # Probability X is greater than 3
+1/2
+>>> E(X+Y) # Expectation of the sum of two dice
+7
+>>> variance(X+Y) # Variance of the sum of two dice
+35/6
+>>> simplify(P(Z>1)) # Probability of Z being greater than 1
+1/2 - erf(sqrt(2)/2)/2
+
+
+One could also create custom distribution and define custom random variables
+as follows:
+
+1. If you want to create a Continuous Random Variable:
+
+>>> from sympy.stats import ContinuousRV, P, E
+>>> from sympy import exp, Symbol, Interval, oo
+>>> x = Symbol('x')
+>>> pdf = exp(-x) # pdf of the Continuous Distribution
+>>> Z = ContinuousRV(x, pdf, set=Interval(0, oo))
+>>> E(Z)
+1
+>>> P(Z > 5)
+exp(-5)
+
+1.1 To create an instance of Continuous Distribution:
+
+>>> from sympy.stats import ContinuousDistributionHandmade
+>>> from sympy import Lambda
+>>> dist = ContinuousDistributionHandmade(Lambda(x, pdf), set=Interval(0, oo))
+>>> dist.pdf(x)
+exp(-x)
+
+2. If you want to create a Discrete Random Variable:
+
+>>> from sympy.stats import DiscreteRV, P, E
+>>> from sympy import Symbol, S
+>>> p = S(1)/2
+>>> x = Symbol('x', integer=True, positive=True)
+>>> pdf = p*(1 - p)**(x - 1)
+>>> D = DiscreteRV(x, pdf, set=S.Naturals)
+>>> E(D)
+2
+>>> P(D > 3)
+1/8
+
+2.1 To create an instance of Discrete Distribution:
+
+>>> from sympy.stats import DiscreteDistributionHandmade
+>>> from sympy import Lambda
+>>> dist = DiscreteDistributionHandmade(Lambda(x, pdf), set=S.Naturals)
+>>> dist.pdf(x)
+2**(1 - x)/2
+
+3. If you want to create a Finite Random Variable:
+
+>>> from sympy.stats import FiniteRV, P, E
+>>> from sympy import Rational, Eq
+>>> pmf = {1: Rational(1, 3), 2: Rational(1, 6), 3: Rational(1, 4), 4: Rational(1, 4)}
+>>> X = FiniteRV('X', pmf)
+>>> E(X)
+29/12
+>>> P(X > 3)
+1/4
+
+3.1 To create an instance of Finite Distribution:
+
+>>> from sympy.stats import FiniteDistributionHandmade
+>>> dist = FiniteDistributionHandmade(pmf)
+>>> dist.pmf(x)
+Lambda(x, Piecewise((1/3, Eq(x, 1)), (1/6, Eq(x, 2)), (1/4, Eq(x, 3) | Eq(x, 4)), (0, True)))
+"""
+
+__all__ = [
+    'P', 'E', 'H', 'density', 'where', 'given', 'sample', 'cdf','median',
+    'characteristic_function', 'pspace', 'sample_iter', 'variance', 'std',
+    'skewness', 'kurtosis', 'covariance', 'dependent', 'entropy', 'independent',
+    'random_symbols', 'correlation', 'factorial_moment', 'moment', 'cmoment',
+    'sampling_density', 'moment_generating_function', 'smoment', 'quantile',
+    'coskewness', 'sample_stochastic_process',
+
+    'FiniteRV', 'DiscreteUniform', 'Die', 'Bernoulli', 'Coin', 'Binomial',
+    'BetaBinomial', 'Hypergeometric', 'Rademacher', 'IdealSoliton', 'RobustSoliton',
+    'FiniteDistributionHandmade',
+
+    'ContinuousRV', 'Arcsin', 'Benini', 'Beta', 'BetaNoncentral', 'BetaPrime',
+    'BoundedPareto', 'Cauchy', 'Chi', 'ChiNoncentral', 'ChiSquared', 'Dagum', 'Davis', 'Erlang',
+    'ExGaussian', 'Exponential', 'ExponentialPower', 'FDistribution',
+    'FisherZ', 'Frechet', 'Gamma', 'GammaInverse', 'Gompertz', 'Gumbel',
+    'Kumaraswamy', 'Laplace', 'Levy', 'Logistic','LogCauchy', 'LogLogistic', 'LogitNormal', 'LogNormal', 'Lomax',
+    'Moyal', 'Maxwell', 'Nakagami', 'Normal', 'GaussianInverse', 'Pareto', 'PowerFunction',
+    'QuadraticU', 'RaisedCosine', 'Rayleigh','Reciprocal', 'StudentT', 'ShiftedGompertz',
+    'Trapezoidal', 'Triangular', 'Uniform', 'UniformSum', 'VonMises', 'Wald',
+    'Weibull', 'WignerSemicircle', 'ContinuousDistributionHandmade',
+
+    'FlorySchulz', 'Geometric','Hermite', 'Logarithmic', 'NegativeBinomial', 'Poisson', 'Skellam',
+    'YuleSimon', 'Zeta', 'DiscreteRV', 'DiscreteDistributionHandmade',
+
+    'JointRV', 'Dirichlet', 'GeneralizedMultivariateLogGamma',
+    'GeneralizedMultivariateLogGammaOmega', 'Multinomial', 'MultivariateBeta',
+    'MultivariateEwens', 'MultivariateT', 'NegativeMultinomial',
+    'NormalGamma', 'MultivariateNormal', 'MultivariateLaplace', 'marginal_distribution',
+
+    'StochasticProcess', 'DiscreteTimeStochasticProcess',
+    'DiscreteMarkovChain', 'TransitionMatrixOf', 'StochasticStateSpaceOf',
+    'GeneratorMatrixOf', 'ContinuousMarkovChain', 'BernoulliProcess',
+    'PoissonProcess', 'WienerProcess', 'GammaProcess',
+
+    'CircularEnsemble', 'CircularUnitaryEnsemble',
+    'CircularOrthogonalEnsemble', 'CircularSymplecticEnsemble',
+    'GaussianEnsemble', 'GaussianUnitaryEnsemble',
+    'GaussianOrthogonalEnsemble', 'GaussianSymplecticEnsemble',
+    'joint_eigen_distribution', 'JointEigenDistribution',
+    'level_spacing_distribution',
+
+    'MatrixGamma', 'Wishart', 'MatrixNormal', 'MatrixStudentT',
+
+    'Probability', 'Expectation', 'Variance', 'Covariance', 'Moment',
+    'CentralMoment',
+
+    'ExpectationMatrix', 'VarianceMatrix', 'CrossCovarianceMatrix'
+
+]
+from .rv_interface import (P, E, H, density, where, given, sample, cdf, median,
+        characteristic_function, pspace, sample_iter, variance, std, skewness,
+        kurtosis, covariance, dependent, entropy, independent, random_symbols,
+        correlation, factorial_moment, moment, cmoment, sampling_density,
+        moment_generating_function, smoment, quantile, coskewness,
+        sample_stochastic_process)
+
+from .frv_types import (FiniteRV, DiscreteUniform, Die, Bernoulli, Coin,
+        Binomial, BetaBinomial, Hypergeometric, Rademacher,
+        FiniteDistributionHandmade, IdealSoliton, RobustSoliton)
+
+from .crv_types import (ContinuousRV, Arcsin, Benini, Beta, BetaNoncentral,
+        BetaPrime, BoundedPareto, Cauchy, Chi, ChiNoncentral, ChiSquared,
+        Dagum, Davis, Erlang, ExGaussian, Exponential, ExponentialPower,
+        FDistribution, FisherZ, Frechet, Gamma, GammaInverse, GaussianInverse,
+        Gompertz, Gumbel, Kumaraswamy, Laplace, Levy, Logistic, LogCauchy,
+        LogLogistic, LogitNormal, LogNormal, Lomax, Maxwell, Moyal, Nakagami,
+        Normal, Pareto, QuadraticU, RaisedCosine, Rayleigh, Reciprocal,
+        StudentT, PowerFunction, ShiftedGompertz, Trapezoidal, Triangular,
+        Uniform, UniformSum, VonMises, Wald, Weibull, WignerSemicircle,
+        ContinuousDistributionHandmade)
+
+from .drv_types import (FlorySchulz, Geometric, Hermite, Logarithmic, NegativeBinomial, Poisson,
+        Skellam, YuleSimon, Zeta, DiscreteRV, DiscreteDistributionHandmade)
+
+from .joint_rv_types import (JointRV, Dirichlet,
+        GeneralizedMultivariateLogGamma, GeneralizedMultivariateLogGammaOmega,
+        Multinomial, MultivariateBeta, MultivariateEwens, MultivariateT,
+        NegativeMultinomial, NormalGamma, MultivariateNormal, MultivariateLaplace,
+        marginal_distribution)
+
+from .stochastic_process_types import (StochasticProcess,
+        DiscreteTimeStochasticProcess, DiscreteMarkovChain,
+        TransitionMatrixOf, StochasticStateSpaceOf, GeneratorMatrixOf,
+        ContinuousMarkovChain, BernoulliProcess, PoissonProcess, WienerProcess,
+        GammaProcess)
+
+from .random_matrix_models import (CircularEnsemble, CircularUnitaryEnsemble,
+        CircularOrthogonalEnsemble, CircularSymplecticEnsemble,
+        GaussianEnsemble, GaussianUnitaryEnsemble, GaussianOrthogonalEnsemble,
+        GaussianSymplecticEnsemble, joint_eigen_distribution,
+        JointEigenDistribution, level_spacing_distribution)
+
+from .matrix_distributions import MatrixGamma, Wishart, MatrixNormal, MatrixStudentT
+
+from .symbolic_probability import (Probability, Expectation, Variance,
+        Covariance, Moment, CentralMoment)
+
+from .symbolic_multivariate_probability import (ExpectationMatrix, VarianceMatrix,
+        CrossCovarianceMatrix)

parrot/lib/python3.10/site-packages/sympy/stats/crv.py

@@ -0,0 +1,570 @@
+"""
+Continuous Random Variables Module
+
+See Also
+========
+sympy.stats.crv_types
+sympy.stats.rv
+sympy.stats.frv
+"""
+
+
+from sympy.core.basic import Basic
+from sympy.core.cache import cacheit
+from sympy.core.function import Lambda, PoleError
+from sympy.core.numbers import (I, nan, oo)
+from sympy.core.relational import (Eq, Ne)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.core.sympify import _sympify, sympify
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.delta_functions import DiracDelta
+from sympy.integrals.integrals import (Integral, integrate)
+from sympy.logic.boolalg import (And, Or)
+from sympy.polys.polyerrors import PolynomialError
+from sympy.polys.polytools import poly
+from sympy.series.series import series
+from sympy.sets.sets import (FiniteSet, Intersection, Interval, Union)
+from sympy.solvers.solveset import solveset
+from sympy.solvers.inequalities import reduce_rational_inequalities
+from sympy.stats.rv import (RandomDomain, SingleDomain, ConditionalDomain, is_random,
+        ProductDomain, PSpace, SinglePSpace, random_symbols, NamedArgsMixin, Distribution)
+
+
+class ContinuousDomain(RandomDomain):
+    """
+    A domain with continuous support
+
+    Represented using symbols and Intervals.
+    """
+    is_Continuous = True
+
+    def as_boolean(self):
+        raise NotImplementedError("Not Implemented for generic Domains")
+
+
+class SingleContinuousDomain(ContinuousDomain, SingleDomain):
+    """
+    A univariate domain with continuous support
+
+    Represented using a single symbol and interval.
+    """
+    def compute_expectation(self, expr, variables=None, **kwargs):
+        if variables is None:
+            variables = self.symbols
+        if not variables:
+            return expr
+        if frozenset(variables) != frozenset(self.symbols):
+            raise ValueError("Values should be equal")
+        # assumes only intervals
+        return Integral(expr, (self.symbol, self.set), **kwargs)
+
+    def as_boolean(self):
+        return self.set.as_relational(self.symbol)
+
+
+class ProductContinuousDomain(ProductDomain, ContinuousDomain):
+    """
+    A collection of independent domains with continuous support
+    """
+
+    def compute_expectation(self, expr, variables=None, **kwargs):
+        if variables is None:
+            variables = self.symbols
+        for domain in self.domains:
+            domain_vars = frozenset(variables) & frozenset(domain.symbols)
+            if domain_vars:
+                expr = domain.compute_expectation(expr, domain_vars, **kwargs)
+        return expr
+
+    def as_boolean(self):
+        return And(*[domain.as_boolean() for domain in self.domains])
+
+
+class ConditionalContinuousDomain(ContinuousDomain, ConditionalDomain):
+    """
+    A domain with continuous support that has been further restricted by a
+    condition such as $x > 3$.
+    """
+
+    def compute_expectation(self, expr, variables=None, **kwargs):
+        if variables is None:
+            variables = self.symbols
+        if not variables:
+            return expr
+        # Extract the full integral
+        fullintgrl = self.fulldomain.compute_expectation(expr, variables)
+        # separate into integrand and limits
+        integrand, limits = fullintgrl.function, list(fullintgrl.limits)
+
+        conditions = [self.condition]
+        while conditions:
+            cond = conditions.pop()
+            if cond.is_Boolean:
+                if isinstance(cond, And):
+                    conditions.extend(cond.args)
+                elif isinstance(cond, Or):
+                    raise NotImplementedError("Or not implemented here")
+            elif cond.is_Relational:
+                if cond.is_Equality:
+                    # Add the appropriate Delta to the integrand
+                    integrand *= DiracDelta(cond.lhs - cond.rhs)
+                else:
+                    symbols = cond.free_symbols & set(self.symbols)
+                    if len(symbols) != 1:  # Can't handle x > y
+                        raise NotImplementedError(
+                            "Multivariate Inequalities not yet implemented")
+                    # Can handle x > 0
+                    symbol = symbols.pop()
+                    # Find the limit with x, such as (x, -oo, oo)
+                    for i, limit in enumerate(limits):
+                        if limit[0] == symbol:
+                            # Make condition into an Interval like [0, oo]
+                            cintvl = reduce_rational_inequalities_wrap(
+                                cond, symbol)
+                            # Make limit into an Interval like [-oo, oo]
+                            lintvl = Interval(limit[1], limit[2])
+                            # Intersect them to get [0, oo]
+                            intvl = cintvl.intersect(lintvl)
+                            # Put back into limits list
+                            limits[i] = (symbol, intvl.left, intvl.right)
+            else:
+                raise TypeError(
+                    "Condition %s is not a relational or Boolean" % cond)
+
+        return Integral(integrand, *limits, **kwargs)
+
+    def as_boolean(self):
+        return And(self.fulldomain.as_boolean(), self.condition)
+
+    @property
+    def set(self):
+        if len(self.symbols) == 1:
+            return (self.fulldomain.set & reduce_rational_inequalities_wrap(
+                self.condition, tuple(self.symbols)[0]))
+        else:
+            raise NotImplementedError(
+                "Set of Conditional Domain not Implemented")
+
+
+class ContinuousDistribution(Distribution):
+    def __call__(self, *args):
+        return self.pdf(*args)
+
+
+class SingleContinuousDistribution(ContinuousDistribution, NamedArgsMixin):
+    """ Continuous distribution of a single variable.
+
+    Explanation
+    ===========
+
+    Serves as superclass for Normal/Exponential/UniformDistribution etc....
+
+    Represented by parameters for each of the specific classes.  E.g
+    NormalDistribution is represented by a mean and standard deviation.
+
+    Provides methods for pdf, cdf, and sampling.
+
+    See Also
+    ========
+
+    sympy.stats.crv_types.*
+    """
+
+    set = Interval(-oo, oo)
+
+    def __new__(cls, *args):
+        args = list(map(sympify, args))
+        return Basic.__new__(cls, *args)
+
+    @staticmethod
+    def check(*args):
+        pass
+
+    @cacheit
+    def compute_cdf(self, **kwargs):
+        """ Compute the CDF from the PDF.
+
+        Returns a Lambda.
+        """
+        x, z = symbols('x, z', real=True, cls=Dummy)
+        left_bound = self.set.start
+
+        # CDF is integral of PDF from left bound to z
+        pdf = self.pdf(x)
+        cdf = integrate(pdf.doit(), (x, left_bound, z), **kwargs)
+        # CDF Ensure that CDF left of left_bound is zero
+        cdf = Piecewise((cdf, z >= left_bound), (0, True))
+        return Lambda(z, cdf)
+
+    def _cdf(self, x):
+        return None
+
+    def cdf(self, x, **kwargs):
+        """ Cumulative density function """
+        if len(kwargs) == 0:
+            cdf = self._cdf(x)
+            if cdf is not None:
+                return cdf
+        return self.compute_cdf(**kwargs)(x)
+
+    @cacheit
+    def compute_characteristic_function(self, **kwargs):
+        """ Compute the characteristic function from the PDF.
+
+        Returns a Lambda.
+        """
+        x, t = symbols('x, t', real=True, cls=Dummy)
+        pdf = self.pdf(x)
+        cf = integrate(exp(I*t*x)*pdf, (x, self.set))
+        return Lambda(t, cf)
+
+    def _characteristic_function(self, t):
+        return None
+
+    def characteristic_function(self, t, **kwargs):
+        """ Characteristic function """
+        if len(kwargs) == 0:
+            cf = self._characteristic_function(t)
+            if cf is not None:
+                return cf
+        return self.compute_characteristic_function(**kwargs)(t)
+
+    @cacheit
+    def compute_moment_generating_function(self, **kwargs):
+        """ Compute the moment generating function from the PDF.
+
+        Returns a Lambda.
+        """
+        x, t = symbols('x, t', real=True, cls=Dummy)
+        pdf = self.pdf(x)
+        mgf = integrate(exp(t * x) * pdf, (x, self.set))
+        return Lambda(t, mgf)
+
+    def _moment_generating_function(self, t):
+        return None
+
+    def moment_generating_function(self, t, **kwargs):
+        """ Moment generating function """
+        if not kwargs:
+                mgf = self._moment_generating_function(t)
+                if mgf is not None:
+                    return mgf
+        return self.compute_moment_generating_function(**kwargs)(t)
+
+    def expectation(self, expr, var, evaluate=True, **kwargs):
+        """ Expectation of expression over distribution """
+        if evaluate:
+            try:
+                p = poly(expr, var)
+                if p.is_zero:
+                    return S.Zero
+                t = Dummy('t', real=True)
+                mgf = self._moment_generating_function(t)
+                if mgf is None:
+                    return integrate(expr * self.pdf(var), (var, self.set), **kwargs)
+                deg = p.degree()
+                taylor = poly(series(mgf, t, 0, deg + 1).removeO(), t)
+                result = 0
+                for k in range(deg+1):
+                    result += p.coeff_monomial(var ** k) * taylor.coeff_monomial(t ** k) * factorial(k)
+                return result
+            except PolynomialError:
+                return integrate(expr * self.pdf(var), (var, self.set), **kwargs)
+        else:
+            return Integral(expr * self.pdf(var), (var, self.set), **kwargs)
+
+    @cacheit
+    def compute_quantile(self, **kwargs):
+        """ Compute the Quantile from the PDF.
+
+        Returns a Lambda.
+        """
+        x, p = symbols('x, p', real=True, cls=Dummy)
+        left_bound = self.set.start
+
+        pdf = self.pdf(x)
+        cdf = integrate(pdf, (x, left_bound, x), **kwargs)
+        quantile = solveset(cdf - p, x, self.set)
+        return Lambda(p, Piecewise((quantile, (p >= 0) & (p <= 1) ), (nan, True)))
+
+    def _quantile(self, x):
+        return None
+
+    def quantile(self, x, **kwargs):
+        """ Cumulative density function """
+        if len(kwargs) == 0:
+            quantile = self._quantile(x)
+            if quantile is not None:
+                return quantile
+        return self.compute_quantile(**kwargs)(x)
+
+
+class ContinuousPSpace(PSpace):
+    """ Continuous Probability Space
+
+    Represents the likelihood of an event space defined over a continuum.
+
+    Represented with a ContinuousDomain and a PDF (Lambda-Like)
+    """
+
+    is_Continuous = True
+    is_real = True
+
+    @property
+    def pdf(self):
+        return self.density(*self.domain.symbols)
+
+    def compute_expectation(self, expr, rvs=None, evaluate=False, **kwargs):
+        if rvs is None:
+            rvs = self.values
+        else:
+            rvs = frozenset(rvs)
+
+        expr = expr.xreplace({rv: rv.symbol for rv in rvs})
+
+        domain_symbols = frozenset(rv.symbol for rv in rvs)
+
+        return self.domain.compute_expectation(self.pdf * expr,
+                domain_symbols, **kwargs)
+
+    def compute_density(self, expr, **kwargs):
+        # Common case Density(X) where X in self.values
+        if expr in self.values:
+            # Marginalize all other random symbols out of the density
+            randomsymbols = tuple(set(self.values) - frozenset([expr]))
+            symbols = tuple(rs.symbol for rs in randomsymbols)
+            pdf = self.domain.compute_expectation(self.pdf, symbols, **kwargs)
+            return Lambda(expr.symbol, pdf)
+
+        z = Dummy('z', real=True)
+        return Lambda(z, self.compute_expectation(DiracDelta(expr - z), **kwargs))
+
+    @cacheit
+    def compute_cdf(self, expr, **kwargs):
+        if not self.domain.set.is_Interval:
+            raise ValueError(
+                "CDF not well defined on multivariate expressions")
+
+        d = self.compute_density(expr, **kwargs)
+        x, z = symbols('x, z', real=True, cls=Dummy)
+        left_bound = self.domain.set.start
+
+        # CDF is integral of PDF from left bound to z
+        cdf = integrate(d(x), (x, left_bound, z), **kwargs)
+        # CDF Ensure that CDF left of left_bound is zero
+        cdf = Piecewise((cdf, z >= left_bound), (0, True))
+        return Lambda(z, cdf)
+
+    @cacheit
+    def compute_characteristic_function(self, expr, **kwargs):
+        if not self.domain.set.is_Interval:
+            raise NotImplementedError("Characteristic function of multivariate expressions not implemented")
+
+        d = self.compute_density(expr, **kwargs)
+        x, t = symbols('x, t', real=True, cls=Dummy)
+        cf = integrate(exp(I*t*x)*d(x), (x, -oo, oo), **kwargs)
+        return Lambda(t, cf)
+
+    @cacheit
+    def compute_moment_generating_function(self, expr, **kwargs):
+        if not self.domain.set.is_Interval:
+            raise NotImplementedError("Moment generating function of multivariate expressions not implemented")
+
+        d = self.compute_density(expr, **kwargs)
+        x, t = symbols('x, t', real=True, cls=Dummy)
+        mgf = integrate(exp(t * x) * d(x), (x, -oo, oo), **kwargs)
+        return Lambda(t, mgf)
+
+    @cacheit
+    def compute_quantile(self, expr, **kwargs):
+        if not self.domain.set.is_Interval:
+            raise ValueError(
+                "Quantile not well defined on multivariate expressions")
+
+        d = self.compute_cdf(expr, **kwargs)
+        x = Dummy('x', real=True)
+        p = Dummy('p', positive=True)
+
+        quantile = solveset(d(x) - p, x, self.set)
+
+        return Lambda(p, quantile)
+
+    def probability(self, condition, **kwargs):
+        z = Dummy('z', real=True)
+        cond_inv = False
+        if isinstance(condition, Ne):
+            condition = Eq(condition.args[0], condition.args[1])
+            cond_inv = True
+        # Univariate case can be handled by where
+        try:
+            domain = self.where(condition)
+            rv = [rv for rv in self.values if rv.symbol == domain.symbol][0]
+            # Integrate out all other random variables
+            pdf = self.compute_density(rv, **kwargs)
+            # return S.Zero if `domain` is empty set
+            if domain.set is S.EmptySet or isinstance(domain.set, FiniteSet):
+                return S.Zero if not cond_inv else S.One
+            if isinstance(domain.set, Union):
+                return sum(
+                     Integral(pdf(z), (z, subset), **kwargs) for subset in
+                     domain.set.args if isinstance(subset, Interval))
+            # Integrate out the last variable over the special domain
+            return Integral(pdf(z), (z, domain.set), **kwargs)
+
+        # Other cases can be turned into univariate case
+        # by computing a density handled by density computation
+        except NotImplementedError:
+            from sympy.stats.rv import density
+            expr = condition.lhs - condition.rhs
+            if not is_random(expr):
+                dens = self.density
+                comp = condition.rhs
+            else:
+                dens = density(expr, **kwargs)
+                comp = 0
+            if not isinstance(dens, ContinuousDistribution):
+                from sympy.stats.crv_types import ContinuousDistributionHandmade
+                dens = ContinuousDistributionHandmade(dens, set=self.domain.set)
+            # Turn problem into univariate case
+            space = SingleContinuousPSpace(z, dens)
+            result = space.probability(condition.__class__(space.value, comp))
+            return result if not cond_inv else S.One - result
+
+    def where(self, condition):
+        rvs = frozenset(random_symbols(condition))
+        if not (len(rvs) == 1 and rvs.issubset(self.values)):
+            raise NotImplementedError(
+                "Multiple continuous random variables not supported")
+        rv = tuple(rvs)[0]
+        interval = reduce_rational_inequalities_wrap(condition, rv)
+        interval = interval.intersect(self.domain.set)
+        return SingleContinuousDomain(rv.symbol, interval)
+
+    def conditional_space(self, condition, normalize=True, **kwargs):
+        condition = condition.xreplace({rv: rv.symbol for rv in self.values})
+        domain = ConditionalContinuousDomain(self.domain, condition)
+        if normalize:
+            # create a clone of the variable to
+            # make sure that variables in nested integrals are different
+            # from the variables outside the integral
+            # this makes sure that they are evaluated separately
+            # and in the correct order
+            replacement  = {rv: Dummy(str(rv)) for rv in self.symbols}
+            norm = domain.compute_expectation(self.pdf, **kwargs)
+            pdf = self.pdf / norm.xreplace(replacement)
+            # XXX: Converting set to tuple. The order matters to Lambda though
+            # so we shouldn't be starting with a set here...
+            density = Lambda(tuple(domain.symbols), pdf)
+
+        return ContinuousPSpace(domain, density)
+
+
+class SingleContinuousPSpace(ContinuousPSpace, SinglePSpace):
+    """
+    A continuous probability space over a single univariate variable.
+
+    These consist of a Symbol and a SingleContinuousDistribution
+
+    This class is normally accessed through the various random variable
+    functions, Normal, Exponential, Uniform, etc....
+    """
+
+    @property
+    def set(self):
+        return self.distribution.set
+
+    @property
+    def domain(self):
+        return SingleContinuousDomain(sympify(self.symbol), self.set)
+
+    def sample(self, size=(), library='scipy', seed=None):
+        """
+        Internal sample method.
+
+        Returns dictionary mapping RandomSymbol to realization value.
+        """
+        return {self.value: self.distribution.sample(size, library=library, seed=seed)}
+
+    def compute_expectation(self, expr, rvs=None, evaluate=False, **kwargs):
+        rvs = rvs or (self.value,)
+        if self.value not in rvs:
+            return expr
+
+        expr = _sympify(expr)
+        expr = expr.xreplace({rv: rv.symbol for rv in rvs})
+
+        x = self.value.symbol
+        try:
+            return self.distribution.expectation(expr, x, evaluate=evaluate, **kwargs)
+        except PoleError:
+            return Integral(expr * self.pdf, (x, self.set), **kwargs)
+
+    def compute_cdf(self, expr, **kwargs):
+        if expr == self.value:
+            z = Dummy("z", real=True)
+            return Lambda(z, self.distribution.cdf(z, **kwargs))
+        else:
+            return ContinuousPSpace.compute_cdf(self, expr, **kwargs)
+
+    def compute_characteristic_function(self, expr, **kwargs):
+        if expr == self.value:
+            t = Dummy("t", real=True)
+            return Lambda(t, self.distribution.characteristic_function(t, **kwargs))
+        else:
+            return ContinuousPSpace.compute_characteristic_function(self, expr, **kwargs)
+
+    def compute_moment_generating_function(self, expr, **kwargs):
+        if expr == self.value:
+            t = Dummy("t", real=True)
+            return Lambda(t, self.distribution.moment_generating_function(t, **kwargs))
+        else:
+            return ContinuousPSpace.compute_moment_generating_function(self, expr, **kwargs)
+
+    def compute_density(self, expr, **kwargs):
+        # https://en.wikipedia.org/wiki/Random_variable#Functions_of_random_variables
+        if expr == self.value:
+            return self.density
+        y = Dummy('y', real=True)
+
+        gs = solveset(expr - y, self.value, S.Reals)
+
+        if isinstance(gs, Intersection):
+            if len(gs.args) == 2 and gs.args[0] is S.Reals:
+                gs = gs.args[1]
+        if not gs.is_FiniteSet:
+            raise ValueError("Can not solve %s for %s" % (expr, self.value))
+        fx = self.compute_density(self.value)
+        fy = sum(fx(g) * abs(g.diff(y)) for g in gs)
+        return Lambda(y, fy)
+
+    def compute_quantile(self, expr, **kwargs):
+
+        if expr == self.value:
+            p = Dummy("p", real=True)
+            return Lambda(p, self.distribution.quantile(p, **kwargs))
+        else:
+            return ContinuousPSpace.compute_quantile(self, expr, **kwargs)
+
+def _reduce_inequalities(conditions, var, **kwargs):
+    try:
+        return reduce_rational_inequalities(conditions, var, **kwargs)
+    except PolynomialError:
+        raise ValueError("Reduction of condition failed %s\n" % conditions[0])
+
+
+def reduce_rational_inequalities_wrap(condition, var):
+    if condition.is_Relational:
+        return _reduce_inequalities([[condition]], var, relational=False)
+    if isinstance(condition, Or):
+        return Union(*[_reduce_inequalities([[arg]], var, relational=False)
+            for arg in condition.args])
+    if isinstance(condition, And):
+        intervals = [_reduce_inequalities([[arg]], var, relational=False)
+            for arg in condition.args]
+        I = intervals[0]
+        for i in intervals:
+            I = I.intersect(i)
+        return I

parrot/lib/python3.10/site-packages/sympy/stats/drv_types.py

@@ -0,0 +1,835 @@
+"""
+
+Contains
+========
+FlorySchulz
+Geometric
+Hermite
+Logarithmic
+NegativeBinomial
+Poisson
+Skellam
+YuleSimon
+Zeta
+"""
+
+
+
+from sympy.concrete.summations import Sum
+from sympy.core.basic import Basic
+from sympy.core.function import Lambda
+from sympy.core.numbers import I
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import (binomial, factorial)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.bessel import besseli
+from sympy.functions.special.beta_functions import beta
+from sympy.functions.special.hyper import hyper
+from sympy.functions.special.zeta_functions import (polylog, zeta)
+from sympy.stats.drv import SingleDiscreteDistribution, SingleDiscretePSpace
+from sympy.stats.rv import _value_check, is_random
+
+
+__all__ = ['FlorySchulz',
+'Geometric',
+'Hermite',
+'Logarithmic',
+'NegativeBinomial',
+'Poisson',
+'Skellam',
+'YuleSimon',
+'Zeta'
+]
+
+
+def rv(symbol, cls, *args, **kwargs):
+    args = list(map(sympify, args))
+    dist = cls(*args)
+    if kwargs.pop('check', True):
+        dist.check(*args)
+    pspace = SingleDiscretePSpace(symbol, dist)
+    if any(is_random(arg) for arg in args):
+        from sympy.stats.compound_rv import CompoundPSpace, CompoundDistribution
+        pspace = CompoundPSpace(symbol, CompoundDistribution(dist))
+    return pspace.value
+
+
+class DiscreteDistributionHandmade(SingleDiscreteDistribution):
+    _argnames = ('pdf',)
+
+    def __new__(cls, pdf, set=S.Integers):
+        return Basic.__new__(cls, pdf, set)
+
+    @property
+    def set(self):
+        return self.args[1]
+
+    @staticmethod
+    def check(pdf, set):
+        x = Dummy('x')
+        val = Sum(pdf(x), (x, set._inf, set._sup)).doit()
+        _value_check(Eq(val, 1) != S.false, "The pdf is incorrect on the given set.")
+
+
+
+def DiscreteRV(symbol, density, set=S.Integers, **kwargs):
+    """
+    Create a Discrete Random Variable given the following:
+
+    Parameters
+    ==========
+
+    symbol : Symbol
+        Represents name of the random variable.
+    density : Expression containing symbol
+        Represents probability density function.
+    set : set
+        Represents the region where the pdf is valid, by default is real line.
+    check : bool
+        If True, it will check whether the given density
+        integrates to 1 over the given set. If False, it
+        will not perform this check. Default is False.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import DiscreteRV, P, E
+    >>> from sympy import Rational, Symbol
+    >>> x = Symbol('x')
+    >>> n = 10
+    >>> density = Rational(1, 10)
+    >>> X = DiscreteRV(x, density, set=set(range(n)))
+    >>> E(X)
+    9/2
+    >>> P(X>3)
+    3/5
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    """
+    set = sympify(set)
+    pdf = Piecewise((density, set.as_relational(symbol)), (0, True))
+    pdf = Lambda(symbol, pdf)
+    # have a default of False while `rv` should have a default of True
+    kwargs['check'] = kwargs.pop('check', False)
+    return rv(symbol.name, DiscreteDistributionHandmade, pdf, set, **kwargs)
+
+
+#-------------------------------------------------------------------------------
+# Flory-Schulz distribution ------------------------------------------------------------
+
+class FlorySchulzDistribution(SingleDiscreteDistribution):
+    _argnames = ('a',)
+    set = S.Naturals
+
+    @staticmethod
+    def check(a):
+        _value_check((0 < a, a < 1), "a must be between 0 and 1")
+
+    def pdf(self, k):
+        a = self.a
+        return (a**2 * k * (1 - a)**(k - 1))
+
+    def _characteristic_function(self, t):
+        a = self.a
+        return a**2*exp(I*t)/((1 + (a - 1)*exp(I*t))**2)
+
+    def _moment_generating_function(self, t):
+        a = self.a
+        return a**2*exp(t)/((1 + (a - 1)*exp(t))**2)
+
+
+def FlorySchulz(name, a):
+    r"""
+    Create a discrete random variable with a FlorySchulz distribution.
+
+    The density of the FlorySchulz distribution is given by
+
+    .. math::
+        f(k) := (a^2) k (1 - a)^{k-1}
+
+    Parameters
+    ==========
+
+    a : A real number between 0 and 1
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density, E, variance, FlorySchulz
+    >>> from sympy import Symbol, S
+
+    >>> a = S.One / 5
+    >>> z = Symbol("z")
+
+    >>> X = FlorySchulz("x", a)
+
+    >>> density(X)(z)
+    (5/4)**(1 - z)*z/25
+
+    >>> E(X)
+    9
+
+    >>> variance(X)
+    40
+
+    References
+    ==========
+
+    https://en.wikipedia.org/wiki/Flory%E2%80%93Schulz_distribution
+    """
+    return rv(name, FlorySchulzDistribution, a)
+
+
+#-------------------------------------------------------------------------------
+# Geometric distribution ------------------------------------------------------------
+
+class GeometricDistribution(SingleDiscreteDistribution):
+    _argnames = ('p',)
+    set = S.Naturals
+
+    @staticmethod
+    def check(p):
+        _value_check((0 < p, p <= 1), "p must be between 0 and 1")
+
+    def pdf(self, k):
+        return (1 - self.p)**(k - 1) * self.p
+
+    def _characteristic_function(self, t):
+        p = self.p
+        return p * exp(I*t) / (1 - (1 - p)*exp(I*t))
+
+    def _moment_generating_function(self, t):
+        p = self.p
+        return p * exp(t) / (1 - (1 - p) * exp(t))
+
+
+def Geometric(name, p):
+    r"""
+    Create a discrete random variable with a Geometric distribution.
+
+    Explanation
+    ===========
+
+    The density of the Geometric distribution is given by
+
+    .. math::
+        f(k) := p (1 - p)^{k - 1}
+
+    Parameters
+    ==========
+
+    p : A probability between 0 and 1
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Geometric, density, E, variance
+    >>> from sympy import Symbol, S
+
+    >>> p = S.One / 5
+    >>> z = Symbol("z")
+
+    >>> X = Geometric("x", p)
+
+    >>> density(X)(z)
+    (5/4)**(1 - z)/5
+
+    >>> E(X)
+    5
+
+    >>> variance(X)
+    20
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Geometric_distribution
+    .. [2] https://mathworld.wolfram.com/GeometricDistribution.html
+
+    """
+    return rv(name, GeometricDistribution, p)
+
+
+#-------------------------------------------------------------------------------
+# Hermite distribution ---------------------------------------------------------
+
+
+class HermiteDistribution(SingleDiscreteDistribution):
+    _argnames = ('a1', 'a2')
+    set = S.Naturals0
+
+    @staticmethod
+    def check(a1, a2):
+        _value_check(a1.is_nonnegative, 'Parameter a1 must be >= 0.')
+        _value_check(a2.is_nonnegative, 'Parameter a2 must be >= 0.')
+
+    def pdf(self, k):
+        a1, a2 = self.a1, self.a2
+        term1 = exp(-(a1 + a2))
+        j = Dummy("j", integer=True)
+        num = a1**(k - 2*j) * a2**j
+        den = factorial(k - 2*j) * factorial(j)
+        return term1 * Sum(num/den, (j, 0, k//2)).doit()
+
+    def _moment_generating_function(self, t):
+        a1, a2 = self.a1, self.a2
+        term1 = a1 * (exp(t) - 1)
+        term2 = a2 * (exp(2*t) - 1)
+        return exp(term1 + term2)
+
+    def _characteristic_function(self, t):
+        a1, a2 = self.a1, self.a2
+        term1 = a1 * (exp(I*t) - 1)
+        term2 = a2 * (exp(2*I*t) - 1)
+        return exp(term1 + term2)
+
+def Hermite(name, a1, a2):
+    r"""
+    Create a discrete random variable with a Hermite distribution.
+
+    Explanation
+    ===========
+
+    The density of the Hermite distribution is given by
+
+    .. math::
+        f(x):= e^{-a_1 -a_2}\sum_{j=0}^{\left \lfloor x/2 \right \rfloor}
+                    \frac{a_{1}^{x-2j}a_{2}^{j}}{(x-2j)!j!}
+
+    Parameters
+    ==========
+
+    a1 : A Positive number greater than equal to 0.
+    a2 : A Positive number greater than equal to 0.
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Hermite, density, E, variance
+    >>> from sympy import Symbol
+
+    >>> a1 = Symbol("a1", positive=True)
+    >>> a2 = Symbol("a2", positive=True)
+    >>> x = Symbol("x")
+
+    >>> H = Hermite("H", a1=5, a2=4)
+
+    >>> density(H)(2)
+    33*exp(-9)/2
+
+    >>> E(H)
+    13
+
+    >>> variance(H)
+    21
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hermite_distribution
+
+    """
+
+    return rv(name, HermiteDistribution, a1, a2)
+
+
+#-------------------------------------------------------------------------------
+# Logarithmic distribution ------------------------------------------------------------
+
+class LogarithmicDistribution(SingleDiscreteDistribution):
+    _argnames = ('p',)
+
+    set = S.Naturals
+
+    @staticmethod
+    def check(p):
+        _value_check((p > 0, p < 1), "p should be between 0 and 1")
+
+    def pdf(self, k):
+        p = self.p
+        return (-1) * p**k / (k * log(1 - p))
+
+    def _characteristic_function(self, t):
+        p = self.p
+        return log(1 - p * exp(I*t)) / log(1 - p)
+
+    def _moment_generating_function(self, t):
+        p = self.p
+        return log(1 - p * exp(t)) / log(1 - p)
+
+
+def Logarithmic(name, p):
+    r"""
+    Create a discrete random variable with a Logarithmic distribution.
+
+    Explanation
+    ===========
+
+    The density of the Logarithmic distribution is given by
+
+    .. math::
+        f(k) := \frac{-p^k}{k \ln{(1 - p)}}
+
+    Parameters
+    ==========
+
+    p : A value between 0 and 1
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Logarithmic, density, E, variance
+    >>> from sympy import Symbol, S
+
+    >>> p = S.One / 5
+    >>> z = Symbol("z")
+
+    >>> X = Logarithmic("x", p)
+
+    >>> density(X)(z)
+    -1/(5**z*z*log(4/5))
+
+    >>> E(X)
+    -1/(-4*log(5) + 8*log(2))
+
+    >>> variance(X)
+    -1/((-4*log(5) + 8*log(2))*(-2*log(5) + 4*log(2))) + 1/(-64*log(2)*log(5) + 64*log(2)**2 + 16*log(5)**2) - 10/(-32*log(5) + 64*log(2))
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Logarithmic_distribution
+    .. [2] https://mathworld.wolfram.com/LogarithmicDistribution.html
+
+    """
+    return rv(name, LogarithmicDistribution, p)
+
+
+#-------------------------------------------------------------------------------
+# Negative binomial distribution ------------------------------------------------------------
+
+class NegativeBinomialDistribution(SingleDiscreteDistribution):
+    _argnames = ('r', 'p')
+    set = S.Naturals0
+
+    @staticmethod
+    def check(r, p):
+        _value_check(r > 0, 'r should be positive')
+        _value_check((p > 0, p < 1), 'p should be between 0 and 1')
+
+    def pdf(self, k):
+        r = self.r
+        p = self.p
+
+        return binomial(k + r - 1, k) * (1 - p)**r * p**k
+
+    def _characteristic_function(self, t):
+        r = self.r
+        p = self.p
+
+        return ((1 - p) / (1 - p * exp(I*t)))**r
+
+    def _moment_generating_function(self, t):
+        r = self.r
+        p = self.p
+
+        return ((1 - p) / (1 - p * exp(t)))**r
+
+def NegativeBinomial(name, r, p):
+    r"""
+    Create a discrete random variable with a Negative Binomial distribution.
+
+    Explanation
+    ===========
+
+    The density of the Negative Binomial distribution is given by
+
+    .. math::
+        f(k) := \binom{k + r - 1}{k} (1 - p)^r p^k
+
+    Parameters
+    ==========
+
+    r : A positive value
+    p : A value between 0 and 1
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import NegativeBinomial, density, E, variance
+    >>> from sympy import Symbol, S
+
+    >>> r = 5
+    >>> p = S.One / 5
+    >>> z = Symbol("z")
+
+    >>> X = NegativeBinomial("x", r, p)
+
+    >>> density(X)(z)
+    1024*binomial(z + 4, z)/(3125*5**z)
+
+    >>> E(X)
+    5/4
+
+    >>> variance(X)
+    25/16
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Negative_binomial_distribution
+    .. [2] https://mathworld.wolfram.com/NegativeBinomialDistribution.html
+
+    """
+    return rv(name, NegativeBinomialDistribution, r, p)
+
+
+#-------------------------------------------------------------------------------
+# Poisson distribution ------------------------------------------------------------
+
+class PoissonDistribution(SingleDiscreteDistribution):
+    _argnames = ('lamda',)
+
+    set = S.Naturals0
+
+    @staticmethod
+    def check(lamda):
+        _value_check(lamda > 0, "Lambda must be positive")
+
+    def pdf(self, k):
+        return self.lamda**k / factorial(k) * exp(-self.lamda)
+
+    def _characteristic_function(self, t):
+        return exp(self.lamda * (exp(I*t) - 1))
+
+    def _moment_generating_function(self, t):
+        return exp(self.lamda * (exp(t) - 1))
+
+
+def Poisson(name, lamda):
+    r"""
+    Create a discrete random variable with a Poisson distribution.
+
+    Explanation
+    ===========
+
+    The density of the Poisson distribution is given by
+
+    .. math::
+        f(k) := \frac{\lambda^{k} e^{- \lambda}}{k!}
+
+    Parameters
+    ==========
+
+    lamda : Positive number, a rate
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Poisson, density, E, variance
+    >>> from sympy import Symbol, simplify
+
+    >>> rate = Symbol("lambda", positive=True)
+    >>> z = Symbol("z")
+
+    >>> X = Poisson("x", rate)
+
+    >>> density(X)(z)
+    lambda**z*exp(-lambda)/factorial(z)
+
+    >>> E(X)
+    lambda
+
+    >>> simplify(variance(X))
+    lambda
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Poisson_distribution
+    .. [2] https://mathworld.wolfram.com/PoissonDistribution.html
+
+    """
+    return rv(name, PoissonDistribution, lamda)
+
+
+# -----------------------------------------------------------------------------
+# Skellam distribution --------------------------------------------------------
+
+
+class SkellamDistribution(SingleDiscreteDistribution):
+    _argnames = ('mu1', 'mu2')
+    set = S.Integers
+
+    @staticmethod
+    def check(mu1, mu2):
+        _value_check(mu1 >= 0, 'Parameter mu1 must be >= 0')
+        _value_check(mu2 >= 0, 'Parameter mu2 must be >= 0')
+
+    def pdf(self, k):
+        (mu1, mu2) = (self.mu1, self.mu2)
+        term1 = exp(-(mu1 + mu2)) * (mu1 / mu2) ** (k / 2)
+        term2 = besseli(k, 2 * sqrt(mu1 * mu2))
+        return term1 * term2
+
+    def _cdf(self, x):
+        raise NotImplementedError(
+            "Skellam doesn't have closed form for the CDF.")
+
+    def _characteristic_function(self, t):
+        (mu1, mu2) = (self.mu1, self.mu2)
+        return exp(-(mu1 + mu2) + mu1 * exp(I * t) + mu2 * exp(-I * t))
+
+    def _moment_generating_function(self, t):
+        (mu1, mu2) = (self.mu1, self.mu2)
+        return exp(-(mu1 + mu2) + mu1 * exp(t) + mu2 * exp(-t))
+
+
+def Skellam(name, mu1, mu2):
+    r"""
+    Create a discrete random variable with a Skellam distribution.
+
+    Explanation
+    ===========
+
+    The Skellam is the distribution of the difference N1 - N2
+    of two statistically independent random variables N1 and N2
+    each Poisson-distributed with respective expected values mu1 and mu2.
+
+    The density of the Skellam distribution is given by
+
+    .. math::
+        f(k) := e^{-(\mu_1+\mu_2)}(\frac{\mu_1}{\mu_2})^{k/2}I_k(2\sqrt{\mu_1\mu_2})
+
+    Parameters
+    ==========
+
+    mu1 : A non-negative value
+    mu2 : A non-negative value
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Skellam, density, E, variance
+    >>> from sympy import Symbol, pprint
+
+    >>> z = Symbol("z", integer=True)
+    >>> mu1 = Symbol("mu1", positive=True)
+    >>> mu2 = Symbol("mu2", positive=True)
+    >>> X = Skellam("x", mu1, mu2)
+
+    >>> pprint(density(X)(z), use_unicode=False)
+         z
+         -
+         2
+    /mu1\   -mu1 - mu2        /       _____   _____\
+    |---| *e          *besseli\z, 2*\/ mu1 *\/ mu2 /
+    \mu2/
+    >>> E(X)
+    mu1 - mu2
+    >>> variance(X).expand()
+    mu1 + mu2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Skellam_distribution
+
+    """
+    return rv(name, SkellamDistribution, mu1, mu2)
+
+
+#-------------------------------------------------------------------------------
+# Yule-Simon distribution ------------------------------------------------------------
+
+class YuleSimonDistribution(SingleDiscreteDistribution):
+    _argnames = ('rho',)
+    set = S.Naturals
+
+    @staticmethod
+    def check(rho):
+        _value_check(rho > 0, 'rho should be positive')
+
+    def pdf(self, k):
+        rho = self.rho
+        return rho * beta(k, rho + 1)
+
+    def _cdf(self, x):
+        return Piecewise((1 - floor(x) * beta(floor(x), self.rho + 1), x >= 1), (0, True))
+
+    def _characteristic_function(self, t):
+        rho = self.rho
+        return rho * hyper((1, 1), (rho + 2,), exp(I*t)) * exp(I*t) / (rho + 1)
+
+    def _moment_generating_function(self, t):
+        rho = self.rho
+        return rho * hyper((1, 1), (rho + 2,), exp(t)) * exp(t) / (rho + 1)
+
+
+def YuleSimon(name, rho):
+    r"""
+    Create a discrete random variable with a Yule-Simon distribution.
+
+    Explanation
+    ===========
+
+    The density of the Yule-Simon distribution is given by
+
+    .. math::
+        f(k) := \rho B(k, \rho + 1)
+
+    Parameters
+    ==========
+
+    rho : A positive value
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import YuleSimon, density, E, variance
+    >>> from sympy import Symbol, simplify
+
+    >>> p = 5
+    >>> z = Symbol("z")
+
+    >>> X = YuleSimon("x", p)
+
+    >>> density(X)(z)
+    5*beta(z, 6)
+
+    >>> simplify(E(X))
+    5/4
+
+    >>> simplify(variance(X))
+    25/48
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Yule%E2%80%93Simon_distribution
+
+    """
+    return rv(name, YuleSimonDistribution, rho)
+
+
+#-------------------------------------------------------------------------------
+# Zeta distribution ------------------------------------------------------------
+
+class ZetaDistribution(SingleDiscreteDistribution):
+    _argnames = ('s',)
+    set = S.Naturals
+
+    @staticmethod
+    def check(s):
+        _value_check(s > 1, 's should be greater than 1')
+
+    def pdf(self, k):
+        s = self.s
+        return 1 / (k**s * zeta(s))
+
+    def _characteristic_function(self, t):
+        return polylog(self.s, exp(I*t)) / zeta(self.s)
+
+    def _moment_generating_function(self, t):
+        return polylog(self.s, exp(t)) / zeta(self.s)
+
+
+def Zeta(name, s):
+    r"""
+    Create a discrete random variable with a Zeta distribution.
+
+    Explanation
+    ===========
+
+    The density of the Zeta distribution is given by
+
+    .. math::
+        f(k) := \frac{1}{k^s \zeta{(s)}}
+
+    Parameters
+    ==========
+
+    s : A value greater than 1
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Zeta, density, E, variance
+    >>> from sympy import Symbol
+
+    >>> s = 5
+    >>> z = Symbol("z")
+
+    >>> X = Zeta("x", s)
+
+    >>> density(X)(z)
+    1/(z**5*zeta(5))
+
+    >>> E(X)
+    pi**4/(90*zeta(5))
+
+    >>> variance(X)
+    -pi**8/(8100*zeta(5)**2) + zeta(3)/zeta(5)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Zeta_distribution
+
+    """
+    return rv(name, ZetaDistribution, s)

parrot/lib/python3.10/site-packages/sympy/stats/joint_rv.py

@@ -0,0 +1,426 @@
+"""
+Joint Random Variables Module
+
+See Also
+========
+sympy.stats.rv
+sympy.stats.frv
+sympy.stats.crv
+sympy.stats.drv
+"""
+from math import prod
+
+from sympy.core.basic import Basic
+from sympy.core.function import Lambda
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol)
+from sympy.core.sympify import sympify
+from sympy.sets.sets import ProductSet
+from sympy.tensor.indexed import Indexed
+from sympy.concrete.products import Product
+from sympy.concrete.summations import Sum, summation
+from sympy.core.containers import Tuple
+from sympy.integrals.integrals import Integral, integrate
+from sympy.matrices import ImmutableMatrix, matrix2numpy, list2numpy
+from sympy.stats.crv import SingleContinuousDistribution, SingleContinuousPSpace
+from sympy.stats.drv import SingleDiscreteDistribution, SingleDiscretePSpace
+from sympy.stats.rv import (ProductPSpace, NamedArgsMixin, Distribution,
+                            ProductDomain, RandomSymbol, random_symbols,
+                            SingleDomain, _symbol_converter)
+from sympy.utilities.iterables import iterable
+from sympy.utilities.misc import filldedent
+from sympy.external import import_module
+
+# __all__ = ['marginal_distribution']
+
+class JointPSpace(ProductPSpace):
+    """
+    Represents a joint probability space. Represented using symbols for
+    each component and a distribution.
+    """
+    def __new__(cls, sym, dist):
+        if isinstance(dist, SingleContinuousDistribution):
+            return SingleContinuousPSpace(sym, dist)
+        if isinstance(dist, SingleDiscreteDistribution):
+            return SingleDiscretePSpace(sym, dist)
+        sym = _symbol_converter(sym)
+        return Basic.__new__(cls, sym, dist)
+
+    @property
+    def set(self):
+        return self.domain.set
+
+    @property
+    def symbol(self):
+        return self.args[0]
+
+    @property
+    def distribution(self):
+        return self.args[1]
+
+    @property
+    def value(self):
+        return JointRandomSymbol(self.symbol, self)
+
+    @property
+    def component_count(self):
+        _set = self.distribution.set
+        if isinstance(_set, ProductSet):
+            return S(len(_set.args))
+        elif isinstance(_set, Product):
+            return _set.limits[0][-1]
+        return S.One
+
+    @property
+    def pdf(self):
+        sym = [Indexed(self.symbol, i) for i in range(self.component_count)]
+        return self.distribution(*sym)
+
+    @property
+    def domain(self):
+        rvs = random_symbols(self.distribution)
+        if not rvs:
+            return SingleDomain(self.symbol, self.distribution.set)
+        return ProductDomain(*[rv.pspace.domain for rv in rvs])
+
+    def component_domain(self, index):
+        return self.set.args[index]
+
+    def marginal_distribution(self, *indices):
+        count = self.component_count
+        if count.atoms(Symbol):
+            raise ValueError("Marginal distributions cannot be computed "
+                                "for symbolic dimensions. It is a work under progress.")
+        orig = [Indexed(self.symbol, i) for i in range(count)]
+        all_syms = [Symbol(str(i)) for i in orig]
+        replace_dict = dict(zip(all_syms, orig))
+        sym = tuple(Symbol(str(Indexed(self.symbol, i))) for i in indices)
+        limits = [[i,] for i in all_syms if i not in sym]
+        index = 0
+        for i in range(count):
+            if i not in indices:
+                limits[index].append(self.distribution.set.args[i])
+                limits[index] = tuple(limits[index])
+                index += 1
+        if self.distribution.is_Continuous:
+            f = Lambda(sym, integrate(self.distribution(*all_syms), *limits))
+        elif self.distribution.is_Discrete:
+            f = Lambda(sym, summation(self.distribution(*all_syms), *limits))
+        return f.xreplace(replace_dict)
+
+    def compute_expectation(self, expr, rvs=None, evaluate=False, **kwargs):
+        syms = tuple(self.value[i] for i in range(self.component_count))
+        rvs = rvs or syms
+        if not any(i in rvs for i in syms):
+            return expr
+        expr = expr*self.pdf
+        for rv in rvs:
+            if isinstance(rv, Indexed):
+                expr = expr.xreplace({rv: Indexed(str(rv.base), rv.args[1])})
+            elif isinstance(rv, RandomSymbol):
+                expr = expr.xreplace({rv: rv.symbol})
+        if self.value in random_symbols(expr):
+            raise NotImplementedError(filldedent('''
+            Expectations of expression with unindexed joint random symbols
+            cannot be calculated yet.'''))
+        limits = tuple((Indexed(str(rv.base),rv.args[1]),
+            self.distribution.set.args[rv.args[1]]) for rv in syms)
+        return Integral(expr, *limits)
+
+    def where(self, condition):
+        raise NotImplementedError()
+
+    def compute_density(self, expr):
+        raise NotImplementedError()
+
+    def sample(self, size=(), library='scipy', seed=None):
+        """
+        Internal sample method
+
+        Returns dictionary mapping RandomSymbol to realization value.
+        """
+        return {RandomSymbol(self.symbol, self): self.distribution.sample(size,
+                    library=library, seed=seed)}
+
+    def probability(self, condition):
+        raise NotImplementedError()
+
+
+class SampleJointScipy:
+    """Returns the sample from scipy of the given distribution"""
+    def __new__(cls, dist, size, seed=None):
+        return cls._sample_scipy(dist, size, seed)
+
+    @classmethod
+    def _sample_scipy(cls, dist, size, seed):
+        """Sample from SciPy."""
+
+        import numpy
+        if seed is None or isinstance(seed, int):
+            rand_state = numpy.random.default_rng(seed=seed)
+        else:
+            rand_state = seed
+        from scipy import stats as scipy_stats
+        scipy_rv_map = {
+            'MultivariateNormalDistribution': lambda dist, size: scipy_stats.multivariate_normal.rvs(
+                mean=matrix2numpy(dist.mu).flatten(),
+                cov=matrix2numpy(dist.sigma), size=size, random_state=rand_state),
+            'MultivariateBetaDistribution': lambda dist, size: scipy_stats.dirichlet.rvs(
+                alpha=list2numpy(dist.alpha, float).flatten(), size=size, random_state=rand_state),
+            'MultinomialDistribution': lambda dist, size: scipy_stats.multinomial.rvs(
+                n=int(dist.n), p=list2numpy(dist.p, float).flatten(), size=size, random_state=rand_state)
+        }
+
+        sample_shape = {
+            'MultivariateNormalDistribution': lambda dist: matrix2numpy(dist.mu).flatten().shape,
+            'MultivariateBetaDistribution': lambda dist: list2numpy(dist.alpha).flatten().shape,
+            'MultinomialDistribution': lambda dist: list2numpy(dist.p).flatten().shape
+        }
+
+        dist_list = scipy_rv_map.keys()
+
+        if dist.__class__.__name__ not in dist_list:
+            return None
+
+        samples = scipy_rv_map[dist.__class__.__name__](dist, size)
+        return samples.reshape(size + sample_shape[dist.__class__.__name__](dist))
+
+class SampleJointNumpy:
+    """Returns the sample from numpy of the given distribution"""
+
+    def __new__(cls, dist, size, seed=None):
+        return cls._sample_numpy(dist, size, seed)
+
+    @classmethod
+    def _sample_numpy(cls, dist, size, seed):
+        """Sample from NumPy."""
+
+        import numpy
+        if seed is None or isinstance(seed, int):
+            rand_state = numpy.random.default_rng(seed=seed)
+        else:
+            rand_state = seed
+        numpy_rv_map = {
+            'MultivariateNormalDistribution': lambda dist, size: rand_state.multivariate_normal(
+                mean=matrix2numpy(dist.mu, float).flatten(),
+                cov=matrix2numpy(dist.sigma, float), size=size),
+            'MultivariateBetaDistribution': lambda dist, size: rand_state.dirichlet(
+                alpha=list2numpy(dist.alpha, float).flatten(), size=size),
+            'MultinomialDistribution': lambda dist, size: rand_state.multinomial(
+                n=int(dist.n), pvals=list2numpy(dist.p, float).flatten(), size=size)
+        }
+
+        sample_shape = {
+            'MultivariateNormalDistribution': lambda dist: matrix2numpy(dist.mu).flatten().shape,
+            'MultivariateBetaDistribution': lambda dist: list2numpy(dist.alpha).flatten().shape,
+            'MultinomialDistribution': lambda dist: list2numpy(dist.p).flatten().shape
+        }
+
+        dist_list = numpy_rv_map.keys()
+
+        if dist.__class__.__name__ not in dist_list:
+            return None
+
+        samples = numpy_rv_map[dist.__class__.__name__](dist, prod(size))
+        return samples.reshape(size + sample_shape[dist.__class__.__name__](dist))
+
+class SampleJointPymc:
+    """Returns the sample from pymc of the given distribution"""
+
+    def __new__(cls, dist, size, seed=None):
+        return cls._sample_pymc(dist, size, seed)
+
+    @classmethod
+    def _sample_pymc(cls, dist, size, seed):
+        """Sample from PyMC."""
+
+        try:
+            import pymc
+        except ImportError:
+            import pymc3 as pymc
+        pymc_rv_map = {
+            'MultivariateNormalDistribution': lambda dist:
+                pymc.MvNormal('X', mu=matrix2numpy(dist.mu, float).flatten(),
+                cov=matrix2numpy(dist.sigma, float), shape=(1, dist.mu.shape[0])),
+            'MultivariateBetaDistribution': lambda dist:
+                pymc.Dirichlet('X', a=list2numpy(dist.alpha, float).flatten()),
+            'MultinomialDistribution': lambda dist:
+                pymc.Multinomial('X', n=int(dist.n),
+                p=list2numpy(dist.p, float).flatten(), shape=(1, len(dist.p)))
+        }
+
+        sample_shape = {
+            'MultivariateNormalDistribution': lambda dist: matrix2numpy(dist.mu).flatten().shape,
+            'MultivariateBetaDistribution': lambda dist: list2numpy(dist.alpha).flatten().shape,
+            'MultinomialDistribution': lambda dist: list2numpy(dist.p).flatten().shape
+        }
+
+        dist_list = pymc_rv_map.keys()
+
+        if dist.__class__.__name__ not in dist_list:
+            return None
+
+        import logging
+        logging.getLogger("pymc3").setLevel(logging.ERROR)
+        with pymc.Model():
+            pymc_rv_map[dist.__class__.__name__](dist)
+            samples = pymc.sample(draws=prod(size), chains=1, progressbar=False, random_seed=seed, return_inferencedata=False, compute_convergence_checks=False)[:]['X']
+        return samples.reshape(size + sample_shape[dist.__class__.__name__](dist))
+
+
+_get_sample_class_jrv = {
+    'scipy': SampleJointScipy,
+    'pymc3': SampleJointPymc,
+    'pymc': SampleJointPymc,
+    'numpy': SampleJointNumpy
+}
+
+class JointDistribution(Distribution, NamedArgsMixin):
+    """
+    Represented by the random variables part of the joint distribution.
+    Contains methods for PDF, CDF, sampling, marginal densities, etc.
+    """
+
+    _argnames = ('pdf', )
+
+    def __new__(cls, *args):
+        args = list(map(sympify, args))
+        for i in range(len(args)):
+            if isinstance(args[i], list):
+                args[i] = ImmutableMatrix(args[i])
+        return Basic.__new__(cls, *args)
+
+    @property
+    def domain(self):
+        return ProductDomain(self.symbols)
+
+    @property
+    def pdf(self):
+        return self.density.args[1]
+
+    def cdf(self, other):
+        if not isinstance(other, dict):
+            raise ValueError("%s should be of type dict, got %s"%(other, type(other)))
+        rvs = other.keys()
+        _set = self.domain.set.sets
+        expr = self.pdf(tuple(i.args[0] for i in self.symbols))
+        for i in range(len(other)):
+            if rvs[i].is_Continuous:
+                density = Integral(expr, (rvs[i], _set[i].inf,
+                    other[rvs[i]]))
+            elif rvs[i].is_Discrete:
+                density = Sum(expr, (rvs[i], _set[i].inf,
+                    other[rvs[i]]))
+        return density
+
+    def sample(self, size=(), library='scipy', seed=None):
+        """ A random realization from the distribution """
+
+        libraries = ('scipy', 'numpy', 'pymc3', 'pymc')
+        if library not in libraries:
+            raise NotImplementedError("Sampling from %s is not supported yet."
+                                        % str(library))
+        if not import_module(library):
+            raise ValueError("Failed to import %s" % library)
+
+        samps = _get_sample_class_jrv[library](self, size, seed=seed)
+
+        if samps is not None:
+            return samps
+        raise NotImplementedError(
+                "Sampling for %s is not currently implemented from %s"
+                % (self.__class__.__name__, library)
+                )
+
+    def __call__(self, *args):
+        return self.pdf(*args)
+
+class JointRandomSymbol(RandomSymbol):
+    """
+    Representation of random symbols with joint probability distributions
+    to allow indexing."
+    """
+    def __getitem__(self, key):
+        if isinstance(self.pspace, JointPSpace):
+            if (self.pspace.component_count <= key) == True:
+                raise ValueError("Index keys for %s can only up to %s." %
+                    (self.name, self.pspace.component_count - 1))
+            return Indexed(self, key)
+
+
+
+class MarginalDistribution(Distribution):
+    """
+    Represents the marginal distribution of a joint probability space.
+
+    Initialised using a probability distribution and random variables(or
+    their indexed components) which should be a part of the resultant
+    distribution.
+    """
+
+    def __new__(cls, dist, *rvs):
+        if len(rvs) == 1 and iterable(rvs[0]):
+            rvs = tuple(rvs[0])
+        if not all(isinstance(rv, (Indexed, RandomSymbol)) for rv in rvs):
+            raise ValueError(filldedent('''Marginal distribution can be
+             intitialised only in terms of random variables or indexed random
+             variables'''))
+        rvs = Tuple.fromiter(rv for rv in rvs)
+        if not isinstance(dist, JointDistribution) and len(random_symbols(dist)) == 0:
+            return dist
+        return Basic.__new__(cls, dist, rvs)
+
+    def check(self):
+        pass
+
+    @property
+    def set(self):
+        rvs = [i for i in self.args[1] if isinstance(i, RandomSymbol)]
+        return ProductSet(*[rv.pspace.set for rv in rvs])
+
+    @property
+    def symbols(self):
+        rvs = self.args[1]
+        return {rv.pspace.symbol for rv in rvs}
+
+    def pdf(self, *x):
+        expr, rvs = self.args[0], self.args[1]
+        marginalise_out = [i for i in random_symbols(expr) if i not in rvs]
+        if isinstance(expr, JointDistribution):
+            count = len(expr.domain.args)
+            x = Dummy('x', real=True)
+            syms = tuple(Indexed(x, i) for i in count)
+            expr = expr.pdf(syms)
+        else:
+            syms = tuple(rv.pspace.symbol if isinstance(rv, RandomSymbol) else rv.args[0] for rv in rvs)
+        return Lambda(syms, self.compute_pdf(expr, marginalise_out))(*x)
+
+    def compute_pdf(self, expr, rvs):
+        for rv in rvs:
+            lpdf = 1
+            if isinstance(rv, RandomSymbol):
+                lpdf = rv.pspace.pdf
+            expr = self.marginalise_out(expr*lpdf, rv)
+        return expr
+
+    def marginalise_out(self, expr, rv):
+        from sympy.concrete.summations import Sum
+        if isinstance(rv, RandomSymbol):
+            dom = rv.pspace.set
+        elif isinstance(rv, Indexed):
+            dom = rv.base.component_domain(
+                rv.pspace.component_domain(rv.args[1]))
+        expr = expr.xreplace({rv: rv.pspace.symbol})
+        if rv.pspace.is_Continuous:
+            #TODO: Modify to support integration
+            #for all kinds of sets.
+            expr = Integral(expr, (rv.pspace.symbol, dom))
+        elif rv.pspace.is_Discrete:
+            #incorporate this into `Sum`/`summation`
+            if dom in (S.Integers, S.Naturals, S.Naturals0):
+                dom = (dom.inf, dom.sup)
+            expr = Sum(expr, (rv.pspace.symbol, dom))
+        return expr
+
+    def __call__(self, *args):
+        return self.pdf(*args)

parrot/lib/python3.10/site-packages/sympy/stats/joint_rv_types.py

@@ -0,0 +1,945 @@
+from sympy.concrete.products import Product
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.function import Lambda
+from sympy.core.mul import Mul
+from sympy.core.numbers import (Integer, Rational, pi)
+from sympy.core.power import Pow
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import (rf, factorial)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.bessel import besselk
+from sympy.functions.special.gamma_functions import gamma
+from sympy.matrices.dense import (Matrix, ones)
+from sympy.sets.fancysets import Range
+from sympy.sets.sets import (Intersection, Interval)
+from sympy.tensor.indexed import (Indexed, IndexedBase)
+from sympy.matrices import ImmutableMatrix, MatrixSymbol
+from sympy.matrices.expressions.determinant import det
+from sympy.matrices.expressions.matexpr import MatrixElement
+from sympy.stats.joint_rv import JointDistribution, JointPSpace, MarginalDistribution
+from sympy.stats.rv import _value_check, random_symbols
+
+__all__ = ['JointRV',
+'MultivariateNormal',
+'MultivariateLaplace',
+'Dirichlet',
+'GeneralizedMultivariateLogGamma',
+'GeneralizedMultivariateLogGammaOmega',
+'Multinomial',
+'MultivariateBeta',
+'MultivariateEwens',
+'MultivariateT',
+'NegativeMultinomial',
+'NormalGamma'
+]
+
+def multivariate_rv(cls, sym, *args):
+    args = list(map(sympify, args))
+    dist = cls(*args)
+    args = dist.args
+    dist.check(*args)
+    return JointPSpace(sym, dist).value
+
+
+def marginal_distribution(rv, *indices):
+    """
+    Marginal distribution function of a joint random variable.
+
+    Parameters
+    ==========
+
+    rv : A random variable with a joint probability distribution.
+    indices : Component indices or the indexed random symbol
+        for which the joint distribution is to be calculated
+
+    Returns
+    =======
+
+    A Lambda expression in `sym`.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import MultivariateNormal, marginal_distribution
+    >>> m = MultivariateNormal('X', [1, 2], [[2, 1], [1, 2]])
+    >>> marginal_distribution(m, m[0])(1)
+    1/(2*sqrt(pi))
+
+    """
+    indices = list(indices)
+    for i in range(len(indices)):
+        if isinstance(indices[i], Indexed):
+            indices[i] = indices[i].args[1]
+    prob_space = rv.pspace
+    if not indices:
+        raise ValueError(
+            "At least one component for marginal density is needed.")
+    if hasattr(prob_space.distribution, '_marginal_distribution'):
+        return prob_space.distribution._marginal_distribution(indices, rv.symbol)
+    return prob_space.marginal_distribution(*indices)
+
+
+class JointDistributionHandmade(JointDistribution):
+
+    _argnames = ('pdf',)
+    is_Continuous = True
+
+    @property
+    def set(self):
+        return self.args[1]
+
+
+def JointRV(symbol, pdf, _set=None):
+    """
+    Create a Joint Random Variable where each of its component is continuous,
+    given the following:
+
+    Parameters
+    ==========
+
+    symbol : Symbol
+        Represents name of the random variable.
+    pdf : A PDF in terms of indexed symbols of the symbol given
+        as the first argument
+
+    NOTE
+    ====
+
+    As of now, the set for each component for a ``JointRV`` is
+    equal to the set of all integers, which cannot be changed.
+
+    Examples
+    ========
+
+    >>> from sympy import exp, pi, Indexed, S
+    >>> from sympy.stats import density, JointRV
+    >>> x1, x2 = (Indexed('x', i) for i in (1, 2))
+    >>> pdf = exp(-x1**2/2 + x1 - x2**2/2 - S(1)/2)/(2*pi)
+    >>> N1 = JointRV('x', pdf) #Multivariate Normal distribution
+    >>> density(N1)(1, 2)
+    exp(-2)/(2*pi)
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    """
+    #TODO: Add support for sets provided by the user
+    symbol = sympify(symbol)
+    syms = [i for i in pdf.free_symbols if isinstance(i, Indexed)
+        and i.base == IndexedBase(symbol)]
+    syms = tuple(sorted(syms, key = lambda index: index.args[1]))
+    _set = S.Reals**len(syms)
+    pdf = Lambda(syms, pdf)
+    dist = JointDistributionHandmade(pdf, _set)
+    jrv = JointPSpace(symbol, dist).value
+    rvs = random_symbols(pdf)
+    if len(rvs) != 0:
+        dist = MarginalDistribution(dist, (jrv,))
+        return JointPSpace(symbol, dist).value
+    return jrv
+
+#-------------------------------------------------------------------------------
+# Multivariate Normal distribution ---------------------------------------------
+
+class MultivariateNormalDistribution(JointDistribution):
+    _argnames = ('mu', 'sigma')
+
+    is_Continuous=True
+
+    @property
+    def set(self):
+        k = self.mu.shape[0]
+        return S.Reals**k
+
+    @staticmethod
+    def check(mu, sigma):
+        _value_check(mu.shape[0] == sigma.shape[0],
+            "Size of the mean vector and covariance matrix are incorrect.")
+        #check if covariance matrix is positive semi definite or not.
+        if not isinstance(sigma, MatrixSymbol):
+            _value_check(sigma.is_positive_semidefinite,
+            "The covariance matrix must be positive semi definite. ")
+
+    def pdf(self, *args):
+        mu, sigma = self.mu, self.sigma
+        k = mu.shape[0]
+        if len(args) == 1 and args[0].is_Matrix:
+            args = args[0]
+        else:
+            args = ImmutableMatrix(args)
+        x = args - mu
+        density = S.One/sqrt((2*pi)**(k)*det(sigma))*exp(
+            Rational(-1, 2)*x.transpose()*(sigma.inv()*x))
+        return MatrixElement(density, 0, 0)
+
+    def _marginal_distribution(self, indices, sym):
+        sym = ImmutableMatrix([Indexed(sym, i) for i in indices])
+        _mu, _sigma = self.mu, self.sigma
+        k = self.mu.shape[0]
+        for i in range(k):
+            if i not in indices:
+                _mu = _mu.row_del(i)
+                _sigma = _sigma.col_del(i)
+                _sigma = _sigma.row_del(i)
+        return Lambda(tuple(sym), S.One/sqrt((2*pi)**(len(_mu))*det(_sigma))*exp(
+            Rational(-1, 2)*(_mu - sym).transpose()*(_sigma.inv()*\
+                (_mu - sym)))[0])
+
+def MultivariateNormal(name, mu, sigma):
+    r"""
+    Creates a continuous random variable with Multivariate Normal
+    Distribution.
+
+    The density of the multivariate normal distribution can be found at [1].
+
+    Parameters
+    ==========
+
+    mu : List representing the mean or the mean vector
+    sigma : Positive semidefinite square matrix
+        Represents covariance Matrix.
+        If `\sigma` is noninvertible then only sampling is supported currently
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import MultivariateNormal, density, marginal_distribution
+    >>> from sympy import symbols, MatrixSymbol
+    >>> X = MultivariateNormal('X', [3, 4], [[2, 1], [1, 2]])
+    >>> y, z = symbols('y z')
+    >>> density(X)(y, z)
+    sqrt(3)*exp(-y**2/3 + y*z/3 + 2*y/3 - z**2/3 + 5*z/3 - 13/3)/(6*pi)
+    >>> density(X)(1, 2)
+    sqrt(3)*exp(-4/3)/(6*pi)
+    >>> marginal_distribution(X, X[1])(y)
+    exp(-(y - 4)**2/4)/(2*sqrt(pi))
+    >>> marginal_distribution(X, X[0])(y)
+    exp(-(y - 3)**2/4)/(2*sqrt(pi))
+
+    The example below shows that it is also possible to use
+    symbolic parameters to define the MultivariateNormal class.
+
+    >>> n = symbols('n', integer=True, positive=True)
+    >>> Sg = MatrixSymbol('Sg', n, n)
+    >>> mu = MatrixSymbol('mu', n, 1)
+    >>> obs = MatrixSymbol('obs', n, 1)
+    >>> X = MultivariateNormal('X', mu, Sg)
+
+    The density of a multivariate normal can be
+    calculated using a matrix argument, as shown below.
+
+    >>> density(X)(obs)
+    (exp(((1/2)*mu.T - (1/2)*obs.T)*Sg**(-1)*(-mu + obs))/sqrt((2*pi)**n*Determinant(Sg)))[0, 0]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Multivariate_normal_distribution
+
+    """
+    return multivariate_rv(MultivariateNormalDistribution, name, mu, sigma)
+
+#-------------------------------------------------------------------------------
+# Multivariate Laplace distribution --------------------------------------------
+
+class MultivariateLaplaceDistribution(JointDistribution):
+    _argnames = ('mu', 'sigma')
+    is_Continuous=True
+
+    @property
+    def set(self):
+        k = self.mu.shape[0]
+        return S.Reals**k
+
+    @staticmethod
+    def check(mu, sigma):
+        _value_check(mu.shape[0] == sigma.shape[0],
+                     "Size of the mean vector and covariance matrix are incorrect.")
+        # check if covariance matrix is positive definite or not.
+        if not isinstance(sigma, MatrixSymbol):
+            _value_check(sigma.is_positive_definite,
+                         "The covariance matrix must be positive definite. ")
+
+    def pdf(self, *args):
+        mu, sigma = self.mu, self.sigma
+        mu_T = mu.transpose()
+        k = S(mu.shape[0])
+        sigma_inv = sigma.inv()
+        args = ImmutableMatrix(args)
+        args_T = args.transpose()
+        x = (mu_T*sigma_inv*mu)[0]
+        y = (args_T*sigma_inv*args)[0]
+        v = 1 - k/2
+        return (2 * (y/(2 + x))**(v/2) * besselk(v, sqrt((2 + x)*y)) *
+                exp((args_T * sigma_inv * mu)[0]) /
+                ((2 * pi)**(k/2) * sqrt(det(sigma))))
+
+
+def MultivariateLaplace(name, mu, sigma):
+    """
+    Creates a continuous random variable with Multivariate Laplace
+    Distribution.
+
+    The density of the multivariate Laplace distribution can be found at [1].
+
+    Parameters
+    ==========
+
+    mu : List representing the mean or the mean vector
+    sigma : Positive definite square matrix
+        Represents covariance Matrix
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import MultivariateLaplace, density
+    >>> from sympy import symbols
+    >>> y, z = symbols('y z')
+    >>> X = MultivariateLaplace('X', [2, 4], [[3, 1], [1, 3]])
+    >>> density(X)(y, z)
+    sqrt(2)*exp(y/4 + 5*z/4)*besselk(0, sqrt(15*y*(3*y/8 - z/8)/2 + 15*z*(-y/8 + 3*z/8)/2))/(4*pi)
+    >>> density(X)(1, 2)
+    sqrt(2)*exp(11/4)*besselk(0, sqrt(165)/4)/(4*pi)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Multivariate_Laplace_distribution
+
+    """
+    return multivariate_rv(MultivariateLaplaceDistribution, name, mu, sigma)
+
+#-------------------------------------------------------------------------------
+# Multivariate StudentT distribution -------------------------------------------
+
+class MultivariateTDistribution(JointDistribution):
+    _argnames = ('mu', 'shape_mat', 'dof')
+    is_Continuous=True
+
+    @property
+    def set(self):
+        k = self.mu.shape[0]
+        return S.Reals**k
+
+    @staticmethod
+    def check(mu, sigma, v):
+        _value_check(mu.shape[0] == sigma.shape[0],
+                     "Size of the location vector and shape matrix are incorrect.")
+        # check if covariance matrix is positive definite or not.
+        if not isinstance(sigma, MatrixSymbol):
+            _value_check(sigma.is_positive_definite,
+                         "The shape matrix must be positive definite. ")
+
+    def pdf(self, *args):
+        mu, sigma = self.mu, self.shape_mat
+        v = S(self.dof)
+        k = S(mu.shape[0])
+        sigma_inv = sigma.inv()
+        args = ImmutableMatrix(args)
+        x = args - mu
+        return gamma((k + v)/2)/(gamma(v/2)*(v*pi)**(k/2)*sqrt(det(sigma)))\
+        *(1 + 1/v*(x.transpose()*sigma_inv*x)[0])**((-v - k)/2)
+
+def MultivariateT(syms, mu, sigma, v):
+    """
+    Creates a joint random variable with multivariate T-distribution.
+
+    Parameters
+    ==========
+
+    syms : A symbol/str
+        For identifying the random variable.
+    mu : A list/matrix
+        Representing the location vector
+    sigma : The shape matrix for the distribution
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density, MultivariateT
+    >>> from sympy import Symbol
+
+    >>> x = Symbol("x")
+    >>> X = MultivariateT("x", [1, 1], [[1, 0], [0, 1]], 2)
+
+    >>> density(X)(1, 2)
+    2/(9*pi)
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    """
+    return multivariate_rv(MultivariateTDistribution, syms, mu, sigma, v)
+
+
+#-------------------------------------------------------------------------------
+# Multivariate Normal Gamma distribution ---------------------------------------
+
+class NormalGammaDistribution(JointDistribution):
+
+    _argnames = ('mu', 'lamda', 'alpha', 'beta')
+    is_Continuous=True
+
+    @staticmethod
+    def check(mu, lamda, alpha, beta):
+        _value_check(mu.is_real, "Location must be real.")
+        _value_check(lamda > 0, "Lambda must be positive")
+        _value_check(alpha > 0, "alpha must be positive")
+        _value_check(beta > 0, "beta must be positive")
+
+    @property
+    def set(self):
+        return S.Reals*Interval(0, S.Infinity)
+
+    def pdf(self, x, tau):
+        beta, alpha, lamda = self.beta, self.alpha, self.lamda
+        mu = self.mu
+
+        return beta**alpha*sqrt(lamda)/(gamma(alpha)*sqrt(2*pi))*\
+        tau**(alpha - S.Half)*exp(-1*beta*tau)*\
+        exp(-1*(lamda*tau*(x - mu)**2)/S(2))
+
+    def _marginal_distribution(self, indices, *sym):
+        if len(indices) == 2:
+            return self.pdf(*sym)
+        if indices[0] == 0:
+            #For marginal over `x`, return non-standardized Student-T's
+            #distribution
+            x = sym[0]
+            v, mu, sigma = self.alpha - S.Half, self.mu, \
+                S(self.beta)/(self.lamda * self.alpha)
+            return Lambda(sym, gamma((v + 1)/2)/(gamma(v/2)*sqrt(pi*v)*sigma)*\
+                (1 + 1/v*((x - mu)/sigma)**2)**((-v -1)/2))
+        #For marginal over `tau`, return Gamma distribution as per construction
+        from sympy.stats.crv_types import GammaDistribution
+        return Lambda(sym, GammaDistribution(self.alpha, self.beta)(sym[0]))
+
+def NormalGamma(sym, mu, lamda, alpha, beta):
+    """
+    Creates a bivariate joint random variable with multivariate Normal gamma
+    distribution.
+
+    Parameters
+    ==========
+
+    sym : A symbol/str
+        For identifying the random variable.
+    mu : A real number
+        The mean of the normal distribution
+    lamda : A positive integer
+        Parameter of joint distribution
+    alpha : A positive integer
+        Parameter of joint distribution
+    beta : A positive integer
+        Parameter of joint distribution
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density, NormalGamma
+    >>> from sympy import symbols
+
+    >>> X = NormalGamma('x', 0, 1, 2, 3)
+    >>> y, z = symbols('y z')
+
+    >>> density(X)(y, z)
+    9*sqrt(2)*z**(3/2)*exp(-3*z)*exp(-y**2*z/2)/(2*sqrt(pi))
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Normal-gamma_distribution
+
+    """
+    return multivariate_rv(NormalGammaDistribution, sym, mu, lamda, alpha, beta)
+
+#-------------------------------------------------------------------------------
+# Multivariate Beta/Dirichlet distribution -------------------------------------
+
+class MultivariateBetaDistribution(JointDistribution):
+
+    _argnames = ('alpha',)
+    is_Continuous = True
+
+    @staticmethod
+    def check(alpha):
+        _value_check(len(alpha) >= 2, "At least two categories should be passed.")
+        for a_k in alpha:
+            _value_check((a_k > 0) != False, "Each concentration parameter"
+                                            " should be positive.")
+
+    @property
+    def set(self):
+        k = len(self.alpha)
+        return Interval(0, 1)**k
+
+    def pdf(self, *syms):
+        alpha = self.alpha
+        B = Mul.fromiter(map(gamma, alpha))/gamma(Add(*alpha))
+        return Mul.fromiter(sym**(a_k - 1) for a_k, sym in zip(alpha, syms))/B
+
+def MultivariateBeta(syms, *alpha):
+    """
+    Creates a continuous random variable with Dirichlet/Multivariate Beta
+    Distribution.
+
+    The density of the Dirichlet distribution can be found at [1].
+
+    Parameters
+    ==========
+
+    alpha : Positive real numbers
+        Signifies concentration numbers.
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density, MultivariateBeta, marginal_distribution
+    >>> from sympy import Symbol
+    >>> a1 = Symbol('a1', positive=True)
+    >>> a2 = Symbol('a2', positive=True)
+    >>> B = MultivariateBeta('B', [a1, a2])
+    >>> C = MultivariateBeta('C', a1, a2)
+    >>> x = Symbol('x')
+    >>> y = Symbol('y')
+    >>> density(B)(x, y)
+    x**(a1 - 1)*y**(a2 - 1)*gamma(a1 + a2)/(gamma(a1)*gamma(a2))
+    >>> marginal_distribution(C, C[0])(x)
+    x**(a1 - 1)*gamma(a1 + a2)/(a2*gamma(a1)*gamma(a2))
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Dirichlet_distribution
+    .. [2] https://mathworld.wolfram.com/DirichletDistribution.html
+
+    """
+    if not isinstance(alpha[0], list):
+        alpha = (list(alpha),)
+    return multivariate_rv(MultivariateBetaDistribution, syms, alpha[0])
+
+Dirichlet = MultivariateBeta
+
+#-------------------------------------------------------------------------------
+# Multivariate Ewens distribution ----------------------------------------------
+
+class MultivariateEwensDistribution(JointDistribution):
+
+    _argnames = ('n', 'theta')
+    is_Discrete = True
+    is_Continuous = False
+
+    @staticmethod
+    def check(n, theta):
+        _value_check((n > 0),
+                        "sample size should be positive integer.")
+        _value_check(theta.is_positive, "mutation rate should be positive.")
+
+    @property
+    def set(self):
+        if not isinstance(self.n, Integer):
+            i = Symbol('i', integer=True, positive=True)
+            return Product(Intersection(S.Naturals0, Interval(0, self.n//i)),
+                                    (i, 1, self.n))
+        prod_set = Range(0, self.n + 1)
+        for i in range(2, self.n + 1):
+            prod_set *= Range(0, self.n//i + 1)
+        return prod_set.flatten()
+
+    def pdf(self, *syms):
+        n, theta = self.n, self.theta
+        condi = isinstance(self.n, Integer)
+        if not (isinstance(syms[0], IndexedBase) or condi):
+            raise ValueError("Please use IndexedBase object for syms as "
+                                "the dimension is symbolic")
+        term_1 = factorial(n)/rf(theta, n)
+        if condi:
+            term_2 = Mul.fromiter(theta**syms[j]/((j+1)**syms[j]*factorial(syms[j]))
+                                    for j in range(n))
+            cond = Eq(sum((k + 1)*syms[k] for k in range(n)), n)
+            return Piecewise((term_1 * term_2, cond), (0, True))
+        syms = syms[0]
+        j, k = symbols('j, k', positive=True, integer=True)
+        term_2 = Product(theta**syms[j]/((j+1)**syms[j]*factorial(syms[j])),
+                            (j, 0, n - 1))
+        cond = Eq(Sum((k + 1)*syms[k], (k, 0, n - 1)), n)
+        return Piecewise((term_1 * term_2, cond), (0, True))
+
+
+def MultivariateEwens(syms, n, theta):
+    """
+    Creates a discrete random variable with Multivariate Ewens
+    Distribution.
+
+    The density of the said distribution can be found at [1].
+
+    Parameters
+    ==========
+
+    n : Positive integer
+        Size of the sample or the integer whose partitions are considered
+    theta : Positive real number
+        Denotes Mutation rate
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density, marginal_distribution, MultivariateEwens
+    >>> from sympy import Symbol
+    >>> a1 = Symbol('a1', positive=True)
+    >>> a2 = Symbol('a2', positive=True)
+    >>> ed = MultivariateEwens('E', 2, 1)
+    >>> density(ed)(a1, a2)
+    Piecewise((1/(2**a2*factorial(a1)*factorial(a2)), Eq(a1 + 2*a2, 2)), (0, True))
+    >>> marginal_distribution(ed, ed[0])(a1)
+    Piecewise((1/factorial(a1), Eq(a1, 2)), (0, True))
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Ewens%27s_sampling_formula
+    .. [2] https://www.jstor.org/stable/24780825
+    """
+    return multivariate_rv(MultivariateEwensDistribution, syms, n, theta)
+
+#-------------------------------------------------------------------------------
+# Generalized Multivariate Log Gamma distribution ------------------------------
+
+class GeneralizedMultivariateLogGammaDistribution(JointDistribution):
+
+    _argnames = ('delta', 'v', 'lamda', 'mu')
+    is_Continuous=True
+
+    def check(self, delta, v, l, mu):
+        _value_check((delta >= 0, delta <= 1), "delta must be in range [0, 1].")
+        _value_check((v > 0), "v must be positive")
+        for lk in l:
+            _value_check((lk > 0), "lamda must be a positive vector.")
+        for muk in mu:
+            _value_check((muk > 0), "mu must be a positive vector.")
+        _value_check(len(l) > 1,"the distribution should have at least"
+                                " two random variables.")
+
+    @property
+    def set(self):
+        return S.Reals**len(self.lamda)
+
+    def pdf(self, *y):
+        d, v, l, mu = self.delta, self.v, self.lamda, self.mu
+        n = Symbol('n', negative=False, integer=True)
+        k = len(l)
+        sterm1 = Pow((1 - d), n)/\
+                ((gamma(v + n)**(k - 1))*gamma(v)*gamma(n + 1))
+        sterm2 = Mul.fromiter(mui*li**(-v - n) for mui, li in zip(mu, l))
+        term1 = sterm1 * sterm2
+        sterm3 = (v + n) * sum(mui * yi for mui, yi in zip(mu, y))
+        sterm4 = sum(exp(mui * yi)/li for (mui, yi, li) in zip(mu, y, l))
+        term2 = exp(sterm3 - sterm4)
+        return Pow(d, v) * Sum(term1 * term2, (n, 0, S.Infinity))
+
+def GeneralizedMultivariateLogGamma(syms, delta, v, lamda, mu):
+    """
+    Creates a joint random variable with generalized multivariate log gamma
+    distribution.
+
+    The joint pdf can be found at [1].
+
+    Parameters
+    ==========
+
+    syms : list/tuple/set of symbols for identifying each component
+    delta : A constant in range $[0, 1]$
+    v : Positive real number
+    lamda : List of positive real numbers
+    mu : List of positive real numbers
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density
+    >>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGamma
+    >>> from sympy import symbols, S
+    >>> v = 1
+    >>> l, mu = [1, 1, 1], [1, 1, 1]
+    >>> d = S.Half
+    >>> y = symbols('y_1:4', positive=True)
+    >>> Gd = GeneralizedMultivariateLogGamma('G', d, v, l, mu)
+    >>> density(Gd)(y[0], y[1], y[2])
+    Sum(exp((n + 1)*(y_1 + y_2 + y_3) - exp(y_1) - exp(y_2) -
+    exp(y_3))/(2**n*gamma(n + 1)**3), (n, 0, oo))/2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Generalized_multivariate_log-gamma_distribution
+    .. [2] https://www.researchgate.net/publication/234137346_On_a_multivariate_log-gamma_distribution_and_the_use_of_the_distribution_in_the_Bayesian_analysis
+
+    Note
+    ====
+
+    If the GeneralizedMultivariateLogGamma is too long to type use,
+
+    >>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGamma as GMVLG
+    >>> Gd = GMVLG('G', d, v, l, mu)
+
+    If you want to pass the matrix omega instead of the constant delta, then use
+    ``GeneralizedMultivariateLogGammaOmega``.
+
+    """
+    return multivariate_rv(GeneralizedMultivariateLogGammaDistribution,
+                            syms, delta, v, lamda, mu)
+
+def GeneralizedMultivariateLogGammaOmega(syms, omega, v, lamda, mu):
+    """
+    Extends GeneralizedMultivariateLogGamma.
+
+    Parameters
+    ==========
+
+    syms : list/tuple/set of symbols
+        For identifying each component
+    omega : A square matrix
+           Every element of square matrix must be absolute value of
+           square root of correlation coefficient
+    v : Positive real number
+    lamda : List of positive real numbers
+    mu : List of positive real numbers
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density
+    >>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega
+    >>> from sympy import Matrix, symbols, S
+    >>> omega = Matrix([[1, S.Half, S.Half], [S.Half, 1, S.Half], [S.Half, S.Half, 1]])
+    >>> v = 1
+    >>> l, mu = [1, 1, 1], [1, 1, 1]
+    >>> G = GeneralizedMultivariateLogGammaOmega('G', omega, v, l, mu)
+    >>> y = symbols('y_1:4', positive=True)
+    >>> density(G)(y[0], y[1], y[2])
+    sqrt(2)*Sum((1 - sqrt(2)/2)**n*exp((n + 1)*(y_1 + y_2 + y_3) - exp(y_1) -
+    exp(y_2) - exp(y_3))/gamma(n + 1)**3, (n, 0, oo))/2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Generalized_multivariate_log-gamma_distribution
+    .. [2] https://www.researchgate.net/publication/234137346_On_a_multivariate_log-gamma_distribution_and_the_use_of_the_distribution_in_the_Bayesian_analysis
+
+    Notes
+    =====
+
+    If the GeneralizedMultivariateLogGammaOmega is too long to type use,
+
+    >>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega as GMVLGO
+    >>> G = GMVLGO('G', omega, v, l, mu)
+
+    """
+    _value_check((omega.is_square, isinstance(omega, Matrix)), "omega must be a"
+                                                            " square matrix")
+    for val in omega.values():
+        _value_check((val >= 0, val <= 1),
+            "all values in matrix must be between 0 and 1(both inclusive).")
+    _value_check(omega.diagonal().equals(ones(1, omega.shape[0])),
+                    "all the elements of diagonal should be 1.")
+    _value_check((omega.shape[0] == len(lamda), len(lamda) == len(mu)),
+                    "lamda, mu should be of same length and omega should "
+                    " be of shape (length of lamda, length of mu)")
+    _value_check(len(lamda) > 1,"the distribution should have at least"
+                            " two random variables.")
+    delta = Pow(Rational(omega.det()), Rational(1, len(lamda) - 1))
+    return GeneralizedMultivariateLogGamma(syms, delta, v, lamda, mu)
+
+
+#-------------------------------------------------------------------------------
+# Multinomial distribution -----------------------------------------------------
+
+class MultinomialDistribution(JointDistribution):
+
+    _argnames = ('n', 'p')
+    is_Continuous=False
+    is_Discrete = True
+
+    @staticmethod
+    def check(n, p):
+        _value_check(n > 0,
+                        "number of trials must be a positive integer")
+        for p_k in p:
+            _value_check((p_k >= 0, p_k <= 1),
+                        "probability must be in range [0, 1]")
+        _value_check(Eq(sum(p), 1),
+                        "probabilities must sum to 1")
+
+    @property
+    def set(self):
+        return Intersection(S.Naturals0, Interval(0, self.n))**len(self.p)
+
+    def pdf(self, *x):
+        n, p = self.n, self.p
+        term_1 = factorial(n)/Mul.fromiter(factorial(x_k) for x_k in x)
+        term_2 = Mul.fromiter(p_k**x_k for p_k, x_k in zip(p, x))
+        return Piecewise((term_1 * term_2, Eq(sum(x), n)), (0, True))
+
+def Multinomial(syms, n, *p):
+    """
+    Creates a discrete random variable with Multinomial Distribution.
+
+    The density of the said distribution can be found at [1].
+
+    Parameters
+    ==========
+
+    n : Positive integer
+        Represents number of trials
+    p : List of event probabilities
+        Must be in the range of $[0, 1]$.
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density, Multinomial, marginal_distribution
+    >>> from sympy import symbols
+    >>> x1, x2, x3 = symbols('x1, x2, x3', nonnegative=True, integer=True)
+    >>> p1, p2, p3 = symbols('p1, p2, p3', positive=True)
+    >>> M = Multinomial('M', 3, p1, p2, p3)
+    >>> density(M)(x1, x2, x3)
+    Piecewise((6*p1**x1*p2**x2*p3**x3/(factorial(x1)*factorial(x2)*factorial(x3)),
+    Eq(x1 + x2 + x3, 3)), (0, True))
+    >>> marginal_distribution(M, M[0])(x1).subs(x1, 1)
+    3*p1*p2**2 + 6*p1*p2*p3 + 3*p1*p3**2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Multinomial_distribution
+    .. [2] https://mathworld.wolfram.com/MultinomialDistribution.html
+
+    """
+    if not isinstance(p[0], list):
+        p = (list(p), )
+    return multivariate_rv(MultinomialDistribution, syms, n, p[0])
+
+#-------------------------------------------------------------------------------
+# Negative Multinomial Distribution --------------------------------------------
+
+class NegativeMultinomialDistribution(JointDistribution):
+
+    _argnames = ('k0', 'p')
+    is_Continuous=False
+    is_Discrete = True
+
+    @staticmethod
+    def check(k0, p):
+        _value_check(k0 > 0,
+                        "number of failures must be a positive integer")
+        for p_k in p:
+            _value_check((p_k >= 0, p_k <= 1),
+                        "probability must be in range [0, 1].")
+        _value_check(sum(p) <= 1,
+                        "success probabilities must not be greater than 1.")
+
+    @property
+    def set(self):
+        return Range(0, S.Infinity)**len(self.p)
+
+    def pdf(self, *k):
+        k0, p = self.k0, self.p
+        term_1 = (gamma(k0 + sum(k))*(1 - sum(p))**k0)/gamma(k0)
+        term_2 = Mul.fromiter(pi**ki/factorial(ki) for pi, ki in zip(p, k))
+        return term_1 * term_2
+
+def NegativeMultinomial(syms, k0, *p):
+    """
+    Creates a discrete random variable with Negative Multinomial Distribution.
+
+    The density of the said distribution can be found at [1].
+
+    Parameters
+    ==========
+
+    k0 : positive integer
+        Represents number of failures before the experiment is stopped
+    p : List of event probabilities
+        Must be in the range of $[0, 1]$
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density, NegativeMultinomial, marginal_distribution
+    >>> from sympy import symbols
+    >>> x1, x2, x3 = symbols('x1, x2, x3', nonnegative=True, integer=True)
+    >>> p1, p2, p3 = symbols('p1, p2, p3', positive=True)
+    >>> N = NegativeMultinomial('M', 3, p1, p2, p3)
+    >>> N_c = NegativeMultinomial('M', 3, 0.1, 0.1, 0.1)
+    >>> density(N)(x1, x2, x3)
+    p1**x1*p2**x2*p3**x3*(-p1 - p2 - p3 + 1)**3*gamma(x1 + x2 +
+    x3 + 3)/(2*factorial(x1)*factorial(x2)*factorial(x3))
+    >>> marginal_distribution(N_c, N_c[0])(1).evalf().round(2)
+    0.25
+
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Negative_multinomial_distribution
+    .. [2] https://mathworld.wolfram.com/NegativeBinomialDistribution.html
+
+    """
+    if not isinstance(p[0], list):
+        p = (list(p), )
+    return multivariate_rv(NegativeMultinomialDistribution, syms, k0, p[0])

parrot/lib/python3.10/site-packages/sympy/stats/matrix_distributions.py

@@ -0,0 +1,610 @@
+from math import prod
+
+from sympy.core.basic import Basic
+from sympy.core.numbers import pi
+from sympy.core.singleton import S
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.special.gamma_functions import multigamma
+from sympy.core.sympify import sympify, _sympify
+from sympy.matrices import (ImmutableMatrix, Inverse, Trace, Determinant,
+                            MatrixSymbol, MatrixBase, Transpose, MatrixSet,
+                            matrix2numpy)
+from sympy.stats.rv import (_value_check, RandomMatrixSymbol, NamedArgsMixin, PSpace,
+                            _symbol_converter, MatrixDomain, Distribution)
+from sympy.external import import_module
+
+
+################################################################################
+#------------------------Matrix Probability Space------------------------------#
+################################################################################
+class MatrixPSpace(PSpace):
+    """
+    Represents probability space for
+    Matrix Distributions.
+    """
+    def __new__(cls, sym, distribution, dim_n, dim_m):
+        sym = _symbol_converter(sym)
+        dim_n, dim_m = _sympify(dim_n), _sympify(dim_m)
+        if not (dim_n.is_integer and dim_m.is_integer):
+            raise ValueError("Dimensions should be integers")
+        return Basic.__new__(cls, sym, distribution, dim_n, dim_m)
+
+    distribution = property(lambda self: self.args[1])
+    symbol = property(lambda self: self.args[0])
+
+    @property
+    def domain(self):
+        return MatrixDomain(self.symbol, self.distribution.set)
+
+    @property
+    def value(self):
+        return RandomMatrixSymbol(self.symbol, self.args[2], self.args[3], self)
+
+    @property
+    def values(self):
+        return {self.value}
+
+    def compute_density(self, expr, *args):
+        rms = expr.atoms(RandomMatrixSymbol)
+        if len(rms) > 1 or (not isinstance(expr, RandomMatrixSymbol)):
+            raise NotImplementedError("Currently, no algorithm has been "
+                    "implemented to handle general expressions containing "
+                    "multiple matrix distributions.")
+        return self.distribution.pdf(expr)
+
+    def sample(self, size=(), library='scipy', seed=None):
+        """
+        Internal sample method
+
+        Returns dictionary mapping RandomMatrixSymbol to realization value.
+        """
+        return {self.value: self.distribution.sample(size, library=library, seed=seed)}
+
+
+def rv(symbol, cls, args):
+    args = list(map(sympify, args))
+    dist = cls(*args)
+    dist.check(*args)
+    dim = dist.dimension
+    pspace = MatrixPSpace(symbol, dist, dim[0], dim[1])
+    return pspace.value
+
+
+class SampleMatrixScipy:
+    """Returns the sample from scipy of the given distribution"""
+    def __new__(cls, dist, size, seed=None):
+        return cls._sample_scipy(dist, size, seed)
+
+    @classmethod
+    def _sample_scipy(cls, dist, size, seed):
+        """Sample from SciPy."""
+
+        from scipy import stats as scipy_stats
+        import numpy
+        scipy_rv_map = {
+            'WishartDistribution': lambda dist, size, rand_state: scipy_stats.wishart.rvs(
+                df=int(dist.n), scale=matrix2numpy(dist.scale_matrix, float), size=size),
+            'MatrixNormalDistribution': lambda dist, size, rand_state: scipy_stats.matrix_normal.rvs(
+                mean=matrix2numpy(dist.location_matrix, float),
+                rowcov=matrix2numpy(dist.scale_matrix_1, float),
+                colcov=matrix2numpy(dist.scale_matrix_2, float), size=size, random_state=rand_state)
+        }
+
+        sample_shape = {
+            'WishartDistribution': lambda dist: dist.scale_matrix.shape,
+            'MatrixNormalDistribution' : lambda dist: dist.location_matrix.shape
+        }
+
+        dist_list = scipy_rv_map.keys()
+
+        if dist.__class__.__name__ not in dist_list:
+            return None
+
+        if seed is None or isinstance(seed, int):
+            rand_state = numpy.random.default_rng(seed=seed)
+        else:
+            rand_state = seed
+        samp = scipy_rv_map[dist.__class__.__name__](dist, prod(size), rand_state)
+        return samp.reshape(size + sample_shape[dist.__class__.__name__](dist))
+
+
+class SampleMatrixNumpy:
+    """Returns the sample from numpy of the given distribution"""
+
+    ### TODO: Add tests after adding matrix distributions in numpy_rv_map
+    def __new__(cls, dist, size, seed=None):
+        return cls._sample_numpy(dist, size, seed)
+
+    @classmethod
+    def _sample_numpy(cls, dist, size, seed):
+        """Sample from NumPy."""
+
+        numpy_rv_map = {
+        }
+
+        sample_shape = {
+        }
+
+        dist_list = numpy_rv_map.keys()
+
+        if dist.__class__.__name__ not in dist_list:
+            return None
+
+        import numpy
+        if seed is None or isinstance(seed, int):
+            rand_state = numpy.random.default_rng(seed=seed)
+        else:
+            rand_state = seed
+        samp = numpy_rv_map[dist.__class__.__name__](dist, prod(size), rand_state)
+        return samp.reshape(size + sample_shape[dist.__class__.__name__](dist))
+
+
+class SampleMatrixPymc:
+    """Returns the sample from pymc of the given distribution"""
+
+    def __new__(cls, dist, size, seed=None):
+        return cls._sample_pymc(dist, size, seed)
+
+    @classmethod
+    def _sample_pymc(cls, dist, size, seed):
+        """Sample from PyMC."""
+
+        try:
+            import pymc
+        except ImportError:
+            import pymc3 as pymc
+        pymc_rv_map = {
+            'MatrixNormalDistribution': lambda dist: pymc.MatrixNormal('X',
+                mu=matrix2numpy(dist.location_matrix, float),
+                rowcov=matrix2numpy(dist.scale_matrix_1, float),
+                colcov=matrix2numpy(dist.scale_matrix_2, float),
+                shape=dist.location_matrix.shape),
+            'WishartDistribution': lambda dist: pymc.WishartBartlett('X',
+                nu=int(dist.n), S=matrix2numpy(dist.scale_matrix, float))
+        }
+
+        sample_shape = {
+            'WishartDistribution': lambda dist: dist.scale_matrix.shape,
+            'MatrixNormalDistribution' : lambda dist: dist.location_matrix.shape
+        }
+
+        dist_list = pymc_rv_map.keys()
+
+        if dist.__class__.__name__ not in dist_list:
+            return None
+        import logging
+        logging.getLogger("pymc").setLevel(logging.ERROR)
+        with pymc.Model():
+            pymc_rv_map[dist.__class__.__name__](dist)
+            samps = pymc.sample(draws=prod(size), chains=1, progressbar=False, random_seed=seed, return_inferencedata=False, compute_convergence_checks=False)['X']
+        return samps.reshape(size + sample_shape[dist.__class__.__name__](dist))
+
+_get_sample_class_matrixrv = {
+    'scipy': SampleMatrixScipy,
+    'pymc3': SampleMatrixPymc,
+    'pymc': SampleMatrixPymc,
+    'numpy': SampleMatrixNumpy
+}
+
+################################################################################
+#-------------------------Matrix Distribution----------------------------------#
+################################################################################
+
+class MatrixDistribution(Distribution, NamedArgsMixin):
+    """
+    Abstract class for Matrix Distribution.
+    """
+    def __new__(cls, *args):
+        args = [ImmutableMatrix(arg) if isinstance(arg, list)
+                else _sympify(arg) for arg in args]
+        return Basic.__new__(cls, *args)
+
+    @staticmethod
+    def check(*args):
+        pass
+
+    def __call__(self, expr):
+        if isinstance(expr, list):
+            expr = ImmutableMatrix(expr)
+        return self.pdf(expr)
+
+    def sample(self, size=(), library='scipy', seed=None):
+        """
+        Internal sample method
+
+        Returns dictionary mapping RandomSymbol to realization value.
+        """
+
+        libraries = ['scipy', 'numpy', 'pymc3', 'pymc']
+        if library not in libraries:
+            raise NotImplementedError("Sampling from %s is not supported yet."
+                                        % str(library))
+        if not import_module(library):
+            raise ValueError("Failed to import %s" % library)
+
+        samps = _get_sample_class_matrixrv[library](self, size, seed)
+
+        if samps is not None:
+            return samps
+        raise NotImplementedError(
+                "Sampling for %s is not currently implemented from %s"
+                % (self.__class__.__name__, library)
+                )
+
+################################################################################
+#------------------------Matrix Distribution Types-----------------------------#
+################################################################################
+
+#-------------------------------------------------------------------------------
+# Matrix Gamma distribution ----------------------------------------------------
+
+class MatrixGammaDistribution(MatrixDistribution):
+
+    _argnames = ('alpha', 'beta', 'scale_matrix')
+
+    @staticmethod
+    def check(alpha, beta, scale_matrix):
+        if not isinstance(scale_matrix, MatrixSymbol):
+            _value_check(scale_matrix.is_positive_definite, "The shape "
+                "matrix must be positive definite.")
+        _value_check(scale_matrix.is_square, "Should "
+        "be square matrix")
+        _value_check(alpha.is_positive, "Shape parameter should be positive.")
+        _value_check(beta.is_positive, "Scale parameter should be positive.")
+
+    @property
+    def set(self):
+        k = self.scale_matrix.shape[0]
+        return MatrixSet(k, k, S.Reals)
+
+    @property
+    def dimension(self):
+        return self.scale_matrix.shape
+
+    def pdf(self, x):
+        alpha, beta, scale_matrix = self.alpha, self.beta, self.scale_matrix
+        p = scale_matrix.shape[0]
+        if isinstance(x, list):
+            x = ImmutableMatrix(x)
+        if not isinstance(x, (MatrixBase, MatrixSymbol)):
+            raise ValueError("%s should be an isinstance of Matrix "
+                    "or MatrixSymbol" % str(x))
+        sigma_inv_x = - Inverse(scale_matrix)*x / beta
+        term1 = exp(Trace(sigma_inv_x))/((beta**(p*alpha)) * multigamma(alpha, p))
+        term2 = (Determinant(scale_matrix))**(-alpha)
+        term3 = (Determinant(x))**(alpha - S(p + 1)/2)
+        return term1 * term2 * term3
+
+def MatrixGamma(symbol, alpha, beta, scale_matrix):
+    """
+    Creates a random variable with Matrix Gamma Distribution.
+
+    The density of the said distribution can be found at [1].
+
+    Parameters
+    ==========
+
+    alpha: Positive Real number
+        Shape Parameter
+    beta: Positive Real number
+        Scale Parameter
+    scale_matrix: Positive definite real square matrix
+        Scale Matrix
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density, MatrixGamma
+    >>> from sympy import MatrixSymbol, symbols
+    >>> a, b = symbols('a b', positive=True)
+    >>> M = MatrixGamma('M', a, b, [[2, 1], [1, 2]])
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> density(M)(X).doit()
+    exp(Trace(Matrix([
+    [-2/3,  1/3],
+    [ 1/3, -2/3]])*X)/b)*Determinant(X)**(a - 3/2)/(3**a*sqrt(pi)*b**(2*a)*gamma(a)*gamma(a - 1/2))
+    >>> density(M)([[1, 0], [0, 1]]).doit()
+    exp(-4/(3*b))/(3**a*sqrt(pi)*b**(2*a)*gamma(a)*gamma(a - 1/2))
+
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Matrix_gamma_distribution
+
+    """
+    if isinstance(scale_matrix, list):
+        scale_matrix = ImmutableMatrix(scale_matrix)
+    return rv(symbol, MatrixGammaDistribution, (alpha, beta, scale_matrix))
+
+#-------------------------------------------------------------------------------
+# Wishart Distribution ---------------------------------------------------------
+
+class WishartDistribution(MatrixDistribution):
+
+    _argnames = ('n', 'scale_matrix')
+
+    @staticmethod
+    def check(n, scale_matrix):
+        if not isinstance(scale_matrix, MatrixSymbol):
+            _value_check(scale_matrix.is_positive_definite, "The shape "
+                "matrix must be positive definite.")
+        _value_check(scale_matrix.is_square, "Should "
+        "be square matrix")
+        _value_check(n.is_positive, "Shape parameter should be positive.")
+
+    @property
+    def set(self):
+        k = self.scale_matrix.shape[0]
+        return MatrixSet(k, k, S.Reals)
+
+    @property
+    def dimension(self):
+        return self.scale_matrix.shape
+
+    def pdf(self, x):
+        n, scale_matrix = self.n, self.scale_matrix
+        p = scale_matrix.shape[0]
+        if isinstance(x, list):
+            x = ImmutableMatrix(x)
+        if not isinstance(x, (MatrixBase, MatrixSymbol)):
+            raise ValueError("%s should be an isinstance of Matrix "
+                    "or MatrixSymbol" % str(x))
+        sigma_inv_x = - Inverse(scale_matrix)*x / S(2)
+        term1 = exp(Trace(sigma_inv_x))/((2**(p*n/S(2))) * multigamma(n/S(2), p))
+        term2 = (Determinant(scale_matrix))**(-n/S(2))
+        term3 = (Determinant(x))**(S(n - p - 1)/2)
+        return term1 * term2 * term3
+
+def Wishart(symbol, n, scale_matrix):
+    """
+    Creates a random variable with Wishart Distribution.
+
+    The density of the said distribution can be found at [1].
+
+    Parameters
+    ==========
+
+    n: Positive Real number
+        Represents degrees of freedom
+    scale_matrix: Positive definite real square matrix
+        Scale Matrix
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy.stats import density, Wishart
+    >>> from sympy import MatrixSymbol, symbols
+    >>> n = symbols('n', positive=True)
+    >>> W = Wishart('W', n, [[2, 1], [1, 2]])
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> density(W)(X).doit()
+    exp(Trace(Matrix([
+    [-1/3,  1/6],
+    [ 1/6, -1/3]])*X))*Determinant(X)**(n/2 - 3/2)/(2**n*3**(n/2)*sqrt(pi)*gamma(n/2)*gamma(n/2 - 1/2))
+    >>> density(W)([[1, 0], [0, 1]]).doit()
+    exp(-2/3)/(2**n*3**(n/2)*sqrt(pi)*gamma(n/2)*gamma(n/2 - 1/2))
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Wishart_distribution
+
+    """
+    if isinstance(scale_matrix, list):
+        scale_matrix = ImmutableMatrix(scale_matrix)
+    return rv(symbol, WishartDistribution, (n, scale_matrix))
+
+#-------------------------------------------------------------------------------
+# Matrix Normal distribution ---------------------------------------------------
+
+class MatrixNormalDistribution(MatrixDistribution):
+
+    _argnames = ('location_matrix', 'scale_matrix_1', 'scale_matrix_2')
+
+    @staticmethod
+    def check(location_matrix, scale_matrix_1, scale_matrix_2):
+        if not isinstance(scale_matrix_1, MatrixSymbol):
+            _value_check(scale_matrix_1.is_positive_definite, "The shape "
+                "matrix must be positive definite.")
+        if not isinstance(scale_matrix_2, MatrixSymbol):
+            _value_check(scale_matrix_2.is_positive_definite, "The shape "
+                "matrix must be positive definite.")
+        _value_check(scale_matrix_1.is_square, "Scale matrix 1 should be "
+        "be square matrix")
+        _value_check(scale_matrix_2.is_square, "Scale matrix 2 should be "
+        "be square matrix")
+        n = location_matrix.shape[0]
+        p = location_matrix.shape[1]
+        _value_check(scale_matrix_1.shape[0] == n, "Scale matrix 1 should be"
+        " of shape %s x %s"% (str(n), str(n)))
+        _value_check(scale_matrix_2.shape[0] == p, "Scale matrix 2 should be"
+        " of shape %s x %s"% (str(p), str(p)))
+
+    @property
+    def set(self):
+        n, p = self.location_matrix.shape
+        return MatrixSet(n, p, S.Reals)
+
+    @property
+    def dimension(self):
+        return self.location_matrix.shape
+
+    def pdf(self, x):
+        M, U, V = self.location_matrix, self.scale_matrix_1, self.scale_matrix_2
+        n, p = M.shape
+        if isinstance(x, list):
+            x = ImmutableMatrix(x)
+        if not isinstance(x, (MatrixBase, MatrixSymbol)):
+            raise ValueError("%s should be an isinstance of Matrix "
+                    "or MatrixSymbol" % str(x))
+        term1 = Inverse(V)*Transpose(x - M)*Inverse(U)*(x - M)
+        num = exp(-Trace(term1)/S(2))
+        den = (2*pi)**(S(n*p)/2) * Determinant(U)**(S(p)/2) * Determinant(V)**(S(n)/2)
+        return num/den
+
+def MatrixNormal(symbol, location_matrix, scale_matrix_1, scale_matrix_2):
+    """
+    Creates a random variable with Matrix Normal Distribution.
+
+    The density of the said distribution can be found at [1].
+
+    Parameters
+    ==========
+
+    location_matrix: Real ``n x p`` matrix
+        Represents degrees of freedom
+    scale_matrix_1: Positive definite matrix
+        Scale Matrix of shape ``n x n``
+    scale_matrix_2: Positive definite matrix
+        Scale Matrix of shape ``p x p``
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy import MatrixSymbol
+    >>> from sympy.stats import density, MatrixNormal
+    >>> M = MatrixNormal('M', [[1, 2]], [1], [[1, 0], [0, 1]])
+    >>> X = MatrixSymbol('X', 1, 2)
+    >>> density(M)(X).doit()
+    exp(-Trace((Matrix([
+    [-1],
+    [-2]]) + X.T)*(Matrix([[-1, -2]]) + X))/2)/(2*pi)
+    >>> density(M)([[3, 4]]).doit()
+    exp(-4)/(2*pi)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Matrix_normal_distribution
+
+    """
+    if isinstance(location_matrix, list):
+        location_matrix = ImmutableMatrix(location_matrix)
+    if isinstance(scale_matrix_1, list):
+        scale_matrix_1 = ImmutableMatrix(scale_matrix_1)
+    if isinstance(scale_matrix_2, list):
+        scale_matrix_2 = ImmutableMatrix(scale_matrix_2)
+    args = (location_matrix, scale_matrix_1, scale_matrix_2)
+    return rv(symbol, MatrixNormalDistribution, args)
+
+#-------------------------------------------------------------------------------
+# Matrix Student's T distribution ---------------------------------------------------
+
+class MatrixStudentTDistribution(MatrixDistribution):
+
+    _argnames = ('nu', 'location_matrix', 'scale_matrix_1', 'scale_matrix_2')
+
+    @staticmethod
+    def check(nu, location_matrix, scale_matrix_1, scale_matrix_2):
+        if not isinstance(scale_matrix_1, MatrixSymbol):
+            _value_check(scale_matrix_1.is_positive_definite != False, "The shape "
+                                                              "matrix must be positive definite.")
+        if not isinstance(scale_matrix_2, MatrixSymbol):
+            _value_check(scale_matrix_2.is_positive_definite != False, "The shape "
+                                                              "matrix must be positive definite.")
+        _value_check(scale_matrix_1.is_square != False, "Scale matrix 1 should be "
+                                               "be square matrix")
+        _value_check(scale_matrix_2.is_square != False, "Scale matrix 2 should be "
+                                               "be square matrix")
+        n = location_matrix.shape[0]
+        p = location_matrix.shape[1]
+        _value_check(scale_matrix_1.shape[0] == p, "Scale matrix 1 should be"
+                                                   " of shape %s x %s" % (str(p), str(p)))
+        _value_check(scale_matrix_2.shape[0] == n, "Scale matrix 2 should be"
+                                                   " of shape %s x %s" % (str(n), str(n)))
+        _value_check(nu.is_positive != False, "Degrees of freedom must be positive")
+
+    @property
+    def set(self):
+        n, p = self.location_matrix.shape
+        return MatrixSet(n, p, S.Reals)
+
+    @property
+    def dimension(self):
+        return self.location_matrix.shape
+
+    def pdf(self, x):
+        from sympy.matrices.dense import eye
+        if isinstance(x, list):
+            x = ImmutableMatrix(x)
+        if not isinstance(x, (MatrixBase, MatrixSymbol)):
+            raise ValueError("%s should be an isinstance of Matrix "
+                             "or MatrixSymbol" % str(x))
+        nu, M, Omega, Sigma = self.nu, self.location_matrix, self.scale_matrix_1, self.scale_matrix_2
+        n, p = M.shape
+
+        K = multigamma((nu + n + p - 1)/2, p) * Determinant(Omega)**(-n/2) * Determinant(Sigma)**(-p/2) \
+            / ((pi)**(n*p/2) * multigamma((nu + p - 1)/2, p))
+        return K * (Determinant(eye(n) + Inverse(Sigma)*(x - M)*Inverse(Omega)*Transpose(x - M))) \
+               **(-(nu + n + p -1)/2)
+
+
+
+def MatrixStudentT(symbol, nu, location_matrix, scale_matrix_1, scale_matrix_2):
+    """
+    Creates a random variable with Matrix Gamma Distribution.
+
+    The density of the said distribution can be found at [1].
+
+    Parameters
+    ==========
+
+    nu: Positive Real number
+        degrees of freedom
+    location_matrix: Positive definite real square matrix
+        Location Matrix of shape ``n x p``
+    scale_matrix_1: Positive definite real square matrix
+        Scale Matrix of shape ``p x p``
+    scale_matrix_2: Positive definite real square matrix
+        Scale Matrix of shape ``n x n``
+
+    Returns
+    =======
+
+    RandomSymbol
+
+    Examples
+    ========
+
+    >>> from sympy import MatrixSymbol,symbols
+    >>> from sympy.stats import density, MatrixStudentT
+    >>> v = symbols('v',positive=True)
+    >>> M = MatrixStudentT('M', v, [[1, 2]], [[1, 0], [0, 1]], [1])
+    >>> X = MatrixSymbol('X', 1, 2)
+    >>> density(M)(X)
+    gamma(v/2 + 1)*Determinant((Matrix([[-1, -2]]) + X)*(Matrix([
+    [-1],
+    [-2]]) + X.T) + Matrix([[1]]))**(-v/2 - 1)/(pi**1.0*gamma(v/2)*Determinant(Matrix([[1]]))**1.0*Determinant(Matrix([
+    [1, 0],
+    [0, 1]]))**0.5)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Matrix_t-distribution
+
+    """
+    if isinstance(location_matrix, list):
+        location_matrix = ImmutableMatrix(location_matrix)
+    if isinstance(scale_matrix_1, list):
+        scale_matrix_1 = ImmutableMatrix(scale_matrix_1)
+    if isinstance(scale_matrix_2, list):
+        scale_matrix_2 = ImmutableMatrix(scale_matrix_2)
+    args = (nu, location_matrix, scale_matrix_1, scale_matrix_2)
+    return rv(symbol, MatrixStudentTDistribution, args)

parrot/lib/python3.10/site-packages/sympy/stats/random_matrix.py

@@ -0,0 +1,30 @@
+from sympy.core.basic import Basic
+from sympy.stats.rv import PSpace, _symbol_converter, RandomMatrixSymbol
+
+class RandomMatrixPSpace(PSpace):
+    """
+    Represents probability space for
+    random matrices. It contains the mechanics
+    for handling the API calls for random matrices.
+    """
+    def __new__(cls, sym, model=None):
+        sym = _symbol_converter(sym)
+        if model:
+            return Basic.__new__(cls, sym, model)
+        else:
+            return Basic.__new__(cls, sym)
+
+    @property
+    def model(self):
+        try:
+            return self.args[1]
+        except IndexError:
+            return None
+
+    def compute_density(self, expr, *args):
+        rms = expr.atoms(RandomMatrixSymbol)
+        if len(rms) > 2 or (not isinstance(expr, RandomMatrixSymbol)):
+            raise NotImplementedError("Currently, no algorithm has been "
+                    "implemented to handle general expressions containing "
+                    "multiple random matrices.")
+        return self.model.density(expr)

parrot/lib/python3.10/site-packages/sympy/stats/random_matrix_models.py

@@ -0,0 +1,457 @@
+from sympy.concrete.products import Product
+from sympy.concrete.summations import Sum
+from sympy.core.basic import Basic
+from sympy.core.function import Lambda
+from sympy.core.numbers import (I, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.special.gamma_functions import gamma
+from sympy.integrals.integrals import Integral
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.matrices.expressions.trace import Trace
+from sympy.tensor.indexed import IndexedBase
+from sympy.core.sympify import _sympify
+from sympy.stats.rv import _symbol_converter, Density, RandomMatrixSymbol, is_random
+from sympy.stats.joint_rv_types import JointDistributionHandmade
+from sympy.stats.random_matrix import RandomMatrixPSpace
+from sympy.tensor.array import ArrayComprehension
+
+__all__ = [
+    'CircularEnsemble',
+    'CircularUnitaryEnsemble',
+    'CircularOrthogonalEnsemble',
+    'CircularSymplecticEnsemble',
+    'GaussianEnsemble',
+    'GaussianUnitaryEnsemble',
+    'GaussianOrthogonalEnsemble',
+    'GaussianSymplecticEnsemble',
+    'joint_eigen_distribution',
+    'JointEigenDistribution',
+    'level_spacing_distribution'
+]
+
+@is_random.register(RandomMatrixSymbol)
+def _(x):
+    return True
+
+
+class RandomMatrixEnsembleModel(Basic):
+    """
+    Base class for random matrix ensembles.
+    It acts as an umbrella and contains
+    the methods common to all the ensembles
+    defined in sympy.stats.random_matrix_models.
+    """
+    def __new__(cls, sym, dim=None):
+        sym, dim = _symbol_converter(sym), _sympify(dim)
+        if dim.is_integer == False:
+            raise ValueError("Dimension of the random matrices must be "
+                                "integers, received %s instead."%(dim))
+        return Basic.__new__(cls, sym, dim)
+
+    symbol = property(lambda self: self.args[0])
+    dimension = property(lambda self: self.args[1])
+
+    def density(self, expr):
+        return Density(expr)
+
+    def __call__(self, expr):
+        return self.density(expr)
+
+class GaussianEnsembleModel(RandomMatrixEnsembleModel):
+    """
+    Abstract class for Gaussian ensembles.
+    Contains the properties common to all the
+    gaussian ensembles.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Random_matrix#Gaussian_ensembles
+    .. [2] https://arxiv.org/pdf/1712.07903.pdf
+    """
+    def _compute_normalization_constant(self, beta, n):
+        """
+        Helper function for computing normalization
+        constant for joint probability density of eigen
+        values of Gaussian ensembles.
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Selberg_integral#Mehta's_integral
+        """
+        n = S(n)
+        prod_term = lambda j: gamma(1 + beta*S(j)/2)/gamma(S.One + beta/S(2))
+        j = Dummy('j', integer=True, positive=True)
+        term1 = Product(prod_term(j), (j, 1, n)).doit()
+        term2 = (2/(beta*n))**(beta*n*(n - 1)/4 + n/2)
+        term3 = (2*pi)**(n/2)
+        return term1 * term2 * term3
+
+    def _compute_joint_eigen_distribution(self, beta):
+        """
+        Helper function for computing the joint
+        probability distribution of eigen values
+        of the random matrix.
+        """
+        n = self.dimension
+        Zbn = self._compute_normalization_constant(beta, n)
+        l = IndexedBase('l')
+        i = Dummy('i', integer=True, positive=True)
+        j = Dummy('j', integer=True, positive=True)
+        k = Dummy('k', integer=True, positive=True)
+        term1 = exp((-S(n)/2) * Sum(l[k]**2, (k, 1, n)).doit())
+        sub_term = Lambda(i, Product(Abs(l[j] - l[i])**beta, (j, i + 1, n)))
+        term2 = Product(sub_term(i).doit(), (i, 1, n - 1)).doit()
+        syms = ArrayComprehension(l[k], (k, 1, n)).doit()
+        return Lambda(tuple(syms), (term1 * term2)/Zbn)
+
+class GaussianUnitaryEnsembleModel(GaussianEnsembleModel):
+    @property
+    def normalization_constant(self):
+        n = self.dimension
+        return 2**(S(n)/2) * pi**(S(n**2)/2)
+
+    def density(self, expr):
+        n, ZGUE = self.dimension, self.normalization_constant
+        h_pspace = RandomMatrixPSpace('P', model=self)
+        H = RandomMatrixSymbol('H', n, n, pspace=h_pspace)
+        return Lambda(H, exp(-S(n)/2 * Trace(H**2))/ZGUE)(expr)
+
+    def joint_eigen_distribution(self):
+        return self._compute_joint_eigen_distribution(S(2))
+
+    def level_spacing_distribution(self):
+        s = Dummy('s')
+        f = (32/pi**2)*(s**2)*exp((-4/pi)*s**2)
+        return Lambda(s, f)
+
+class GaussianOrthogonalEnsembleModel(GaussianEnsembleModel):
+    @property
+    def normalization_constant(self):
+        n = self.dimension
+        _H = MatrixSymbol('_H', n, n)
+        return Integral(exp(-S(n)/4 * Trace(_H**2)))
+
+    def density(self, expr):
+        n, ZGOE = self.dimension, self.normalization_constant
+        h_pspace = RandomMatrixPSpace('P', model=self)
+        H = RandomMatrixSymbol('H', n, n, pspace=h_pspace)
+        return Lambda(H, exp(-S(n)/4 * Trace(H**2))/ZGOE)(expr)
+
+    def joint_eigen_distribution(self):
+        return self._compute_joint_eigen_distribution(S.One)
+
+    def level_spacing_distribution(self):
+        s = Dummy('s')
+        f = (pi/2)*s*exp((-pi/4)*s**2)
+        return Lambda(s, f)
+
+class GaussianSymplecticEnsembleModel(GaussianEnsembleModel):
+    @property
+    def normalization_constant(self):
+        n = self.dimension
+        _H = MatrixSymbol('_H', n, n)
+        return Integral(exp(-S(n) * Trace(_H**2)))
+
+    def density(self, expr):
+        n, ZGSE = self.dimension, self.normalization_constant
+        h_pspace = RandomMatrixPSpace('P', model=self)
+        H = RandomMatrixSymbol('H', n, n, pspace=h_pspace)
+        return Lambda(H, exp(-S(n) * Trace(H**2))/ZGSE)(expr)
+
+    def joint_eigen_distribution(self):
+        return self._compute_joint_eigen_distribution(S(4))
+
+    def level_spacing_distribution(self):
+        s = Dummy('s')
+        f = ((S(2)**18)/((S(3)**6)*(pi**3)))*(s**4)*exp((-64/(9*pi))*s**2)
+        return Lambda(s, f)
+
+def GaussianEnsemble(sym, dim):
+    sym, dim = _symbol_converter(sym), _sympify(dim)
+    model = GaussianEnsembleModel(sym, dim)
+    rmp = RandomMatrixPSpace(sym, model=model)
+    return RandomMatrixSymbol(sym, dim, dim, pspace=rmp)
+
+def GaussianUnitaryEnsemble(sym, dim):
+    """
+    Represents Gaussian Unitary Ensembles.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import GaussianUnitaryEnsemble as GUE, density
+    >>> from sympy import MatrixSymbol
+    >>> G = GUE('U', 2)
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> density(G)(X)
+    exp(-Trace(X**2))/(2*pi**2)
+    """
+    sym, dim = _symbol_converter(sym), _sympify(dim)
+    model = GaussianUnitaryEnsembleModel(sym, dim)
+    rmp = RandomMatrixPSpace(sym, model=model)
+    return RandomMatrixSymbol(sym, dim, dim, pspace=rmp)
+
+def GaussianOrthogonalEnsemble(sym, dim):
+    """
+    Represents Gaussian Orthogonal Ensembles.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import GaussianOrthogonalEnsemble as GOE, density
+    >>> from sympy import MatrixSymbol
+    >>> G = GOE('U', 2)
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> density(G)(X)
+    exp(-Trace(X**2)/2)/Integral(exp(-Trace(_H**2)/2), _H)
+    """
+    sym, dim = _symbol_converter(sym), _sympify(dim)
+    model = GaussianOrthogonalEnsembleModel(sym, dim)
+    rmp = RandomMatrixPSpace(sym, model=model)
+    return RandomMatrixSymbol(sym, dim, dim, pspace=rmp)
+
+def GaussianSymplecticEnsemble(sym, dim):
+    """
+    Represents Gaussian Symplectic Ensembles.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import GaussianSymplecticEnsemble as GSE, density
+    >>> from sympy import MatrixSymbol
+    >>> G = GSE('U', 2)
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> density(G)(X)
+    exp(-2*Trace(X**2))/Integral(exp(-2*Trace(_H**2)), _H)
+    """
+    sym, dim = _symbol_converter(sym), _sympify(dim)
+    model = GaussianSymplecticEnsembleModel(sym, dim)
+    rmp = RandomMatrixPSpace(sym, model=model)
+    return RandomMatrixSymbol(sym, dim, dim, pspace=rmp)
+
+class CircularEnsembleModel(RandomMatrixEnsembleModel):
+    """
+    Abstract class for Circular ensembles.
+    Contains the properties and methods
+    common to all the circular ensembles.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Circular_ensemble
+    """
+    def density(self, expr):
+        # TODO : Add support for Lie groups(as extensions of sympy.diffgeom)
+        #        and define measures on them
+        raise NotImplementedError("Support for Haar measure hasn't been "
+                                  "implemented yet, therefore the density of "
+                                  "%s cannot be computed."%(self))
+
+    def _compute_joint_eigen_distribution(self, beta):
+        """
+        Helper function to compute the joint distribution of phases
+        of the complex eigen values of matrices belonging to any
+        circular ensembles.
+        """
+        n = self.dimension
+        Zbn = ((2*pi)**n)*(gamma(beta*n/2 + 1)/S(gamma(beta/2 + 1))**n)
+        t = IndexedBase('t')
+        i, j, k = (Dummy('i', integer=True), Dummy('j', integer=True),
+                   Dummy('k', integer=True))
+        syms = ArrayComprehension(t[i], (i, 1, n)).doit()
+        f = Product(Product(Abs(exp(I*t[k]) - exp(I*t[j]))**beta, (j, k + 1, n)).doit(),
+                    (k, 1, n - 1)).doit()
+        return Lambda(tuple(syms), f/Zbn)
+
+class CircularUnitaryEnsembleModel(CircularEnsembleModel):
+    def joint_eigen_distribution(self):
+        return self._compute_joint_eigen_distribution(S(2))
+
+class CircularOrthogonalEnsembleModel(CircularEnsembleModel):
+    def joint_eigen_distribution(self):
+        return self._compute_joint_eigen_distribution(S.One)
+
+class CircularSymplecticEnsembleModel(CircularEnsembleModel):
+    def joint_eigen_distribution(self):
+        return self._compute_joint_eigen_distribution(S(4))
+
+def CircularEnsemble(sym, dim):
+    sym, dim = _symbol_converter(sym), _sympify(dim)
+    model = CircularEnsembleModel(sym, dim)
+    rmp = RandomMatrixPSpace(sym, model=model)
+    return RandomMatrixSymbol(sym, dim, dim, pspace=rmp)
+
+def CircularUnitaryEnsemble(sym, dim):
+    """
+    Represents Circular Unitary Ensembles.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import CircularUnitaryEnsemble as CUE
+    >>> from sympy.stats import joint_eigen_distribution
+    >>> C = CUE('U', 1)
+    >>> joint_eigen_distribution(C)
+    Lambda(t[1], Product(Abs(exp(I*t[_j]) - exp(I*t[_k]))**2, (_j, _k + 1, 1), (_k, 1, 0))/(2*pi))
+
+    Note
+    ====
+
+    As can be seen above in the example, density of CiruclarUnitaryEnsemble
+    is not evaluated because the exact definition is based on haar measure of
+    unitary group which is not unique.
+    """
+    sym, dim = _symbol_converter(sym), _sympify(dim)
+    model = CircularUnitaryEnsembleModel(sym, dim)
+    rmp = RandomMatrixPSpace(sym, model=model)
+    return RandomMatrixSymbol(sym, dim, dim, pspace=rmp)
+
+def CircularOrthogonalEnsemble(sym, dim):
+    """
+    Represents Circular Orthogonal Ensembles.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import CircularOrthogonalEnsemble as COE
+    >>> from sympy.stats import joint_eigen_distribution
+    >>> C = COE('O', 1)
+    >>> joint_eigen_distribution(C)
+    Lambda(t[1], Product(Abs(exp(I*t[_j]) - exp(I*t[_k])), (_j, _k + 1, 1), (_k, 1, 0))/(2*pi))
+
+    Note
+    ====
+
+    As can be seen above in the example, density of CiruclarOrthogonalEnsemble
+    is not evaluated because the exact definition is based on haar measure of
+    unitary group which is not unique.
+    """
+    sym, dim = _symbol_converter(sym), _sympify(dim)
+    model = CircularOrthogonalEnsembleModel(sym, dim)
+    rmp = RandomMatrixPSpace(sym, model=model)
+    return RandomMatrixSymbol(sym, dim, dim, pspace=rmp)
+
+def CircularSymplecticEnsemble(sym, dim):
+    """
+    Represents Circular Symplectic Ensembles.
+
+    Examples
+    ========
+
+    >>> from sympy.stats import CircularSymplecticEnsemble as CSE
+    >>> from sympy.stats import joint_eigen_distribution
+    >>> C = CSE('S', 1)
+    >>> joint_eigen_distribution(C)
+    Lambda(t[1], Product(Abs(exp(I*t[_j]) - exp(I*t[_k]))**4, (_j, _k + 1, 1), (_k, 1, 0))/(2*pi))
+
+    Note
+    ====
+
+    As can be seen above in the example, density of CiruclarSymplecticEnsemble
+    is not evaluated because the exact definition is based on haar measure of
+    unitary group which is not unique.
+    """
+    sym, dim = _symbol_converter(sym), _sympify(dim)
+    model = CircularSymplecticEnsembleModel(sym, dim)
+    rmp = RandomMatrixPSpace(sym, model=model)
+    return RandomMatrixSymbol(sym, dim, dim, pspace=rmp)
+
+def joint_eigen_distribution(mat):
+    """
+    For obtaining joint probability distribution
+    of eigen values of random matrix.
+
+    Parameters
+    ==========
+
+    mat: RandomMatrixSymbol
+        The matrix symbol whose eigen values are to be considered.
+
+    Returns
+    =======
+
+    Lambda
+
+    Examples
+    ========
+
+    >>> from sympy.stats import GaussianUnitaryEnsemble as GUE
+    >>> from sympy.stats import joint_eigen_distribution
+    >>> U = GUE('U', 2)
+    >>> joint_eigen_distribution(U)
+    Lambda((l[1], l[2]), exp(-l[1]**2 - l[2]**2)*Product(Abs(l[_i] - l[_j])**2, (_j, _i + 1, 2), (_i, 1, 1))/pi)
+    """
+    if not isinstance(mat, RandomMatrixSymbol):
+        raise ValueError("%s is not of type, RandomMatrixSymbol."%(mat))
+    return mat.pspace.model.joint_eigen_distribution()
+
+def JointEigenDistribution(mat):
+    """
+    Creates joint distribution of eigen values of matrices with random
+    expressions.
+
+    Parameters
+    ==========
+
+    mat: Matrix
+        The matrix under consideration.
+
+    Returns
+    =======
+
+    JointDistributionHandmade
+
+    Examples
+    ========
+
+    >>> from sympy.stats import Normal, JointEigenDistribution
+    >>> from sympy import Matrix
+    >>> A = [[Normal('A00', 0, 1), Normal('A01', 0, 1)],
+    ... [Normal('A10', 0, 1), Normal('A11', 0, 1)]]
+    >>> JointEigenDistribution(Matrix(A))
+    JointDistributionHandmade(-sqrt(A00**2 - 2*A00*A11 + 4*A01*A10 + A11**2)/2
+    + A00/2 + A11/2, sqrt(A00**2 - 2*A00*A11 + 4*A01*A10 + A11**2)/2 + A00/2 + A11/2)
+
+    """
+    eigenvals = mat.eigenvals(multiple=True)
+    if not all(is_random(eigenval) for eigenval in set(eigenvals)):
+        raise ValueError("Eigen values do not have any random expression, "
+                         "joint distribution cannot be generated.")
+    return JointDistributionHandmade(*eigenvals)
+
+def level_spacing_distribution(mat):
+    """
+    For obtaining distribution of level spacings.
+
+    Parameters
+    ==========
+
+    mat: RandomMatrixSymbol
+        The random matrix symbol whose eigen values are
+        to be considered for finding the level spacings.
+
+    Returns
+    =======
+
+    Lambda
+
+    Examples
+    ========
+
+    >>> from sympy.stats import GaussianUnitaryEnsemble as GUE
+    >>> from sympy.stats import level_spacing_distribution
+    >>> U = GUE('U', 2)
+    >>> level_spacing_distribution(U)
+    Lambda(_s, 32*_s**2*exp(-4*_s**2/pi)/pi**2)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Random_matrix#Distribution_of_level_spacings
+    """
+    return mat.pspace.model.level_spacing_distribution()