I would like an easy way to run the PCE emulator once it has been created on any arbitrary new sample Iw ould like to examine. Something like this:

#For some modelFunction with three input parameters
pce.build()
newSample = np.array([0,5,2])
emulatorOutput = pce.emulator.sample(newSample)
modelOutput = modleFunction(newSample)
compareOutputs(emulatorOutput, modelOutput)

copy the scirun github pages format as a skeleton for the Uncertainty pages.

The following script produces an x less than -1:

from UncertainSCI.families import JacobiPolynomials

J = JacobiPolynomials(alpha=1.553,beta=2.270)

u = 4.6808507655704545e-05
x = J.fidistinv(u, 0)

Probably a bug in how the degree-0 fast approximation is constructed.

@jab0707 produced a good start, it still needs some sections filled in.

from families import JacobiPolynomials

J = JacobiPolynomials(alpha=0,beta=0)
J.idistinv(0,0)

should be -1, but throws a divide-by-zero error stemming from JacobiPolynomials.idist_medapprox

default_rng only exists in numpy version >= 1.17

For complicated model evaluation usage patterns (e.g., failed runs, parallel runs)

• Tensor product
• Euclidean degree
• L^p sets, p < 1

Implement generic univariate orthogonal polynomials for generic discrete distributions. Finite state space for now, so that we can easily do induced distribution stuff. Should support general probability mass function.

