funcsim 0.1.4__py3-none-any.whl

funcsim/__init__.py

@@ -0,0 +1,54 @@
+import sys
+import os
+sys.path.append(os.path.dirname(os.path.realpath(__file__)))
+
+from core import simulate
+
+from dependence import covtocorr
+from dependence import spearman
+from dependence import MvNorm
+from dependence import MvKde
+from dependence import CopulaGauss
+from dependence import CopulaStudent
+from dependence import CopulaClayton
+from dependence import CopulaGumbel
+
+from imanconover import imanconover
+
+from shrinkage import shrink
+from nearby import nearestpd
+
+from edf import edf
+
+from kde import Kde
+
+from ecdfgof import kstest
+from ecdfgof import adtest
+from ecdfgof import cvmtest
+
+from shapiro import swtest
+
+from distfit import fit
+from distfit import compare
+
+from utests import utests
+
+from screen import screen
+
+from cpt import cpt, utilPower, utilNormLog, weightTK, weightPrelec1
+from cpt import weightPrelec2, cptBV
+
+from eut import eut, utilIsoelastic
+
+from plotting import fan, twofuncs, histpdf, dblscat, qqplot, show
+
+def version():
+    """
+    Return the current version of the funcsim package.
+
+    Returns
+    -------
+    str
+        The version string of the package (e.g., '0.1.4').
+    """
+    return "0.1.4"

funcsim/addist.py

@@ -0,0 +1,74 @@
+"""
+Distributions of the Anderson-Darling statistic.
+
+After doi:18637/jss.v009.i02.
+
+Original Work (scikit-gof) Copyright (c) 2015 Wojciech Ruszczewski <scipy@wr.waw.pl>
+
+Modified Work Copyright (c) 2020 h-bryant
+"""
+from __future__ import division
+
+from numpy import exp, log, sqrt
+from scipy.stats import rv_continuous
+
+from vect import vectorize
+
+
+class ad_unif_gen(rv_continuous):
+    """
+    Approximate distribution of the uniform Anderson-Darling statistic
+    (with the hypothesized distribution continuous and fully specified).
+    """
+    def _argcheck(self, samples):
+        return samples > 0
+
+    @vectorize(otypes=(float,))
+    def _cdf(self, statistic, samples):
+        if samples == 1:
+            # Exact distribution for a single sample (a bit more precise than
+            # the approximation). See doi:10.1214/aoms/1177704850 equation 8.
+            if statistic <= log(4) - 1:
+                return 0.
+            else:
+                return sqrt(1 - 4 * exp(-1 - statistic))
+        pinf = ad_unif_inf(statistic)
+        return pinf + ad_unif_fix(samples, pinf)
+
+
+ad_unif = ad_unif_gen(a=0, name='ad-unif', shapes='samples')
+
+
+def ad_unif_inf(statistic):
+    """
+    Approximates the limiting distribution to about 5 decimal digits.
+    """
+    z = statistic
+    if z < 2:
+        return (exp(-1.2337141 / z) / sqrt(z) *
+                                (2.00012 + (.247105 - (.0649821 - (.0347962 -
+                                (.011672 - .00168691 * z) * z) * z) * z) * z))
+    else:
+        return exp(-exp(1.0776 - (2.30695 - (.43424 - (.082433 -
+                                (.008056 - .0003146 * z) * z) * z) * z) * z))
+
+
+g1 = lambda x: sqrt(x) * (1 - x) * (49 * x - 102)
+g2 = lambda x: (-.00022633 + (6.54034 - (14.6538 - (14.458 -
+                                (8.259 - 1.91864 * x) * x) * x) * x) * x)
+g3 = lambda x: (-130.2137 + (745.2337 - (1705.091 - (1950.646 -
+                                (1116.36 - 255.7844 * x) * x) * x) * x) * x)
+
+
+def ad_unif_fix(samples, pinf):
+    """
+    Corrects the limiting distribution for a finite sample size.
+    """
+    n = samples
+    c = .01265 + .1757 / n
+    if pinf < c:
+        return (((.0037 / n + .00078) / n + .00006) / n) * g1(pinf / c)
+    elif pinf < .8:
+        return ((.01365 / n + .04213) / n) * g2((pinf - c) / (.8 - c))
+    else:
+        return g3(pinf) / n

funcsim/conversions.py

