nrc-cnrc / metrolopy Goto Github PK

A function normalizing the gummy to the corresponding SI unit would be nice, i.e., gummy.x in SI and gummy.U in SI

Hi,

I noticed that gummy.create() mutates its input covariance matrix.
This leads to unexpected behavior:

from metrolopy import gummy
import numpy as np

val = [1., 2.]
cov = np.array([[0.3, 0.1], [0.1, 0.2]])

print("cov before gummy creation:\n", cov)
print()

a, b = gummy.create(val, covariance_matrix=cov)

print("cov after gummy creation:\n", cov)
print()
print("a + b after first gummy creation ", a + b)

a, b = gummy.create(val, covariance_matrix=cov)

print("a + b after second gummy creation ", a + b)

cov before gummy creation:
 [[0.3 0.1]
 [0.1 0.2]]

cov after gummy creation:
 [[1.         0.40824829]
 [0.40824829 1.        ]]

a + b after first gummy creation  3.00(84)
a + b after second gummy creation  3.0(17)

I think this line is the problem:

Is the mutation necessary?
A workaround is to pass a deepcopy of the covariance matrix.

Hi there!

Is there a preferred way to cite this package?
I did not find instructions on that.

By the way, the search field over at https://nrc-cnrc.github.io/MetroloPy does not work for me, neither in Firefox nor Brave-Browser (it just hangs).

Hello,

I'm new to MetroloPy, trying to handle complex numbers with uncertainty.
I've noticed that the uc.angle() function fails on jummy objects with

~\Miniconda3\envs\default\lib\site-packages\metrolopy\dfunc.py in tofloat(self)
    193         # this should return a copy of self with the x and u properties
    194         # converted to float values
--> 195         raise NotImplementedError()
    196
    197     @classmethod

NotImplementedError:

As far as I can tell this is from MetroloPy/dfunc.py

try_fconvert = True
def _call(f,*x):
    if try_fconvert:
        try:
            return f(*x)
        except:
--->        x = [a.tofloat() if isinstance(a,Dfunc) else float(a) for a in x]
            return f(*x)

    return f(*x)

since the initial return f(*x) throws a KeyError stemming from MetroloPy/dfunc.py:

    def __array_ufunc__(self,ufunc,method,*args,**kwds):
        if method != '__call__':
            return None
        
        try:
--->        return _call(lambda *x: self._apply(ufunc,ddict[ufunc],*x), *args)
        except KeyError:
            try:
                return _call(fdict[ufunc],*args)
            except KeyError:
                return None

since ddict[np.angle] is not defined.

Hi,

the docs don't explicitly mention this, but from looking into the source code I take it that nonlinear dependencies are implemented by linear approximation, is that correct?

For binary operations between two correlated gummys dof is not calculated properly, e.g. (x+x).dof != (2*x).dof

As far as I know standard conform spacing is:
4.899 7 kΩ ± 1.1 Ω
4.899 68 kΩ ± 0.1 Ω
4.899 681 kΩ ± 0.01 Ω

Currently it is in the first case like this:
4.8997 kΩ ± 1.1 Ω

so the first should be: "nr < 4 and nl < 4: " and "if nr >= 4: " and " if nl >= 4:".

Modul is ummy.py

elif self.thousand_spaces:

if nr < 4 and nl < 4:
    return s + ellipses

s = list(s)
if nr >= 4:
    for i in range(int(nr/3)):
        s.insert(d + i + (i+1)*3 + 1, sp)
if nl >= 4:
    for i in range(int(nl/3)):
        s.insert(d - (i+1)*3, sp)

I love your great work with MetrolPy!
I'm sorry, for my bad contribution quality - I'm a rooky in this issue. But I'll soon learn how to to proper issues, push, pulls and what ever exist to contribute good way.

According to the docs the utype property of a gummy should accept an arbitrary string, but this only works for single characters, e.G. A/B (which are obvious choices for a utype).
I tried grouping uncertainties according to the source (DUT, REF, ...) and noticed that the gummy.ufrom() method returned a value of 0. Looking at the code, it seems that only single characters are supported. Here is a minimal example:

import metrolopy as uc

x_1 = uc.gummy(10.0, 1, utype='A')
x_2 = uc.gummy(20.0, 2, utype='DUT')
y = x_1 - x_2
print(y.ufrom('A'))
print(y.ufrom('DUT'))

The definition of "significance" seems to be wrong. According to the docs:

“s” or “significance”: the sensitivity coefficient (below) multiplied by the standard uncertainty, displayed by default

The significance is in fact calculated as x.u / result.u (or v[0]/yu in budget.py)

If I am not mistaken, the correct text should therefore be:

“s” or “significance”: the sensitivity coefficient (below) multiplied by the standard uncertainty divided by the combined standard uncertainty, displayed by default

Hey,

since 0.6.2 the names of uncertainties are omitted by the budget method.

Here's a minimal example:

import metrolopy as uc
x_1 = uc.gummy(42, 0, name='A')
x_2 = uc.gummy(42, 1, name='B')
y = x_1 - x_2
print(y.budget([x_1, x_2]))

output for 0.6.1

Component Value    u |dy/dx|     s
        B  42.0  1.0     1.0  1.00
        A    42    0     nan   nan
        y   0.0  1.0

output for 0.6.2

Component Value    u |dy/dx|     s
     x[2]  42.0  1.0     1.0  1.00
     x[1]    42    0     0.0     0
        y   0.0  1.0

Please notice the 'Component' column

Any operation (e.g. multiplication) of a gummy with a complex number raises an exception. It should rather create a jummy.

This probably require only some additional conditional checks in the ummy code to work and would lead to a more expectable behaviour.

