Mathematical expression parser: cython wrapper around the 'C++ Mathematical Expression Toolkit Library'
Project description
#cexprtk: Mathematical Expression Parsing and Evaluation in Python
`cexprtk` is a cython wrapper around the "[ExprTK: C++ Mathematical Expression Toolkit Library ](http://www.partow.net/programming/exprtk/index.html)" by Arash Partow. Using `cexprtk` a powerful mathematical expression engine can be incorporated into your python project.
## Table of Contents
[TOC]
## Installation
The latest version of `cexprtk` can be installed using [pip][pip] :
```bash
$ pip install cexprtk
```
__Note:__ Installation requires a compatible C++ compiler to be installed (unless installing from a binary wheel).
## Usage
The following examples show the major features of `cexprtk`.
### Example: Evaluate a simple equation
The following shows how the arithmetic expression `(5+5) * 23` can be evaluated:
```python
>>> import cexprtk
>>> cexprtk.evaluate_expression("(5+5) * 23", {})
230.0
```
### Example: Using Variables
Variables can be used within expressions by passing a dictionary to the `evaluate_expression` function. This maps variable names to their values. The expression from the previous example can be re-calculated using variable values:
```python
>>> import cexprtk
>>> cexprtk.evaluate_expression("(A+B) * C", {"A" : 5, "B" : 5, "C" : 23})
230.0
```
### Example: Re-using expressions
When using the `evaluate_expression()` function, the mathematical expression is parsed, evaluated and then immediately thrown away. This example shows how to re-use an `Expression` for multiple evaluations.
* An expression will be defined to calculate the circumference of circle, this will then be re-used to calculate the value for several different radii.
* First a `Symbol_Table` is created containing a variable `r` (for radius), it is also populated with some useful constants such as π.
```python
>>> import cexprtk
>>> st = cexprtk.Symbol_Table({'r' : 1.0}, add_constants= True)
```
* Now an instance of `Expression` is created, defining our function:
```python
>>> circumference = cexprtk.Expression('2*pi*r', st)
```
* The `Symbol_Table` was initialised with `r=1`, the expression can be evaluated for this radius simply by calling it:
```python
>>> circumference()
6.283185307179586
```
* Now update the radius to a value of 3.0 using the dictionary like object returned by the `Symbol_Table`'s `.variables` property:
```python
>>> st.variables['r'] = 3.0
>>> circumference()
18.84955592153876
```
### Example: Defining custom functions
Python functions can be registered with a `Symbol_Table` then used in an `Expression`. In this example a custom function will be defined which produces a random number within a given range.
A suitable function exists in the `random` module, namely `random.uniform`. As this is an instance method it needs to be wrapped in function:
```python
>>> import random
>>> def rnd(low, high):
... return random.uniform(low,high)
...
```
Our `rnd` function now needs to be registered with a `Symbol_Table`:
```python
>>> import cexprtk
>>> st = cexprtk.Symbol_Table({})
>>> st.functions["rand"] = rnd
```
The `functions` property of the `Symbol_Table` is accessed like a dictionary. In the preceding code snippet, a symbol table is created and then the `rnd` function is assigned to the `rand` key. This key is used as the function's name in a `cexprtk` expression. The key cannot be the same as an existing variable, constant or reserved function name.
The `rand` function will now be used in an expression. This expression chooses a random number between 5 and 8 and then multiplies it by 10. The followin snippet shows the instantiation of the `Expression` which is then evaluated a few times. You will probably get different numbers out of your expression than shown, this is because your random number generator will have been initialised with a different seed than used in the example.
```python
>>> e = cexprtk.Expression("rand(5,8) * 10", st)
>>> e()
61.4668441077191
>>> e()
77.13523163246415
>>> e()
59.14881842716157
>>> e()
69.1476535568958
```
### Example: Defining an unknown symbol resolver
A callback can be passed to the `Expression` constructor through the `unknown_symbol_resolver_callback` parameter. This callback is invoked during expression parsing when a variable or constant is encountered that isn't in the `Symbol_Table` associated with the `Expression`.
The callback can be used to provide some logic that leads to a new symbol being registered or for an error condition to be flagged.
__The Problem:__ The following example shows a potential use for the symbol resolver:
* An expression contains variables of the form `m_VARIABLENAME` and `f_VARIABLENAME`.
* `m_` or `f_` prefix the actual variable name (perhaps indicating gender).
* `VARIABLENAME` should be used to look up the desired value in a dictionary.
* The dictionary value of `VARIABLENAME` should then be weighted according to its prefix:
+ `m_` variables should be multiplied by 0.8.
+ `f_` variables should be multiplied by 1.1.
__The Solution:__
* First the `VARIABLENAME` dictionary is defined:
```python
variable_values = { 'county_a' : 82, 'county_b' : 76}
```
* Now the callback is defined. This takes a single argument, *symbol*, which gives the name of the missing variable found in the expression:
```python
def callback(symbol):
# Tokenize the symbol name into prefix and VARIABLENAME components.
prefix,variablename = symbol.split("_", 1)
# Get the value for this VARIABLENAME from the variable_values dict
value = variable_values[variablename]
# Find the correct weight for the prefix
if prefix == 'm':
weight = 0.8
elif prefix == 'f':
weight = 1.1
else:
# Flag an error condition if prefix not found.
errormsg = "Unknown prefix "+ str(prefix)
return (False, cexprtk.USRSymbolType.VARIABLE, 0.0, errormsg)
# Apply the weight to the
value *= weight
# Indicate success and return value to cexprtk
return (True, cexprtk.USRSymbolType.VARIABLE, value, "")
```
* All that remains is to register the callback with an instance of `Expression` and to evaluate an expression. The expression to be evaluated is:
- `(m_county_a - f_county_b)`
- This should give a value of `(0.8*82) - (1.1*76) = -18`
```python
>>> st = cexprtk.Symbol_Table({})
>>> e = cexprtk.Expression("(m_county_a - f_county_b)", st, callback)
>>> e.value()
-18.0
```
---
## API Reference
For information about expressions supported by `cexprtk` please refer to the original C++ [ExprTK][] documentation:
### Class Reference
#### class Expression:
Class representing mathematical expression.
* Following instantiation, the expression is evaluated calling the expression or invoking its `value()` method.
* The variable values used by the Expression can be modified through the `variables` property of the `Symbol_Table` instance associated with the expression. The `Symbol_Table` can be accessed using the `Expression.symbol_table` property.
##### Defining unknown symbol-resolver:
The `unknown_symbol_resolver_callback` argument to the `Expression`
constructor accepts a callable which is invoked whenever a symbol (i.e. a
variable or a constant), is not found in the `Symbol_Table` given by the
`symbol_table` argument. The `unknown_symbol_resolver_callback` can be
used to provide a value for the missing value or to set an error condition.
The callable should have following signature:
```python
def callback(symbol_name):
...
```
Where `symbol_name` is a string identifying the missing symbol.
The callable should return a tuple of the form:
```python
(HANDLED_FLAG, USR_SYMBOL_TYPE, SYMBOL_VALUE, ERROR_STRING)
```
Where:
* `HANDLED_FLAG` is a boolean:
+ `True` indicates that callback was able handle the error condition and that `SYMBOL_VALUE` should be used for the missing symbol.
+ `False`, flags and error condition, the reason why the unknown symbol could not be resolved by the callback is described by `ERROR_STRING`.
* `USR_SYMBOL_TYPE` gives type of symbol (constant or variable) that should be added to the `symbol_table` when unkown symbol is resolved. Value should be one of those given in `cexprtk.USRSymbolType`. e.g.
+ `cexprtk.USRSymbolType.VARIABLE`
+ `cexprtk.USRSymbolType.CONSTANT`
* `SYMBOL_VALUE`, floating point value that should be used when resolving missing symbol.
* `ERROR_STRING` when `HANDLED_FLAG` is `False` this can be used to describe error condition.
##### def __init__(self, *expression*, *symbol_table*, *unknown_symbol_resolver_callback* = None):
Instantiate `Expression` from a text string giving formula and `Symbol_Table`
instance encapsulating variables and constants used by the expression.
__Parameters:__
* __expression__ (*str*) String giving expression to be calculated.
* __symbol_table__ (*Symbol_Table*) Object defining variables and constants.
* __unknown_symbol_resolver_callback__ (*callable*) See description above.
##### def value(self):
Evaluate expression using variable values currently set within associated `Symbol_Table`
__Returns:__
* (*float*) Value resulting from evaluation of expression.
##### def __call__(self):
Equivalent to calling `value()` method.
__Returns:__
* (*float*) Value resulting from evaluation of expression.
##### symbol_table
Read only property that returns `Symbol_Table` instance associated with this expression.
__Returns:__
* (*Symbol_Table*) `Symbol_Table` associated with this `Expression`.
---
#### class Symbol_Table:
Class for providing variable and constant values to `Expression` instances.
##### def __init__(self, *variables*, *constants* = {}, *add_constants* = False, functions = {}):
Instantiate `Symbol_Table` defining variables and constants for use with `Expression` class.
__Example:__
* To instantiate a `Symbol_Table` with:
+ `x = 1`
+ `y = 5`
+ define a constant `k = 1.3806488e-23`
* The following code would be used:
```python
st = cexprtk.Symbol_Table({'x' : 1, 'y' : 5}, {'k'= 1.3806488e-23})
```
__Parameters:__
* __variables__ (*dict*) Mapping between variable name and initial variable value.
* __constants__ (*dict*) Dictionary containing values that should be added to `Symbol_Table` as constants. These can be used a variables within expressions but their values cannot be updated following `Symbol_Table` instantiation.
* __add_constants__ (*bool*) If `True`, add the standard constants `pi`, `inf`, `epsilon` to the 'constants' dictionary before populating the `Symbol_Table`
* __functions__ (*dict*) Dictionary containing custom functions to be made available to expressions. Dictionary keys specify function names and values should be functions.
##### variables
Returns dictionary like object containing variable values. `Symbol_Table` values can be updated through this object.
__Example:__
```python
>>> import cexprtk
>>> st = cexprtk.Symbol_Table({'x' : 5, 'y' : 5})
>>> expression = cexprtk.Expression('x+y', st)
>>> expression()
10.0
```
Update the value of `x` in the symbol table and re-evaluate the expression:
```python
>>> expression.symbol_table.variables['x'] = 11.0
>>> expression()
16.0
```
__Returns:__
* Dictionary like giving variables stored in this `Symbol_Table`. Keys are variables names and these map to variable values.
##### constants
Property giving constants stored in this `Symbol_Table`.
__Returns:__
* Read-only dictionary like object mapping constant names stored in `Symbol_Table` to their values.
##### functions
Returns dictionary like object containing custom python functions to use in expressions.
__Returns:__
* Dictionary like giving function stored in this `Symbol_Table`. Keys are function names (as used in `Expression`) and these map to python callable objects including functions, functors, and `functools.partial`.
---
#### class USRSymbolType:
Defines constant values used to determine symbol type returned by `unknown_symbol_resolver_callback` (see `Expression` constructor documentation for more).
##### VARIABLE
Value that should be returned by an `unknown_symbol_resolver_callback` to define a variable.
##### CONSTANT
Value that should be returned by an `unknown_symbol_resolver_callback` to define a constant.
---
### Utility Functions
#### def check_expression (*expression*)
Check that expression can be parsed. If successful do nothing, if unsuccessful raise `ParseException`.
__Parameters:__
* *expression* (*str*) Formula to be evaluated
__Raises:__
* `ParseException`: If expression is invalid.
#### def evaluate_expression (*expression*, *variables*)
Evaluate a mathematical formula using the exprtk library and return result.
For more information about supported functions and syntax see the
[exprtk C++ library website](http://www.partow.net/programming/exprtk/index.html).
__Parameters:__
* __expression__ (*str*) Expression to be evaluated.
* __variables__ (*dict*) Dictionary containing variable name, variable value pairs to be used in expression.
__Returns:__
* (*float*): Evaluated expression
__Raises:__
* `ParseException`: if *expression* is invalid.
---
## Authors
Cython wrapper by Michael Rushton (m.j.d.rushton@gmail.com), although most credit should go to Arash Partow for creating the underlying [ExprTK](http://www.partow.net/programming/exprtk/index.html) library.
## License
`cexprtk` is released under the same terms as the [ExprTK][] library the [Common Public License Version 1.0][] (CPL).
[pip]: http://www.pip-installer.org/en/latest/index.html
[Common Public License Version 1.0]: http://opensource.org/licenses/cpl1.0.php
`cexprtk` is a cython wrapper around the "[ExprTK: C++ Mathematical Expression Toolkit Library ](http://www.partow.net/programming/exprtk/index.html)" by Arash Partow. Using `cexprtk` a powerful mathematical expression engine can be incorporated into your python project.
## Table of Contents
[TOC]
## Installation
The latest version of `cexprtk` can be installed using [pip][pip] :
```bash
$ pip install cexprtk
```
__Note:__ Installation requires a compatible C++ compiler to be installed (unless installing from a binary wheel).
## Usage
The following examples show the major features of `cexprtk`.
### Example: Evaluate a simple equation
The following shows how the arithmetic expression `(5+5) * 23` can be evaluated:
```python
>>> import cexprtk
>>> cexprtk.evaluate_expression("(5+5) * 23", {})
230.0
```
### Example: Using Variables
Variables can be used within expressions by passing a dictionary to the `evaluate_expression` function. This maps variable names to their values. The expression from the previous example can be re-calculated using variable values:
```python
>>> import cexprtk
>>> cexprtk.evaluate_expression("(A+B) * C", {"A" : 5, "B" : 5, "C" : 23})
230.0
```
### Example: Re-using expressions
When using the `evaluate_expression()` function, the mathematical expression is parsed, evaluated and then immediately thrown away. This example shows how to re-use an `Expression` for multiple evaluations.
* An expression will be defined to calculate the circumference of circle, this will then be re-used to calculate the value for several different radii.
* First a `Symbol_Table` is created containing a variable `r` (for radius), it is also populated with some useful constants such as π.
```python
>>> import cexprtk
>>> st = cexprtk.Symbol_Table({'r' : 1.0}, add_constants= True)
```
* Now an instance of `Expression` is created, defining our function:
```python
>>> circumference = cexprtk.Expression('2*pi*r', st)
```
* The `Symbol_Table` was initialised with `r=1`, the expression can be evaluated for this radius simply by calling it:
```python
>>> circumference()
6.283185307179586
```
* Now update the radius to a value of 3.0 using the dictionary like object returned by the `Symbol_Table`'s `.variables` property:
```python
>>> st.variables['r'] = 3.0
>>> circumference()
18.84955592153876
```
### Example: Defining custom functions
Python functions can be registered with a `Symbol_Table` then used in an `Expression`. In this example a custom function will be defined which produces a random number within a given range.
A suitable function exists in the `random` module, namely `random.uniform`. As this is an instance method it needs to be wrapped in function:
```python
>>> import random
>>> def rnd(low, high):
... return random.uniform(low,high)
...
```
Our `rnd` function now needs to be registered with a `Symbol_Table`:
```python
>>> import cexprtk
>>> st = cexprtk.Symbol_Table({})
>>> st.functions["rand"] = rnd
```
The `functions` property of the `Symbol_Table` is accessed like a dictionary. In the preceding code snippet, a symbol table is created and then the `rnd` function is assigned to the `rand` key. This key is used as the function's name in a `cexprtk` expression. The key cannot be the same as an existing variable, constant or reserved function name.
The `rand` function will now be used in an expression. This expression chooses a random number between 5 and 8 and then multiplies it by 10. The followin snippet shows the instantiation of the `Expression` which is then evaluated a few times. You will probably get different numbers out of your expression than shown, this is because your random number generator will have been initialised with a different seed than used in the example.
```python
>>> e = cexprtk.Expression("rand(5,8) * 10", st)
>>> e()
61.4668441077191
>>> e()
77.13523163246415
>>> e()
59.14881842716157
>>> e()
69.1476535568958
```
### Example: Defining an unknown symbol resolver
A callback can be passed to the `Expression` constructor through the `unknown_symbol_resolver_callback` parameter. This callback is invoked during expression parsing when a variable or constant is encountered that isn't in the `Symbol_Table` associated with the `Expression`.
The callback can be used to provide some logic that leads to a new symbol being registered or for an error condition to be flagged.
__The Problem:__ The following example shows a potential use for the symbol resolver:
* An expression contains variables of the form `m_VARIABLENAME` and `f_VARIABLENAME`.
* `m_` or `f_` prefix the actual variable name (perhaps indicating gender).
* `VARIABLENAME` should be used to look up the desired value in a dictionary.
* The dictionary value of `VARIABLENAME` should then be weighted according to its prefix:
+ `m_` variables should be multiplied by 0.8.
+ `f_` variables should be multiplied by 1.1.
__The Solution:__
* First the `VARIABLENAME` dictionary is defined:
```python
variable_values = { 'county_a' : 82, 'county_b' : 76}
```
* Now the callback is defined. This takes a single argument, *symbol*, which gives the name of the missing variable found in the expression:
```python
def callback(symbol):
# Tokenize the symbol name into prefix and VARIABLENAME components.
prefix,variablename = symbol.split("_", 1)
# Get the value for this VARIABLENAME from the variable_values dict
value = variable_values[variablename]
# Find the correct weight for the prefix
if prefix == 'm':
weight = 0.8
elif prefix == 'f':
weight = 1.1
else:
# Flag an error condition if prefix not found.
errormsg = "Unknown prefix "+ str(prefix)
return (False, cexprtk.USRSymbolType.VARIABLE, 0.0, errormsg)
# Apply the weight to the
value *= weight
# Indicate success and return value to cexprtk
return (True, cexprtk.USRSymbolType.VARIABLE, value, "")
```
* All that remains is to register the callback with an instance of `Expression` and to evaluate an expression. The expression to be evaluated is:
- `(m_county_a - f_county_b)`
- This should give a value of `(0.8*82) - (1.1*76) = -18`
```python
>>> st = cexprtk.Symbol_Table({})
>>> e = cexprtk.Expression("(m_county_a - f_county_b)", st, callback)
>>> e.value()
-18.0
```
---
## API Reference
For information about expressions supported by `cexprtk` please refer to the original C++ [ExprTK][] documentation:
### Class Reference
#### class Expression:
Class representing mathematical expression.
* Following instantiation, the expression is evaluated calling the expression or invoking its `value()` method.
* The variable values used by the Expression can be modified through the `variables` property of the `Symbol_Table` instance associated with the expression. The `Symbol_Table` can be accessed using the `Expression.symbol_table` property.
##### Defining unknown symbol-resolver:
The `unknown_symbol_resolver_callback` argument to the `Expression`
constructor accepts a callable which is invoked whenever a symbol (i.e. a
variable or a constant), is not found in the `Symbol_Table` given by the
`symbol_table` argument. The `unknown_symbol_resolver_callback` can be
used to provide a value for the missing value or to set an error condition.
The callable should have following signature:
```python
def callback(symbol_name):
...
```
Where `symbol_name` is a string identifying the missing symbol.
The callable should return a tuple of the form:
```python
(HANDLED_FLAG, USR_SYMBOL_TYPE, SYMBOL_VALUE, ERROR_STRING)
```
Where:
* `HANDLED_FLAG` is a boolean:
+ `True` indicates that callback was able handle the error condition and that `SYMBOL_VALUE` should be used for the missing symbol.
+ `False`, flags and error condition, the reason why the unknown symbol could not be resolved by the callback is described by `ERROR_STRING`.
* `USR_SYMBOL_TYPE` gives type of symbol (constant or variable) that should be added to the `symbol_table` when unkown symbol is resolved. Value should be one of those given in `cexprtk.USRSymbolType`. e.g.
+ `cexprtk.USRSymbolType.VARIABLE`
+ `cexprtk.USRSymbolType.CONSTANT`
* `SYMBOL_VALUE`, floating point value that should be used when resolving missing symbol.
* `ERROR_STRING` when `HANDLED_FLAG` is `False` this can be used to describe error condition.
##### def __init__(self, *expression*, *symbol_table*, *unknown_symbol_resolver_callback* = None):
Instantiate `Expression` from a text string giving formula and `Symbol_Table`
instance encapsulating variables and constants used by the expression.
__Parameters:__
* __expression__ (*str*) String giving expression to be calculated.
* __symbol_table__ (*Symbol_Table*) Object defining variables and constants.
* __unknown_symbol_resolver_callback__ (*callable*) See description above.
##### def value(self):
Evaluate expression using variable values currently set within associated `Symbol_Table`
__Returns:__
* (*float*) Value resulting from evaluation of expression.
##### def __call__(self):
Equivalent to calling `value()` method.
__Returns:__
* (*float*) Value resulting from evaluation of expression.
##### symbol_table
Read only property that returns `Symbol_Table` instance associated with this expression.
__Returns:__
* (*Symbol_Table*) `Symbol_Table` associated with this `Expression`.
---
#### class Symbol_Table:
Class for providing variable and constant values to `Expression` instances.
##### def __init__(self, *variables*, *constants* = {}, *add_constants* = False, functions = {}):
Instantiate `Symbol_Table` defining variables and constants for use with `Expression` class.
__Example:__
* To instantiate a `Symbol_Table` with:
+ `x = 1`
+ `y = 5`
+ define a constant `k = 1.3806488e-23`
* The following code would be used:
```python
st = cexprtk.Symbol_Table({'x' : 1, 'y' : 5}, {'k'= 1.3806488e-23})
```
__Parameters:__
* __variables__ (*dict*) Mapping between variable name and initial variable value.
* __constants__ (*dict*) Dictionary containing values that should be added to `Symbol_Table` as constants. These can be used a variables within expressions but their values cannot be updated following `Symbol_Table` instantiation.
* __add_constants__ (*bool*) If `True`, add the standard constants `pi`, `inf`, `epsilon` to the 'constants' dictionary before populating the `Symbol_Table`
* __functions__ (*dict*) Dictionary containing custom functions to be made available to expressions. Dictionary keys specify function names and values should be functions.
##### variables
Returns dictionary like object containing variable values. `Symbol_Table` values can be updated through this object.
__Example:__
```python
>>> import cexprtk
>>> st = cexprtk.Symbol_Table({'x' : 5, 'y' : 5})
>>> expression = cexprtk.Expression('x+y', st)
>>> expression()
10.0
```
Update the value of `x` in the symbol table and re-evaluate the expression:
```python
>>> expression.symbol_table.variables['x'] = 11.0
>>> expression()
16.0
```
__Returns:__
* Dictionary like giving variables stored in this `Symbol_Table`. Keys are variables names and these map to variable values.
##### constants
Property giving constants stored in this `Symbol_Table`.
__Returns:__
* Read-only dictionary like object mapping constant names stored in `Symbol_Table` to their values.
##### functions
Returns dictionary like object containing custom python functions to use in expressions.
__Returns:__
* Dictionary like giving function stored in this `Symbol_Table`. Keys are function names (as used in `Expression`) and these map to python callable objects including functions, functors, and `functools.partial`.
---
#### class USRSymbolType:
Defines constant values used to determine symbol type returned by `unknown_symbol_resolver_callback` (see `Expression` constructor documentation for more).
##### VARIABLE
Value that should be returned by an `unknown_symbol_resolver_callback` to define a variable.
##### CONSTANT
Value that should be returned by an `unknown_symbol_resolver_callback` to define a constant.
---
### Utility Functions
#### def check_expression (*expression*)
Check that expression can be parsed. If successful do nothing, if unsuccessful raise `ParseException`.
__Parameters:__
* *expression* (*str*) Formula to be evaluated
__Raises:__
* `ParseException`: If expression is invalid.
#### def evaluate_expression (*expression*, *variables*)
Evaluate a mathematical formula using the exprtk library and return result.
For more information about supported functions and syntax see the
[exprtk C++ library website](http://www.partow.net/programming/exprtk/index.html).
__Parameters:__
* __expression__ (*str*) Expression to be evaluated.
* __variables__ (*dict*) Dictionary containing variable name, variable value pairs to be used in expression.
__Returns:__
* (*float*): Evaluated expression
__Raises:__
* `ParseException`: if *expression* is invalid.
---
## Authors
Cython wrapper by Michael Rushton (m.j.d.rushton@gmail.com), although most credit should go to Arash Partow for creating the underlying [ExprTK](http://www.partow.net/programming/exprtk/index.html) library.
## License
`cexprtk` is released under the same terms as the [ExprTK][] library the [Common Public License Version 1.0][] (CPL).
[pip]: http://www.pip-installer.org/en/latest/index.html
[Common Public License Version 1.0]: http://opensource.org/licenses/cpl1.0.php
Project details
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Source Distribution
cexprtk-0.3.3.tar.gz
(327.8 kB
view hashes)
Built Distributions
Close
Hashes for cexprtk-0.3.3-cp37-cp37m-win_amd64.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | 8f38efa5d948ae9aadff81dcbcca774b83404b04f678db1ca75dbf565f275078 |
|
MD5 | 3185471a10b7e02e59c40a3e2c10fa4d |
|
BLAKE2b-256 | 43cf67453616e6e800ca75c26759e67516f75cb7f7785c310e027d0062934d1d |
Close
Hashes for cexprtk-0.3.3-cp37-cp37m-manylinux1_x86_64.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | 06477c0aa45ad9dfb34d0a04509413b29e68babef5ab9b59ec05dd7fc9571204 |
|
MD5 | 57fdb52bcf6095f2731f60622203b2cc |
|
BLAKE2b-256 | ab595a63431f04dde83a70955ce7fdc34e54b0b5a947af8cb8023f5b8d130677 |
Close
Hashes for cexprtk-0.3.3-cp37-cp37m-manylinux1_i686.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | 9a3b17143fc7af84f2d5b1026920153f25207f60948a6b652fa3433b26836e7b |
|
MD5 | aa453e9f32c5bdfb3b57fda24f9474fe |
|
BLAKE2b-256 | 53ac7677af116838d7e82f18b6f0252c14e7d094095fc77c079fc7307b585d2e |
Close
Hashes for cexprtk-0.3.3-cp37-cp37m-macosx_10_13_x86_64.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | 065f9694a5ddc0644553b1be63763823b0d3dc0fda2a6eb3dba990efaf538bfc |
|
MD5 | bf5b9c5413bda91d58bdd3d138787ccc |
|
BLAKE2b-256 | 9c192369b57e263c1431b808f7b476f9f3afaff61145c844080546e68f9b851f |
Close
Hashes for cexprtk-0.3.3-cp36-cp36m-win_amd64.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | 17f8bfb90c3db8608b8d991f5c65241d9f25cab746c4e0492e324ca651ad96ce |
|
MD5 | b4612797a37aeffe1789d6007e08b062 |
|
BLAKE2b-256 | 003b1d755af1deb24b6036796006bf84b696a85e246adafff3e84f019f816e94 |
Close
Hashes for cexprtk-0.3.3-cp36-cp36m-manylinux1_x86_64.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | 353d8151cb69c17cdcb135aa7a4f33e33904db64c23624a3f4b87afdf7afb17e |
|
MD5 | afe913017523abef7c8100cc0ced4589 |
|
BLAKE2b-256 | 76999074d0539fc7963c2cf8c655b9f162145cedab6517e2a1040c7645b5fcfe |
Close
Hashes for cexprtk-0.3.3-cp36-cp36m-manylinux1_i686.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | 8e612d7bbb0e0a402e5543f34ca12aa9533a0cb7ae36cc8ea84002a2cbc57ede |
|
MD5 | 9e742a8ce06c2d5c300b42e48223b50e |
|
BLAKE2b-256 | bd43753ea49ef12372a8655b6dcccc39ef72c725c0f461720644bb57c2e53aef |
Close
Hashes for cexprtk-0.3.3-cp36-cp36m-macosx_10_13_x86_64.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | 5f4dc067a9ebcfa85f93051a427370c99c344f6e12de894e70b8a9d379f3fc39 |
|
MD5 | da8416c7d633a19d3ccd2cde57fb6663 |
|
BLAKE2b-256 | 1b245a375a93a451f46b38c6bbd79c6007821e805fd742b754203b745b0688b7 |
Close
Hashes for cexprtk-0.3.3-cp35-cp35m-win_amd64.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | a9c811d7157ac9baa1c58f1ac95a014b59ce428ebf264e1c7f2703dae8ef42a7 |
|
MD5 | d07a7ebbbe857725944131ed4752b7b5 |
|
BLAKE2b-256 | de6390323094a19f2cad74fe64ed2d3630c099dc5646dfadcc36ed2d4df397c2 |
Close
Hashes for cexprtk-0.3.3-cp35-cp35m-manylinux1_x86_64.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | af145cb8f463e0427c2a541c361daaaa11eedaaf800cea0b7a0f23ab79fd3354 |
|
MD5 | 4f47c4223673512f4e388c98c27de48d |
|
BLAKE2b-256 | 1458cb6a2a45ca045ac9a4c05d198a9db7d9f1d31249c3a50c9dd3b086cae32e |
Close
Hashes for cexprtk-0.3.3-cp35-cp35m-manylinux1_i686.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | 81631b88e6c0c5d7d8b2d8aa8b1957116b27bd378ffac6c752063a54fcdc5e9d |
|
MD5 | d8943b89eada7322f076e5bfb8b5d63a |
|
BLAKE2b-256 | 54e7642c206f4256adc76c08174f9f85fe9b29aaafe738d02027666125f35518 |
Close
Hashes for cexprtk-0.3.3-cp35-cp35m-macosx_10_13_x86_64.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | 6351e6e185f1dca3db5d081550ef4342429f9239c484c6bf5e0733d93a92efb2 |
|
MD5 | c0f6a66d5f89bc92ccdc4a3182f977c8 |
|
BLAKE2b-256 | 8d9bd36c823bb039bd189bd5992cd412b6d8f81edbbd816e79f7d99f4f56dd73 |
Close
Hashes for cexprtk-0.3.3-cp34-cp34m-manylinux1_x86_64.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | cd72dd1b3075b218f186c52362f7feb1a3cefb0ff1525c62f538b807117e28f9 |
|
MD5 | 7042698eacd2627a6399ec30ef4375cf |
|
BLAKE2b-256 | f3bdf36f302f357a6c63c91af0304b2a1bfecea9270445d82bbdb09c0125d42e |
Close
Hashes for cexprtk-0.3.3-cp34-cp34m-manylinux1_i686.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | 113c9133b98f67c42b1cc6ab6cfe98d96388692841bd2588e3f67b7aa8e66f69 |
|
MD5 | c9f7fcc654bc7e0c181f500555fbd854 |
|
BLAKE2b-256 | faddc8d9c6f9ce2e6dbfa1e240c2162bdf48664042642ac8c3acae0b4fb03259 |
Close
Hashes for cexprtk-0.3.3-cp34-cp34m-macosx_10_13_x86_64.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | 8ef2537cc1c9e4c92e0fb98a4c1c7807ad7ca452e04642bf84ebb2b5581ed85f |
|
MD5 | e3e2ccd159f488570a768eae8bdcaa72 |
|
BLAKE2b-256 | f73695460549ea8413e9212475c1a4ebfed02a0ce546810691811181fe60bc40 |
Close
Hashes for cexprtk-0.3.3-cp33-cp33m-macosx_10_13_x86_64.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | ed237ad6e4cafdb4104e72c7c767372dddbc7e93256e20cfe00b34194efaaab6 |
|
MD5 | 23c5922ec47d24fd152e3da5499bd847 |
|
BLAKE2b-256 | 588718a25cd047258e75716c1188355acd09f3581eb7a502a5244808a9ed53e0 |
Close
Hashes for cexprtk-0.3.3-cp27-cp27mu-manylinux1_x86_64.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | 4d76da7509b7d552bbd8546de9f30c931bfda230bfe71cd95b19f9e79ea33f91 |
|
MD5 | ec6fc6a98f81117fe8c776c74431c98d |
|
BLAKE2b-256 | ebf0b54ab7571193f36aee8af5d6146f434233dc879ac80bfe1c3cbb1a950603 |
Close
Hashes for cexprtk-0.3.3-cp27-cp27mu-manylinux1_i686.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | 808be89560ccb3230dbc8f5e2f1ccfb4008a3e9674274f378a99dd58b82726cb |
|
MD5 | a07c56b10769efec2aea45816d84c977 |
|
BLAKE2b-256 | 68f3a38f4a8e8b7278e41020a2644360b625788b2cf244eda3bec23884624b58 |
Close
Hashes for cexprtk-0.3.3-cp27-cp27m-win_amd64.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | 067c1ad02876be35b7f0520caa507545f2b1515487aceff33139ff9b3b0019bb |
|
MD5 | 21eff02fb0af7089ba98d1d30500726e |
|
BLAKE2b-256 | a1d44bbe6fdbec7824be2301a5bf898e2f852ec0a06a49e531a79d53061503be |
Close
Hashes for cexprtk-0.3.3-cp27-cp27m-manylinux1_x86_64.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | 59fe275776a66f2259933469155b1308be70fa9a0e3244d31bc10bb52ccfecba |
|
MD5 | 787137cc463fd977bf9ece9f007a91b9 |
|
BLAKE2b-256 | a1b87a7849f9c4fef3f68a74cb9553d999d51e483c8418b084be6395a855a753 |
Close
Hashes for cexprtk-0.3.3-cp27-cp27m-manylinux1_i686.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | 37026b84124e7248c6bbae06fed3a488c13e787659c0eebafab554f53e4700da |
|
MD5 | 4700fd1f54377561213307a37a100132 |
|
BLAKE2b-256 | 4a53180e35737c56ee8df4e12568eeb6fec9bf0adfd3b211b6bda7b6e85ddd91 |
Close
Hashes for cexprtk-0.3.3-cp27-cp27m-macosx_10_13_x86_64.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | 73acad458d60d173d1cff63bb711c23e1256881c17b309b0a266760ca3e1c1a9 |
|
MD5 | 3363c6f544ca6e6cb0bd901ef0d2de76 |
|
BLAKE2b-256 | 1d5c2f981f69ee591a0c4973b36383c472babdf7d2022ee3c1e0a1306a401fe1 |