@@ -0,0 +1,203 @@
+from typing       import TypeVar, Union, Sequence, Any
+import numpy      as np
+import pandas     as pd
+import xarray     as xr
+from numpy.typing import NDArray
+
+T = TypeVar("T")
+
+VectorLike = Union[
+    Sequence[T],         # list[T], tuple[T], etc.
+    NDArray[Any],        # np.NDArray of any dtype (runtime shape not enforced)
+    pd.Series,           # 1‑D pandas Series
+    pd.DataFrame,        # 1‑D pandas DataFrame
+    xr.DataArray         # 1‑D xarray DataArray
+]
+
+ArrayLike = Union[
+    NDArray[Any],        # np.NDArray of any dtype (runtime shape not enforced)
+    pd.DataFrame,        # 2‑D pandas Series
+    xr.DataArray         # 2‑D xarray DataArray
+]
+
+
+def vlValidate(vl: VectorLike) -> bool:
+    """
+    Validate if the input is a vector-like object.
+
+    Parameters
+    ----------
+    vl : VectorLike
+        The object to validate.
+
+    Returns
+    -------
+    bool
+        True if the input is a vector-like object, False otherwise.
+    """
+    if isinstance(vl, (list, tuple, pd.Series)):
+        return True
+    elif isinstance(vl, np.ndarray):
+        a = np.asarray(vl)
+        if a.ndim > 2:
+            return False
+        if a.ndim == 2:
+            if not (a.shape[0] == 1 or a.shape[1] == 1):
+                return False
+        return True
+    elif isinstance(vl, xr.DataArray):
+        a = np.asarray(vl)
+        if a.ndim > 2:
+            return False
+        if a.ndim == 2:
+            if not (a.shape[0] == 1 or a.shape[1] == 1):
+                return False
+        return True
+    elif isinstance(vl, pd.DataFrame):  
+        a = np.asarray(vl)
+        if a.ndim > 2:
+            return False
+        if a.ndim == 2:
+            if not (a.shape[0] == 1 or a.shape[1] == 1):
+                return False
+        return True            
+    return False
+    
+
+def vlToArray(vl: VectorLike) -> NDArray:
+    """
+    Convert a vector-like object to a 1-D NumPy array.
+
+    Parameters
+    ----------
+    vl : VectorLike
+        The vector-like object to convert.
+
+    Returns
+    -------
+    NDArray
+        The converted 1-D NumPy array.
+    """
+    if not vlValidate(vl):
+        raise ValueError("argument passed is not a vector-like object")
+    if isinstance(vl, (list, tuple)):
+        a = np.array(vl)
+    elif isinstance(vl, pd.Series):
+        a = vl.to_numpy()
+    elif isinstance(vl, xr.DataArray):
+        a = vl.values
+    else:
+        a = np.asarray(vl)
+    return a.flatten()  # Ensure the array is 1-D
+
+
+def alValidate(al: ArrayLike) -> bool:
+    """
+    Validate if the input is a 2-D array-like object.
+
+    Parameters
+    ----------
+    al : ArrayLike
+        The object to validate.
+
+    Returns
+    -------
+    bool
+        True if the input is a array-like object, False otherwise.
+    """
+    if isinstance(al, np.ndarray):
+        a = np.asarray(al)
+    elif isinstance(al, xr.DataArray):
+        a = np.asarray(al)
+    elif isinstance(al, pd.DataFrame):  
+        a = np.asarray(al)
+    else:
+        return False
+    if a.ndim != 2:
+        return False
+    return True
+
+
+def alToArray(al: ArrayLike) -> NDArray:
+    """
+    Convert an array-like object to a 2-D NumPy array.
+
+    Parameters
+    ----------
+    al : ArrayLike
+        The array-like object to convert.
+
+    Returns
+    -------
+    NDArray
+        The converted 2-D NumPy array.
+    """
+    if not alValidate(al):
+        raise ValueError("argument passed is not an array-like object")
+    if isinstance(al, pd.DataFrame):
+        a = al.to_numpy()
+    elif isinstance(al, xr.DataArray):
+        a = al.values
+    else:  # Assume it's a NumPy array
+        a = np.asarray(al)
+    return a
+
+
+def vlCoords(vl: VectorLike) -> pd.Index:
+    """
+    Get or create coordinates for a vector-like object.
+
+    Parameters
+    ----------
+    vl : VectorLike
+        The vector-like object to convert.
+
+    Returns
+    -------
+    pandas.Index
+        A pandas index with coordinates corresponding to the vector-like object.
+    """
+    if not vlValidate(vl):
+        raise ValueError("argument passed is not a vector-like object")
+    if isinstance(vl, (list, tuple)):
+        return pd.Index(list(range(max(shape(vl)))))
+    if isinstance(vl, (np.ndarray)):
+        if vl.ndim == 1:
+            return pd.Index(list(range(len(vl))))
+        if vl.ndim == 2:
+            if vl.shape[0] == 1:
+                return pd.Index(list(range(vl.shape[1])))
+            if vl.shape[1] == 1:
+                return pd.Index(list(range(vl.shape[0])))
+    if isinstance(vl, pd.Series):
+        return vl.index
+    if isinstance(vl, xr.DataArray):
+        dim_size_to_name = dict(zip(vl.shape, vl.dims))
+        longest_dim = max(dim_size_to_name.keys())
+        ret = vl.coords[dim_size_to_name[longest_dim]]
+        return pd.Index(ret)
+
+
+def alColNames(al: ArrayLike) -> pd.Index:
+    """
+    Get or create column names from an array-like object.
+
+    Parameters
+    ----------
+    al : ArrayLike
+        The array-like object to process.
+
+    Returns
+    -------
+    pandas.Index
+        Column names of the array-like object.
+    """
+    if not alValidate(al):
+        raise ValueError("argument passed is not an array-like object")
+    if isinstance(al, pd.DataFrame):
+        return al.columns
+    if isinstance(al, xr.DataArray):
+        return al.coords[al.dims[-1]]
+    if isinstance(al, np.ndarray):
+        return pd.Index([f"v{i}" for i in range(al.shape[1])])
+    raise ValueError("Unsupported array-like type")

