bag.util.math

Module Contents

Classes

HalfInt	A class that represents a half integer.
Calculator	A simple calculator.

class bag.util.math.HalfInt(dbl_val: Any)

Bases: numbers.Integral

A class that represents a half integer.

property value: float

property is_integer: bool

property dbl_value: int

classmethod convert(val: Any) → HalfInt

div2(round_up: bool = False) → HalfInt

to_string() → str

up() → HalfInt

down() → HalfInt

up_even(flag: bool) → HalfInt

down_even(flag: bool) → HalfInt

__str__()

Return str(self).

__repr__()

Return repr(self).

__hash__()

Return hash(self).

__eq__(other)

self == other

__ne__(other)

Return self!=value.

__le__(other)

self <= other

__lt__(other)

self < other

< on Reals defines a total ordering, except perhaps for NaN.

__ge__(other)

Return self>=value.

__gt__(other)

Return self>value.

__add__(other)

self + other

__sub__(other)

self - other

__mul__(other)

self * other

__truediv__(other)

self / other: Should promote to float when necessary.

__floordiv__(other)

self // other: The floor() of self/other.

__mod__(other)

self % other

__divmod__(other)

divmod(self, other): The pair (self // other, self % other).

Sometimes this can be computed faster than the pair of operations.

__pow__(other, modulus=None)

self ** exponent % modulus, but maybe faster.

Accept the modulus argument if you want to support the 3-argument version of pow(). Raise a TypeError if exponent < 0 or any argument isn’t Integral. Otherwise, just implement the 2-argument version described in Complex.

__lshift__(other)

self << other

__rshift__(other)

self >> other

__and__(other)

self & other

__xor__(other)

self ^ other

__or__(other)

self | other

__radd__(other)

other + self

__rsub__(other)

other - self

__rmul__(other)

other * self

__rtruediv__(other)

other / self

__rfloordiv__(other)

other // self: The floor() of other/self.

__rmod__(other)

other % self

__rdivmod__(other)

divmod(other, self): The pair (self // other, self % other).

Sometimes this can be computed faster than the pair of operations.

__rpow__(other)

base ** self

__rlshift__(other)

other << self

__rrshift__(other)

other >> self

__rand__(other)

other & self

__rxor__(other)

other ^ self

__ror__(other)

other | self

__iadd__(other)

__isub__(other)

__imul__(other)

__itruediv__(other)

__ifloordiv__(other)

__imod__(other)

__ipow__(other)

__ilshift__(other)

__irshift__(other)

__iand__(other)

__ixor__(other)

__ior__(other)

__neg__()

-self

__pos__()

+self

__abs__()

Returns the Real distance from 0. Called for abs(self).

__invert__()

~self

__complex__()

complex(self) == complex(float(self), 0)

__int__()

int(self)

__float__()

float(self) == float(int(self))

__index__()

Called whenever an index is needed, such as in slicing

__round__(ndigits=0)

Rounds self to ndigits decimal places, defaulting to 0.

If ndigits is omitted or None, returns an Integral, otherwise returns a Real. Rounds half toward even.

__trunc__()

trunc(self): Truncates self to an Integral.

Returns an Integral i such that:

• i>0 iff self>0;

• abs(i) <= abs(self);

• for any Integral j satisfying the first two conditions, abs(i) >= abs(j) [i.e. i has “maximal” abs among those].

i.e. “truncate towards 0”.

__floor__()

Finds the greatest Integral <= self.

__ceil__()

Finds the least Integral >= self.

class bag.util.math.Calculator(namespace: Mapping[str, Any])

Bases: ast.NodeVisitor

A simple calculator.

Modified from: https://stackoverflow.com/questions/33029168/how-to-calculate-an-equation-in-a-string-python

user mgilson said in a comment that he agrees to distribute code with Apache 2.0 license.

property namespace: Mapping[str, Any]

_OP_MAP

__getitem__(name: str) → Any

visit_BinOp(node)

visit_UnaryOp(node)

visit_Num(node)

visit_Expr(node)

visit_Name(node)

eval(expression: str)

classmethod evaluate(expr: str, namespace: Mapping[str, Any])