If the value 0°C is entered it is automatically converted to - 273.15(15) °C. A Value slightly above ist giving the correct result.
Enclosed my code:

import metrolopy as uc

UUT = uc.gummy(0, 0.15, uunit="°C", unit="°C")
Out[4]: -273.15(15) °C

UUT = uc.gummy(0, 0.15, uunit="degC", unit="degC")
Out[8]: -273.15(15) °C

UUT = uc.gummy(0.1, 0.15, uunit="degC", unit="degC")
Out[10]: 0.10(15) °C

There are at least two bugs in unitparser.py:

• Giving a unit as e.g. "V**(0.5)" will attempt to typecast "(0.5)" as float, when it should be typecasting "0.5" (line 212, 201, etc.). It seems to currently impossible to set fractional exponents.
• isspace() is misspelled on several occasions (as ispace()).

In the budget values are displayed with names if uunit of output variable is set to % or ppm.

Adding show_name = False to budget.py solved this issue for me:

Result:

The standard uncertainty of the uniform distribution is not correct if it is calculated by upper and lower limit. I think you missed a factor 2 in the denominator.

First of all, thank you for uploading this package, I was look for something like this for a while!

When testing the package (v0.5.4) on a convoluted model function which had a 10**(...) term I found that the uncertainty does not seem to be calculated correctly (double checking with a calculation by hand and the uncertainties package yielded significantly different results). By accident, I changed the integer 10 to a float 10.0**(...) which solved the problem!

Here is a minimal example:

>>> a = uc.gummy(1, u=0.1)
>>> 10**a

10.0 +/- 2.0

vs.

>>> a = uc.gummy(1, u=0.1)
>>> 10.0**a

10.0 +/- 2.3

Although the following expressions should be equivalent results differ. Only the latter is correct.

tmp = uc.gummy(uc.UniformDist(lower_limit=6,upper_limit=9),unit='pA')
uc.gummy.simulate([tmp],n=1e7)
tmp.hist(p=0.99)

tmp = uc.gummy(uc.UniformDist(center=7.5,half_width=1.5),unit='pA') 
uc.gummy.simulate([tmp],n=1e7)
tmp.hist(p=0.99)

Hi,
While trying to validate metrolopy (v0.6.1) with example S9 from EA-4/02 M: 2013, I noticed that an BudgetWarning is raised for uncertainties with a value 0, when trying to create a budget. I don't want to post the whole code so here is a minimal example showcasing this:

import metrolopy as uc

x_1 = uc.gummy(42, 0)
x_2 = uc.gummy(42, 1)
y = x_1 - x_2
print(y.budget([x_1, x_2]))

the traceback is:

gummy.py:2070: BudgetWarning: the x variables are over determined; they cannot all be taken as independant variables
  return Budget(self,xlist,**kwds)
budget.py:443: RuntimeWarning: invalid value encountered in double_scalars
  d = [p*yu/q.u for p,q in zip(s,x)]
Component Value    u |dy/dx|     s
     x[2]  42.0  1.0     1.0  1.00
     x[1]    42    0     nan   nan
        y   0.0  1.0

This is by itself not a problem, since the calculation still seems to be correct and the warnings are easily captured. I just wonder if this is an intended behavior?

Newer versions of matplotlib raise a depreciation warning for the hist normed keyword argument ("use the density keyword argument instead") when gummy.hist() is executed.

Here is a suggestion for a Microsoft Word export of budget and frequency distribution. Might be interesting for people who don't know Latex.

Result

SourceCode

from docx import Document
import matplotlib
from docx.enum.section import WD_ORIENT, WD_SECTION
from docx.shared import Mm
def budget2word(budget,file,output=None):    
    df = budget.df_str
    doc = Document()
    section = doc.sections[-1]
    section.page_height = Mm(297)
    section.page_width = Mm(210)
    section.left_margin = Mm(25.4)
    section.right_margin = Mm(25.4)
    section.top_margin = Mm(25.4)
    section.bottom_margin = Mm(25.4)
    section.header_distance = Mm(12.7)
    section.footer_distance = Mm(12.7)
    t = doc.add_table(df.shape[0]+1, df.shape[1])
    t.style = doc.styles['Colorful List Accent 2']
    for j in range(df.shape[-1]):
        t.cell(0,j).text = df.columns[j]
    for i in range(df.shape[0]):
        for j in range(df.shape[-1]):
            t.cell(i+1,j).text = df.values[i,j] 
    if output is not None:
        matplotlib.pyplot.clf()
        uc.gummy.simulate([output],n=5e5)
        output.hist(p=0.95, density=False)
        matplotlib.pyplot.gca().set_ylabel("frequency distribution")
        output.k = 1
        matplotlib.pyplot.savefig(file.split(".")[0]+".png")
        doc.add_picture(file.split(".")[0]+".png")
    doc.save(file)

Execution

fname = 'budgets/budget.docx'
budget2word(budget,fname,output=outputVariable)

I am missing a feature for automatic calculation of uncertainty by a given array of observations similliar to GUM Type A Bayes. Please find an example for student distribution assumptions below.

from scipy.stats import t
from scipy import special
import numpy as np

def u(x):
    confidence = special.erf(1/np.sqrt(2)) # single standard deviation 68 percent
    return t.ppf(1-(1-confidence)/2, len(x)-1)*x.std(ddof=1)/np.sqrt(len(x))

def mean(x):
    return np.mean(x)

An incorrect negative exponent is selected for scientific notation when printing a value that has no uncertainty and has a mantissa exactly equal to 1.0, e.g. 1.0e-10 displays as 10.0e-11.

Github supports CITATION.cff files, so I was thinking you might want to add one:
https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-citation-files

Hello,
I think I have found a typo...