def install(cls, calculator):
calculator.add_op(OperatorDefinition(
'Regular Expression',
'=~',
'Return true if value matches regex',
RegexFeature.op_regex,
1,
1,
'string'))
calculator.add_op(OperatorDefinition(
'Regular Expression',
'!~',
'Return true if value doesn\'t match regex',
RegexFeature.op_regexnot,
1,
1,
'string'))
calculator.funcs['regexget'] = FunctionDefinition(
'Regular Expression',
'regexget',
'Return either all or a specific occurrence of a pattern in a string',
['string', 'pattern', '[group]'],
RegexFeature.func_regexget,
2,
3)
calculator.funcs['regexget'].add_value_restriction(0, 1, 'string')
calculator.funcs['regexget'].add_value_restriction(2, 2, 'number')
calculator.funcs['regexsplit'] = FunctionDefinition(
'Regular Expression',
'regexsplit',
'Split a string on a regular expression and return as an array',
['string', 'pattern'],
RegexFeature.func_regexsplit,
2,
2,
'string')
calculator.funcs['regexsub'] = FunctionDefinition(
'Regular Expression',
'regexsub',
'Replace all or a specific occurrence of a pattern with a replacement',
['string', 'pattern', 'replacement', '[group]'],
RegexFeature.func_regexsub,
3,
4)
calculator.funcs['regexsub'].add_value_restriction(0, 2, 'string')
calculator.funcs['regexsub'].add_value_restriction(3, 3, 'number')
calculator.funcs['regexcount'] = FunctionDefinition(
'Regular Expression',
'regexcount',
'Count the number of times a pattern appears in a string',
['string', 'pattern'],
RegexFeature.func_regexcount,
2,
2)
calculator.funcs['regexcount'].add_value_restriction(0, 1, 'string')
def install(cls, calculator):
calculator.enable_units()
calculator.unit_simplification = True
calculator.unit_normaliser.prefixes = [
(None, None, Decimal('1')),
]
calculator.unit_symbols_enabled = False
calculator.add_parser('units', UnitsFeature.parse_units)
calculator.unit_assignment_op = 'UNIT_ASSIGNMENT'
calculator.unit_multiply_op = 'UNIT_MULTIPLY'
calculator.unit_divide_op = 'UNIT_DIVIDE'
calculator.add_op(OperatorDefinition(
'Units',
'to',
'Convert a value with a unit to another unit',
UnitsFeature.op_unit_conversion,
1,
1,
[['number with unit', 'unit'], 'unit']),
{'units_normalise': False})
calculator.add_op(OperatorDefinition(
'Units',
'UNIT_ASSIGNMENT',
'Assign a unit to a value',
BasicArithmeticFeature.op_number_multiply,
1,
1,
['number', 'unit']),
{'units_normalise': False, 'hidden': True})
calculator.add_op(OperatorDefinition(
'Units',
'UNIT_MULTIPLY',
'Multiply two units',
BasicArithmeticFeature.op_number_multiply,
1,
1,
'unit'),
{'units_normalise': False, 'hidden': True})
calculator.add_op(OperatorDefinition(
'Units',
'UNIT_DIVIDE',
'Divide two units',
BasicArithmeticFeature.op_number_divide,
1,
1,
'unit'),
{'units_normalise': False, 'hidden': True})
calculator.validators['unit'] = UnitsFeature.validate_unit
calculator.validators['number with unit'] = UnitsFeature.validate_number_with_unit
def install(cls, calculator):
calculator.add_op(
OperatorDefinition('Numerical', '%', 'Modulus',
AdvancedArithmeticFeature.op_number_modulus, 1,
1, 'number'))
calculator.add_op(
OperatorDefinition(
'Numerical', '\\',
'Integer divide - Truncates non-integer component',
AdvancedArithmeticFeature.op_number_integer_divide, 1, 1,
'number'))
def install(cls, calculator):
calculator.add_op(
OperatorDefinition('Bitwise', '&', 'Bitwise AND',
BitwiseOperatorsFeature.op_bitwise_and, 1, 1,
'number'))
calculator.add_op(
OperatorDefinition('Bitwise', '|', 'Bitwise OR',
BitwiseOperatorsFeature.op_bitwise_or, 1, 1,
'number'))
calculator.add_op(
OperatorDefinition('Bitwise', '^^', 'Bitwise XOR',
BitwiseOperatorsFeature.op_bitwise_xor, 1, 1,
'number'))
bitwise_not = OperatorDefinition(
'Bitwise', '~', 'Bitwise Negation (1\'s Complement)',
BitwiseOperatorsFeature.op_bitwise_not, 0, 1, 'number')
bitwise_not.auto_convert_numerical_inputs = False
calculator.add_op(bitwise_not, {'rtl': True})
calculator.add_op(
OperatorDefinition('Bitwise', '<<', 'Bitwise Left Shift',
BitwiseOperatorsFeature.op_bitwise_lshift, 1, 1,
'number'))
calculator.add_op(
OperatorDefinition('Bitwise', '>>', 'Bitwise Right Shift',
BitwiseOperatorsFeature.op_bitwise_rshift, 1, 1,
'number'))
def install(cls, calculator):
calculator.add_parser('string', StringsFeature.parse_string)
calculator.add_op(
OperatorDefinition('String', '+$', 'Concatenate two strings',
StringsFeature.op_string_add, 1, 1, 'string'))
string_mult = OperatorDefinition(
'String', '*$', 'Multiply a string a number of times',
StringsFeature.op_string_multiply, 1, 1, ['string', 'number'])
calculator.add_op(string_mult)
calculator.validators['string'] = StringsFeature.validate_string
calculator.feature_options['strings.strings'] = cls.default_options()
def install(cls, calculator):
calculator.add_parser('var', AssignmentFeature.parse_var)
calculator.add_op(
OperatorDefinition('Assignment', '=',
'Assign a value to a variable',
AssignmentFeature.op_var_set, 1, 1,
['variable', [None, 'array']]),
{'units_normalise': False})
calculator.add_op(
OperatorDefinition(
'Assignment', '||=',
'Assign a value to a variable only if the variable doesn\'t exist yet',
AssignmentFeature.op_var_set_if_empty, 1, 1,
['variable', [None, 'array']]), {'units_normalise': False})
calculator.vars = {}
calculator.validators['variable'] = AssignmentFeature.validate_variable
def install(cls, calculator):
calculator.add_op(
OperatorDefinition('Assignment', '++', 'Increment a variable',
AssignmentOperatorsFeature.op_var_increment, 1,
0, ['variable']))
calculator.add_op(
OperatorDefinition('Assignment', '--', 'Decrement a variable',
AssignmentOperatorsFeature.op_var_decrement, 1,
0, ['variable']))
calculator.add_op(
OperatorDefinition('Assignment', '+=', 'Addition assignment',
AssignmentOperatorsFeature.op_var_add, 1, 1,
['variable', 'number']),
{'units_normalise': False})
calculator.add_op(
OperatorDefinition('Assignment', '-=', 'Subtraction assignment',
AssignmentOperatorsFeature.op_var_subtract, 1,
1, ['variable', 'number']),
{'units_normalise': False})
calculator.add_op(
OperatorDefinition('Assignment', '*=', 'Multiplication assignment',
AssignmentOperatorsFeature.op_var_multiply, 1,
1, ['variable', 'number']),
{'units_normalise': False})
calculator.add_op(
OperatorDefinition('Assignment', '/=', 'Division assignment',
AssignmentOperatorsFeature.op_var_divide, 1, 1,
['variable', 'number']),
{'units_normalise': False})
calculator.add_op(
OperatorDefinition('Assignment', '^=', 'Power assignment',
AssignmentOperatorsFeature.op_var_power, 1, 1,
['variable', 'number']),
{'units_normalise': False})
calculator.add_op(
OperatorDefinition('Assignment', '%=', 'Modulus assignment',
AssignmentOperatorsFeature.op_var_modulus, 1, 1,
['variable', 'number']),
{'units_normalise': False})
calculator.add_op(
OperatorDefinition(
'Assignment', r'\=', 'Integer-division assignment',
AssignmentOperatorsFeature.op_var_integer_divide, 1, 1,
['variable', 'number']), {'units_normalise': False})
def install(cls, calculator):
date_add_op = OperatorDefinition(
'Date',
'+%',
'Add a time period to a date',
DateOperatorsFeature.op_date_add,
1,
1,
['date', 'number'])
date_add_op.add_unit_restriction(1, 1, ['time', 1])
calculator.add_op(date_add_op, {'units_normalise': False})
date_sub_op = OperatorDefinition(
'Date',
'-%',
'Subtract a time period from a date',
DateOperatorsFeature.op_date_subtract,
1,
1,
['date', 'number'])
date_sub_op.add_unit_restriction(1, 1, ['time', 1])
calculator.add_op(date_sub_op, {'units_normalise': False})
def install(cls, calculator):
calculator.add_op(
OperatorDefinition('Numerical', '^', 'Power',
BasicArithmeticFeature.op_number_power, 1, 1,
[['number', 'unit'], 'number']),
{'units_normalise': False})
calculator.add_op(
OperatorDefinition('Numerical', '*', 'Multiply',
BasicArithmeticFeature.op_number_multiply, 1, 1,
[['number', 'unit'], ['number', 'unit']]), {
'units_relative': True,
'units_multi': True
})
calculator.add_op(
OperatorDefinition('Numerical', '/', 'Divide',
BasicArithmeticFeature.op_number_divide, 1, 1,
[['number', 'unit'], ['number', 'unit']]), {
'units_relative': True,
'units_multi': True
})
calculator.add_op(
OperatorDefinition('Numerical', '+', 'Add',
BasicArithmeticFeature.op_number_add, 1, 1,
'number'), {'units_relative': True})
calculator.add_op(
OperatorDefinition('Numerical', '-', 'Subtract',
BasicArithmeticFeature.op_number_subtract, 1, 1,
'number'), {'units_relative': True})
calculator.add_op(
OperatorDefinition(
'Numerical', 'IMPLICIT_MULTIPLY',
'Implicitly multiply two values next to each other',
BasicArithmeticFeature.op_number_multiply, 1, 1, 'number'), {
'units_relative': True,
'units_multi': True,
'hidden': True
})
calculator.implicit_multiply_op = 'IMPLICIT_MULTIPLY'
calculator.multiply_op = '*'
calculator.divide_op = '/'
def install(cls, calculator):
calculator.add_parser('boolean', BooleansFeature.parse_boolean)
calculator.add_op(OperatorDefinition(
'Boolean',
'not',
'Not',
BooleansFeature.op_boolean_not,
0,
1,
'boolean'),
{'rtl': True})
calculator.add_op(OperatorDefinition(
'Numerical',
'<',
'Less than',
BooleansFeature.op_number_lessthan,
1,
1,
'number'))
calculator.add_op(OperatorDefinition(
'Numerical',
'>',
'More than',
BooleansFeature.op_number_morethan,
1,
1,
'number'))
calculator.add_op(OperatorDefinition(
'Numerical',
'<=',
'Less than or equal to',
BooleansFeature.op_number_lessthanequal,
1,
1,
'number'))
calculator.add_op(OperatorDefinition(
'Numerical',
'>=',
'More than or equal to',
BooleansFeature.op_number_morethanequal,
1,
1,
'number'))
calculator.add_op(OperatorDefinition(
'Numerical',
'==',
'Equal to',
BooleansFeature.op_number_equals,
1,
1,
'number'))
calculator.add_op(OperatorDefinition(
'Numerical',
'!=',
'Not equal to',
BooleansFeature.op_number_notequals,
1,
1,
'number'))
calculator.add_op(OperatorDefinition(
'Boolean',
'and',
'And',
BooleansFeature.op_boolean_and,
1,
1,
['boolean', ['boolean', 'exception']]),
{'inputs_can_be_exceptions': True})
calculator.add_op(OperatorDefinition(
'Boolean',
'or',
'Or',
BooleansFeature.op_boolean_or,
1,
1,
['boolean', ['boolean', 'exception']]),
{'inputs_can_be_exceptions': True})
calculator.add_op(OperatorDefinition(
'Boolean',
'xor',
'XOR',
BooleansFeature.op_boolean_xor,
1,
1,
['boolean', ['boolean', 'exception']]),
{'inputs_can_be_exceptions': True})
calculator.add_op(OperatorDefinition(
'Boolean',
'then',
'Ternary - If A is true, then B, else C',
BooleansFeature.op_boolean_conditional,
1,
[1, 'else', 1],
['boolean', None, None]),
{'units_normalise': False, 'inputs_can_be_exceptions': True})
calculator.add_number_caster('boolean', BooleansFeature.number_bool)
calculator.validators['boolean'] = BooleansFeature.validate_boolean
def install(cls, calculator):
calculator.add_op(
OperatorDefinition('String', '<$', 'Less than, alphabetical',
StringComparisonFeature.op_string_lessthan, 1,
1, 'string'))
calculator.add_op(
OperatorDefinition('String', '>$', 'More than, alphabetical',
StringComparisonFeature.op_string_morethan, 1,
1, 'string'))
calculator.add_op(
OperatorDefinition('String', '<=$',
'Less than or equal to, alphabetical',
StringComparisonFeature.op_string_lessthanequal,
1, 1, 'string'))
calculator.add_op(
OperatorDefinition('String', '>=$',
'More than or equal to, alphabetical',
StringComparisonFeature.op_string_morethanequal,
1, 1, 'string'))
calculator.add_op(
OperatorDefinition('String', '==$', 'Equal to, string-wise',
StringComparisonFeature.op_string_equals, 1, 1,
'string'))
calculator.add_op(
OperatorDefinition('String', '!=$', 'Not equal to, string-wise',
StringComparisonFeature.op_string_notequals, 1,
1, 'string'))
calculator.add_op(
OperatorDefinition(
'String Case-Insensitive', '<~',
'Less than, alphabetical, case-insensitive',
StringComparisonFeature.op_stringcaseless_lessthan, 1, 1,
'string'))
calculator.add_op(
OperatorDefinition(
'String Case-Insensitive', '>~',
'More than, alphabetical, case-insensitive',
StringComparisonFeature.op_stringcaseless_morethan, 1, 1,
'string'))
calculator.add_op(
OperatorDefinition(
'String Case-Insensitive', '<=~',
'Less than or equal to, alphabetical, case-insensitive',
StringComparisonFeature.op_stringcaseless_lessthanequal, 1, 1,
'string'))
calculator.add_op(
OperatorDefinition(
'String Case-Insensitive', '>=~',
'More than or equal to, alphabetical, case-insensitive',
StringComparisonFeature.op_stringcaseless_morethanequal, 1, 1,
'string'))
calculator.add_op(
OperatorDefinition(
'String Case-Insensitive', '==~',
'Equal to, string-wise, case-insensitive',
StringComparisonFeature.op_stringcaseless_equals, 1, 1,
'string'))
calculator.add_op(
OperatorDefinition(
'String Case-Insensitive', '!=~',
'Not equal to, string-wise, case-insensitive',
StringComparisonFeature.op_stringcaseless_notequals, 1, 1,
'string'))