1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
# -*- coding: utf-8 -*-
"""
pint.measurement
~~~~~~~~~~~~~~~~
:copyright: 2016 by Pint Authors, see AUTHORS for more details.
:license: BSD, see LICENSE for more details.
"""
from __future__ import division, unicode_literals, print_function, absolute_import
from .compat import ufloat
from .formatting import _FORMATS, siunitx_format_unit
from .quantity import Quantity
MISSING = object()
class Measurement(Quantity):
"""Implements a class to describe a quantity with uncertainty.
:param value: The expected value of the measurement
:type value: pint.Quantity or any numeric type
:param error: The error or uncertainty of the measurement
:type error: pint.Quantity or any numeric type
"""
def __new__(cls, value, error, units=MISSING):
if units is MISSING:
try:
value, units = value.magnitude, value.units
except AttributeError:
# if called with two arguments and the first looks like a ufloat
# then assume the second argument is the units, keep value intact
if hasattr(value, "nominal_value"):
units = error
error = MISSING # used for check below
else:
units = ''
try:
error = error.to(units).magnitude
except AttributeError:
pass
if error is MISSING:
mag = value
elif error < 0:
raise ValueError('The magnitude of the error cannot be negative'.format(value, error))
else:
mag = ufloat(value, error)
inst = super(Measurement, cls).__new__(cls, mag, units)
return inst
@property
def value(self):
return self._REGISTRY.Quantity(self.magnitude.nominal_value, self.units)
@property
def error(self):
return self._REGISTRY.Quantity(self.magnitude.std_dev, self.units)
@property
def rel(self):
return float(abs(self.magnitude.std_dev / self.magnitude.nominal_value))
def __reduce__(self):
# See notes in Quantity.__reduce__
from . import _unpickle
return _unpickle, (Measurement, self.magnitude, self._units)
def __repr__(self):
return "<Measurement({0:.2f}, {1:.2f}, {2})>".format(self.magnitude.nominal_value,
self.magnitude.std_dev,
self.units)
def __str__(self):
return '{0}'.format(self)
def __format__(self, spec):
# special cases
if 'Lx' in spec: # the LaTeX siunitx code
# the uncertainties module supports formatting
# numbers in value(unc) notation (i.e. 1.23(45) instead of 1.23 +/- 0.45),
# which siunitx actually accepts as input. we just need to give the 'S'
# formatting option for the uncertainties module.
spec = spec.replace('Lx','S')
# todo: add support for extracting options
opts = 'separate-uncertainty=true'
mstr = format( self.magnitude, spec )
ustr = siunitx_format_unit(self.units)
ret = r'\SI[%s]{%s}{%s}'%( opts, mstr, ustr )
return ret
# standard cases
if 'L' in spec:
newpm = pm = r' \pm '
pars = _FORMATS['L']['parentheses_fmt']
elif 'P' in spec:
newpm = pm = '±'
pars = _FORMATS['P']['parentheses_fmt']
else:
newpm = pm = '+/-'
pars = _FORMATS['']['parentheses_fmt']
if 'C' in spec:
sp = ''
newspec = spec.replace('C', '')
pars = _FORMATS['C']['parentheses_fmt']
else:
sp = ' '
newspec = spec
if 'H' in spec:
newpm = '±'
newspec = spec.replace('H', '')
pars = _FORMATS['H']['parentheses_fmt']
mag = format(self.magnitude, newspec).replace(pm, sp + newpm + sp)
if 'L' in newspec and 'S' in newspec:
mag = mag.replace('(', r'\left(').replace(')', r'\right)')
if 'L' in newspec:
space = r'\ '
else:
space = ' '
if 'uS' in newspec or 'ue' in newspec or 'u%' in newspec:
return mag + space + format(self.units, spec)
else:
return pars.format(mag) + space + format(self.units, spec)
_Measurement = Measurement
def build_measurement_class(registry):
if ufloat is None:
class Measurement(object):
_REGISTRY = registry
def __init__(self, *args):
raise RuntimeError("Pint requires the 'uncertainties' package to create a Measurement object.")
else:
class Measurement(_Measurement):
_REGISTRY = registry
return Measurement
|