Infinite state space stuff (e.g., Poisson RV's et al) can be done later.

https://pip.pypa.io/en/stable/reference/pip_install/#requirements-file-format

• Numpy: support < 1.14, as well as >= 1.14

PolynomialChaosExpanation.build() doesn't have any way for the user to restart interrupted looping for model calls.

Also, user cannot get WAFP points and run model on their own.

After calling self.MC_samples, quantiles doesn't scale physical samples to appropriate opoly ranges

SimNIBS has a gradient-based sensitivity metric, which is not currently implemented here.

Write basic technical documentation for HyperbolicCrossSet and LpSet.

Make updates on the branch index-set-docs that is already pushed to github. That branch has the TotalDegreeSet docs implemented for reference. See UncertainSCI/indexing.py.

To locally compile the documentation to check your changes, see https://uncertainsci.readthedocs.io/en/latest/dev_docs/HowToTutorial.html#testing-locally. After you re-build the documentation locally, your changes will appear in your local copy of the page https://uncertainsci.readthedocs.io/en/latest/api_docs/spaces.html

there are several warnings in the sphinx build, including missing references. These should trigger a build fail on PR.

Start converting the lowest-level math routines to do some performance comparisons on.

I would like to be able to access the weights of the PCE samples that are used to make the emulator. Something like:

samples = pce.samples
weights = pce.weights
assert len(samples) == len(weights), "There should be one weight per sample"

Here are some example templates:
https://github.com/jacebrowning/template-python/blob/master/README.md
https://github.com/dbader/readme-template
https://gist.github.com/PurpleBooth/109311bb0361f32d87a2

I am trying a minimal installation of UnvertainSCI but it fails.
Flowing the documentation python 3 should be used. The requirements need to be installed with pip and the package itself. The first observation is, that the python version 3.9 will fail to install the requirements. Thus, I use python version 3.8.
To install UncertainSCI, I use the official python 3.8 docker image and follow the instructions from your documentation. This results in the Dockerfile, which is saved in the root folder of this repo.

FROM python:3.8
RUN useradd -ms /bin/bash User # Add a user so we do not run as root
USER User
WORKDIR /home/User

COPY ./ /opt/UncertainSCI  # Let's assume we build from the root folder of the repo
COPY demos /home/User/code/demos # Copy them in a place which is accessible by the user

RUN pip install -r /opt/UncertainSCI/requirements.txt  # Install requirements
RUN pip install /opt/UncertainSCI/UncertainSCI # Install UncertainSCI
CMD python

I can build this Dockerfile, plus minus a few expected warnings

docker build -t uncertainsci ./

From the python console
docker run -it --rm uncertainsci:latest
I try to import UnvertainSCI

>>> import UncertainSCI.distributions
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ModuleNotFoundError: No module named 'UncertainSCI'
>>> 

Which is not available.

Using the same container, but with bash
docker run -it --rm uncertainsci:latest /bin/bash
and reinstalling UncertainSCI, shows first that it is already installed and then that, a reinstallation does not solve the problem.

The question is, where do I go wrong in the installation?

Inputting a float for a quantile level in PolynomialChaosExpansion.quantile produces an error. The intended input is a numpy array, but float should be casted on input.

I am having issues installing the UncertainSCI package in my environment and running the demo examples.

After following the installation instructions in the documentation the UncrertainSCI package does not get installed in the environment.
To clarify, I ran the "pip install ." command without any errors being reported.
Afterwards, I tried running a demo script and ipython throws error when trying to load the packages:

  3 from scipy import sparse as sprs
  4  ##

----> 5 from UncertainSCI.families import JacobiPolynomials, HermitePolynomials, LaguerrePolynomials
6 from UncertainSCI.families import DiscreteChebyshevPolynomials
7 from UncertainSCI.opolynd import TensorialPolynomials

ModuleNotFoundError: No module named 'UncertainSCI'

I tried to install the software on two computers (mac and ubuntu), bith with python 3.8 installed

Any idea what could be the issue?

Thanks for your help!
Jaume

Documentation for

• TotalDegreeSet
• HyperbolicCrossSet
• LpSet

a security alert for kramdown (https://github.com/SCIInstitute/UncertainSCI/network/alert/docs/Gemfile.lock/kramdown/open). Looks like it is a temp file that might be unnecessary.

First is SCIRun--then come up with a more general way to insert models.

• true Gaussian
• Exponential
• two-sided Freud
• one-sided Freud

Setting rcond=None generates error for numpy version < 1.14

PolynomialChaosExpansion.quantile generates a huge amount of data to naively compute stuff.

For python < 3.6, have to use strings passed into open. This causes JacobiPolynomials.fidistinv to fail when trying to create files.

See
https://stackoverflow.com/a/42694113

Implement recurrence and class wrappers in families.py for

• Discrete Chebyshev
• Meixner
• Hahn
• Krawtchouk
• Charlier

Documentation (text + pics walkthrough?) for

• build_pce
• build_pce_normal
• discrete_uniform

Issue solved.

The documentation is incorrect. The 'setup.py' file needs to be run from the root folder of the UncertainSCI tree. In the documentation it currently reads as it should be run from the UncertainSCI folder within the installation

Originally posted by @jcollfont in #83 (comment)

• Slack/Github integration. Send to separate channel?
• Github action build. What tests to run?
• Python version constraints?
• Need a list of dependencies with versions
• Branching model and team/collaborator permissions

Plotting in quantiles demo doesn't properly reshape median arrays, resulting in matplotlib error

We could keep the algorithm code in Python, and just write a C++ wrapper as a SCIRun module. The new looping framework in SCIRun would let the model be filled with whatever output data SCIRun can generate. When the SCIRun part is done, the output of this new module could be displayed with a Qwt graph module (replacing matplotlib).

Implement

• mean
• cov
• stdev
• pdf

methods for NormalDistribution, ExponentialDistribution, and DiscreteUniformDistribution. (For DiscreteUniformDistribution implement pmf instead of pdf.)

import numpy as np
from families import JacobiPolynomials

alpha = -0.95703125
beta = -0.8710937500000002

J = JacobiPolynomials(alpha=alpha,beta=beta)

print(J.idist(-1, 0)) # Should be 0

Outputs [0.11839635] instead of 0.

This also causes issues downstream when inverting these distributions. (Does the matlab code work for this case?)

User specification of parameter samples not exposed in PolynomialChaosExpansion.build_pce_wafp

Also, add Mac and Windows to OSes tested

The distribution bounds does not seem to actually scale the distribution from its default [0,1]. Example code below produces pce.samples that are [0,1].

dimension = 3
alpha = 2.#a = b = 2 makes a normal dist
beta = 2.
bounds = np.zeros([2,3])
bounds[0,0],bounds[1,0] = -3, 3
bounds[0,1],bounds[1,1] = -3, 3
bounds[0,2],bounds[1,2] = -3, 3

dist = BetaDistribution(alpha=alpha, beta=beta, dim=dimension,domain = bounds)

Documentation for

• ExponentialDistribution
• GaussianDistribution
• DiscreteChebyshevDistribution