funcsim/core.py

@@ -0,0 +1,279 @@
+import sys
+from copy import deepcopy as copy
+import numpy as np
+import pandas as pd
+import xarray as xr
+import multicore
+import rdarrays
+from scipy import stats
+from collections.abc import Callable, Generator
+from typing import Optional
+import inspect
+
+
+def _get_arg_count(func):
+    sig = inspect.signature(func)
+    params = sig.parameters.values()
+
+    # Count only parameters that are positional or keyword
+    # (excluding *args and **kwargs)
+    return sum(
+        1 for p in params
+        if p.kind in (inspect.Parameter.POSITIONAL_ONLY,
+                      inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                      inspect.Parameter.KEYWORD_ONLY)
+    )
+
+
+def _checkhist0(hist0):
+    # check that user's hist0 seems sane.  Return list of variable names
+    # in hist0 order.
+
+    if isinstance(hist0, xr.DataArray) is False:
+        raise ValueError('"hist0" must be an xarray.DataArray')
+
+    # check that hist0 has the right dimension names 
+    hist0Coords = hist0.coords
+    if not len(hist0Coords) == 2:
+        raise ValueError('"hist0" must have exactly two dimensions')
+    if not ("variables" in hist0Coords.keys() and
+            "steps" in hist0Coords.keys()):
+        raise ValueError('"hist0" must have dimensions "variables" and "steps"')
+    
+    # Check for an appropriate index for the 'variables' dimension
+    stepsCoords = hist0Coords["steps"]
+    if not (np.issubdtype(stepsCoords.dtype, np.integer) or
+            isinstance(stepsCoords.to_index(), pd.PeriodIndex)):
+        raise ValueError('"hist0" must have either an integer index or a '
+                         'pandas PeriodIndex for the "steps" dimension')
+
+    return list(hist0Coords["variables"])
+
+
+def _checkf(f, data0):
+    # Count number of times 'f', and any code 'f' invokes, calls 'next(draw)'
+    # If 'data0' is None, infer that 'f' is the 'trial' func for a cross-sec sim
+    # If 'data0' is a xr.DataArray, infer that 'f' is 'step' for rec. dyn. sim
+    # Also, check that f returns something that makes sense.
+    fakeugen = _countgen()
+
+    # check that 'f' returns a dict
+    out = f(fakeugen, data0)
+    if type(out) != dict:
+        raise ValueError('"f" function must return a dict')
+
+    # check that the dict returned by 'f' has variable names as keys
+    varnames = list(out.keys())
+    if sum(1 if type(k) is str else 0 for k in varnames) < len(varnames):
+        raise ValueError('The keys of the dictionary returned by "f" must be '
+                         'variable names as strings')
+
+    calls = int(round((next(fakeugen) - 0.5) * 10**4))
+    return calls, varnames
+
+
+def _countgen():
+    # dummy generator for counting calls but always returning approximately 0.5.
+    i = 0
+    while i < int(10000):
+        yield 0.5 + float(i) * 10**-4
+        i += 1
+
+
+def _makewgen(w, r):
+    # given an array 'w' of indep. draws, where rows reflect variables
+    # and columns reflect trials, make a generator for trial 'r' tha emits
+    # a number of draws equal to the number of RVs
+    i = 0
+    while i < w.shape[0]:
+        yield w[i, r]
+        i += 1
+
+
+def _strat(R):
+    # stratified sampling for a single uniformly distributed random variable.
+    # 'R' (an int) is the number of draws to perform
+    # returns a numpy array of floats, each in the interval [0, 1).
+    draws = (np.arange(0, R) + np.random.uniform(0.0, 1.0, R)) / float(R)
+    np.random.shuffle(draws)  # warning: mutating 'draws'
+    return draws
+
+
+def _mcs(K, R):
+    # Monte Carlo sampling.  For each of K independent uniform (over the
+    # unit interval) random variables, create a sample of length R.
+    # 'K' (an int) is the number of variables
+    # 'R' (an int) is the number of trials
+    # returns a KxR numpy array containing draws
+    return np.concatenate([[np.random.uniform(0.0, 1.0, R)]
+                           for i in range(K)], axis=0)
+
+
+def _lhs(K, R):
+    # Latin hypercube sampling.  For each of K independent uniform (over the
+    # unit interval) random variables, create a stratified sample of length R.
+    # 'K' (an int) is the number of variables
+    # 'R' (an int) is the number of trials
+    # returns a KxR numpy array containing draws
+    return np.concatenate([[_strat(R)] for i in range(K)], axis=0)
+
+
+def _extendIndex(idx, nNewSteps):
+    # extend a 'steps' index; should work for ints or pd.Period
+    if len(idx) == 0:  # no previous index; just use integers for the new index
+        return list(range(nNewSteps))
+    newIdx = list(idx)
+    [newIdx.append(newIdx[-1] + 1) for i in range(nNewSteps)]
+    return newIdx
+
+
+def simulate(f: Callable[[Generator[int, float, None],
+                          Optional[rdarrays.RDdata]],
+                       dict[str, float]],
+             ntrials: Optional[int] = 500,
+             nsteps: Optional[int] = 1,
+             hist0: Optional[xr.DataArray] = None,
+             multi: Optional[bool] = False,
+             seed: Optional[int] = 6,
+             stdnorm: Optional[bool] = False,
+             sampling: Optional[str] = 'lh'
+             ) -> xr.DataArray:
+    """
+    Stochastic simulation.
+
+    Parameters
+    ----------
+    f : function
+        Function that performs a single trial in a static simulation or a s
+        single step through time in a recursive dynamic simulation.  Should take
+        'ugen' as a first argument in either case, where 'ugen' will be a
+        generator that emits standard uniform draws (or standard normal draws,
+        if `stdnorm` is True) that will be passed to f by ``simulate``.
+        In the case of a recursive dynamic simulation that employs past values,
+        f should take 'data' as a second argument, where this will be a type of
+        array that is also provided by ``simulate.`` This function should return
+        a dict with variable names (as strings) as keys and values for those
+        variables (as floats) as values.
+    ntrials : int, optional
+        The number of trials to perform.  Default is 500.
+    nsteps : int, optional
+        The number of steps to perform in each trial.  Default is 1.
+    hist0 : xarray.DataArray, optional
+        Initial and/or historical data relevant to the simulation.
+        Should have dimensions 'variables' and 'steps'.  Any lagged values
+        needed (recalled) by `f` must be in `hist0`.  The 'steps' dimension
+        should have either an integer index or a pandas PeriodIndex.
+    multi : bool, optional
+        Use multiple processes/cores for the simulation. Default is False.
+    seed : int, optional
+        Seed for pseudo-random number generation. Default is 6.
+    stdnorm : book, optional
+        If False, ``next(draw)`` within `trialf` will return standard uniform
+        random draws. If True, ``next(draw)`` will return standard normal draws.
+        Default is False.
+    sampling : {'lh', 'mc'}, optional
+        If 'lh', Latin Hypercube sampling is employed.  If 'mc', simple
+        Monte Carlo sampling is employed.  Default is 'lh'.
+
+    Returns
+    -------
+    xarray.DataArray
+        3-D xarray.DataArray with dimensions 'trials', 'variables', and 'steps'.
+    """
+    if hist0 is not None:
+        _checkhist0(hist0)
+
+        # check that we know how to cope with the types for the 'steps' index
+        sidx = hist0.indexes['steps']
+        if len(sidx) > 0:
+            if not type(sidx[0]) in [pd.Period, np.int64]:
+                raise ValueError("'hist0' should have either an integer index"
+                                 " or a pandas.PeriodIndex for the 'steps' "
+                                 "dimension.")
+    else:
+        sidx = []
+        # create an empty hist0.
+        variables = np.array([], dtype=str)
+        steps = np.array([], dtype=int)
+        hist0 = xr.DataArray(
+            data=np.empty((0, 0)),
+            dims=("steps", "variables"),
+            coords={"steps": steps, "variables": variables}
+        )
+
+    # check for 'f'
+    if not isinstance(f, Callable):
+        raise ValueError('"f" must be a callable function')
+
+    # infer number of arguments in 'f'.  If it takes only a single arg, wrap it
+    # in an outer func that takes "hist" as a second arg
+    numb_f_args = _get_arg_count(f)
+    if numb_f_args == 1:
+        stepf = lambda draw, hist: f(draw)
+    elif numb_f_args == 2:
+        stepf = f
+    else:
+        raise ValueError('"f" should take two arguments at most')
+     
+    # indexes for the final output xr.DataArray
+    varNames = hist0.indexes['variables']
+    namePositionsPrelim = {nm: i for i, nm in enumerate(varNames)}
+    stepLabels = _extendIndex(sidx, nsteps)
+
+    # create example data object in which data for one trail can accumulate
+    dataPrelim = rdarrays.RDdata(hist0.to_masked_array(),
+                                 nsteps, namePositionsPrelim)
+
+    # infer number of random vars reflected in 'step' fucntion
+    # and the variable names being returned by 'step' and their order
+    rvs, stepfNames = _checkf(stepf, copy(dataPrelim))
+
+    # specify that the data objects that accumulate data for each trial
+    # will reflect the union of the variables in 'hist0' and the variables
+    # returned by 'step'
+    # breakpoint()
+    varNamesList = list(varNames)
+    if stepfNames == varNamesList:
+        finalNames = varNamesList
+        finalHist0 = hist0
+    else:
+        finalNames = list(set(varNamesList).union(set(stepfNames)))
+        finalHist0 = hist0.copy()
+        finalHist0 = finalHist0.reindex(variables=finalNames, fill_value=np.nan)
+
+    # create a DataArray to hold the data for one trial
+    # create example data object in which data for one trail can accumulate
+    namePositions = {nm: i for i, nm in enumerate(finalNames)}
+    data = rdarrays.RDdata(finalHist0.to_masked_array(), nsteps, namePositions)
+
+    # draws for all RVs in all time steps, w/ sampling stratified across trials
+    if rvs > 0:
+        np.random.seed(seed)
+        if sampling == 'lh':    
+            u = _lhs(rvs * nsteps, ntrials)  # np.array: (rvs*steps) x trials
+        elif sampling == 'mc':  
+            u = _mcs(rvs * nsteps, ntrials)  # monte carlo
+        else:
+            raise ValueError('sampling must be "lh" or "mc"')
+        w = stats.norm.ppf(u) if stdnorm is True else u
+
+    def trial(r):
+        wgen = _makewgen(w, r) if rvs > 0 else None  # 'w' gener. for trial 'r'
+        # perform all time steps for one trial
+        # return _recurse(f=lambda x: step(x, wgen), x0=copy(data), S=steps)
+        dataWorking = copy(data)
+        for s in range(nsteps):
+            # step 's' of trial 'r'
+            dataWorking.append(stepf(wgen, dataWorking))
+        return dataWorking
+
+    # create and return 3-D output DataArray, with new dimension 'trials'
+    if multi is True:
+        out = multicore.parmap(lambda r: trial(r)._a, range(ntrials))
+    else:
+        out = [trial(r)._a for r in range(ntrials)]
+
+    prelim = xr.DataArray(out, coords=[('trials', list(range(ntrials))),
+                                       ('variables', finalNames),
+                                       ('steps', stepLabels)])
+    return prelim.transpose('trials', 'variables', 'steps')