daamath 0.2.0__py3-none-any.whl

daamath/__init__.py

@@ -0,0 +1,23 @@
+from .context import Context
+
+from . import functions, numbers, strings, domains
+from .functions import *
+from .numbers import *
+from .strings import *
+from .domains import *
+from . import enums
+
+from . import aliases
+from .aliases import *
+
+from . import exceptions
+
+context = Context(
+        functions = '',
+        datatypes = ''
+#        check_input_domain  = True,
+#        check_output_domain = True,
+#        domain              = REAL,
+#        error_policy     = enums.ErrorPolicy.FLAG_RAISE_HALT,
+#        rounding            = roundeven,
+    )

daamath/aliases.py

@@ -0,0 +1,125 @@
+import daamath as dm
+
+# hyperoperation
+succ  = dm.h0c # hyperoperation of 0th order, solving for c in the equation a ? b = c
+pred  = dm.h0b
+add   = dm.h1c
+sub   = dm.h1b
+mul   = dm.h2c
+div   = dm.h2b
+pow   = dm.h3c
+log   = dm.h3b
+root  = dm.h3a
+spow  = dm.h4c
+slog  = dm.h4b
+sroot = dm.h4a
+
+# hyperoperation extra
+ainv    = dm.h1b_0  # sub with first argument fixed to 0
+minv    = dm.h2b_1
+exp     = dm.h3c_e
+exp2    = dm.h3c_2
+exp10   = dm.h3c_10
+ln      = dm.h3b__e # log with second argument fixed to e
+log2    = dm.h3b__2
+log10   = dm.h3b__10
+square  = dm.h3c__2
+cube    = dm.h3c__3
+sqrt    = dm.h3a__2
+cbrt    = dm.h3a__3
+rsquare = dm.h2b_1_h3c__2 # minv of square of x
+rcube   = dm.h2b_1_h3c__3
+rsqrt   = dm.h2b_1_h3a__2
+rcbrt   = dm.h2b_1_h3a__3
+fma     = dm.h1c_h2c      # dm.add_mul
+expm1   = dm.h1b_h3c_e__1 # dm.sub_pow_e__1
+ln1p    = dm.h3b_h1c_1__e # dm.log_add_1__e
+
+# trigonometry
+sin   = dm.croh # circular ratio from opposite and hypotenuse
+cos   = dm.crah
+tan   = dm.croa
+cot   = dm.crao
+sec   = dm.crha
+csc   = dm.crho
+asin  = dm.csoh
+acos  = dm.csah
+atan  = dm.csoa
+acot  = dm.csao
+asec  = dm.csha
+acsc  = dm.csho
+sinh  = dm.hroh
+cosh  = dm.hrah
+tanh  = dm.hroa
+coth  = dm.hrao
+sech  = dm.hrha
+csch  = dm.hrho
+asinh = dm.hsoh
+acosh = dm.hsah # hyperbolic semiarea from adjacent and hypotenuse
+atanh = dm.hsoa
+acoth = dm.hsao
+asech = dm.hsha
+acsch = dm.hsho
+
+# trigonometry extra
+asin2  = dm.csoh2 # 2-argument version of dm.csoh
+acos2  = dm.csah2
+atan2  = dm.csoa2
+acot2  = dm.csao2
+asec2  = dm.csha2
+acsc2  = dm.csho2
+sinc   = dm.h2b_croh_S_S  # dm.div_sin_S_S
+
+# boolean
+not_ = dm.tf   # F, T → T, F
+and_ = dm.ffft # FF, FT, TF, TT → F, F, F, T
+or_  = dm.fttt
+xor  = dm.fttf
+imp  = dm.ttft
+con  = dm.tftt
+nand = dm.tttf
+nor  = dm.tfff
+nxor = dm.tfft # NOTE: nxor, not xnor
+nimp = dm.fftf
+ncon = dm.ftff
+
+# interval
+lt = dm.iee   # A |B| C → include exclude exclude
+le = dm.iie
+eq = dm.eie
+ne = dm.iei
+ge = dm.eii
+gt = dm.eei
+oo = dm.eeiee # A |B| C |D| E → exclude exclude include exclude exclude
+oc = dm.eeiie
+co = dm.eiiee
+cc = dm.eiiie
+
+# variadic
+sum   = dm.vh1c
+prod  = dm.vh2c
+all   = dm.vffft
+any   = dm.vfttt
+min   = dm.mean__h1b_0_inf
+hmean = dm.mean__h1b_0_1
+gmean = dm.mean__0
+amean = dm.mean__1
+rms   = dm.mean__2
+cmean = dm.mean__3
+max   = dm.mean__inf
+
+# idk bro
+abs = dm.norm__2
+sgn = dm.normalize__2
+
+# quantization
+floor      = dm.round__true_floor
+ceil       = dm.round__true_ceil
+trunc      = dm.round__true_trunc
+away       = dm.round__true_away
+roundfloor = dm.round__false_floor
+roundceil  = dm.round__false_ceil
+roundtrunc = dm.round__false_trunc
+roundaway  = dm.round__false_away
+roundeven  = dm.round__false_even
+roundodd   = dm.round__false_odd

daamath/context.py

@@ -0,0 +1,16 @@
+from typing import Any
+from dataclasses import dataclass
+
+@dataclass
+class Functions:
+    ...
+
+@dataclass
+class DataTypes:
+    ...
+
+@dataclass
+class Context:
+    "a collection of variables that define daamath's behaviour"
+    functions: Functions
+    datatypes: DataTypes

daamath/domains.py

@@ -0,0 +1,93 @@
+# a domain is a function with special UPPERCASE naming, because it is treated as both an object and also as a function
+
+from typing import Any, Callable
+import numbers
+
+# 1st order domains (indicator functions):
+def THING(fish: Any) -> bool:
+    'the base domain of anything. everything is a thing. even nothing is a thing. the indicator function simply returns `true`'
+    return True
+
+def TRUTH(fish: Any) -> bool:
+    'idk'
+    return True
+
+def BOOLEAN(fish: Any) -> bool:
+    'idk'
+    return True
+
+def NUMBER(fish: Any) -> bool:
+    return isinstance(fish, numbers.Number)
+                              
+def HYPERCOMPLEX(fish: Any) -> bool:
+    'idk'
+    return NUMBER(fish)
+
+def OCTONION(fish: Any) -> bool:        
+    'fish is HYPERCOMPLEX and fish has non-zero octonion vector part'
+    return HYPERCOMPLEX(fish)
+
+def QUATERNION(fish: Any) -> bool:      
+    'fish is OCTONION and fish has non-zero quaternion vector part'
+    return OCTONION(fish)
+
+def COMPLEX(fish: Any) -> bool:         
+    'fish is QUATERNION and fish has non-zero imaginary part'
+    return OCTONION(fish) and fish.imag == 0
+
+def IMAGINARY(fish: Any) -> bool:
+    'fish is COMPLEX and real part is zero'
+    return COMPLEX(fish) and fish.real == 0
+
+def REAL(fish: Any) -> bool:            
+    'fish is COMPLEX and imaginary part is zero'
+    return COMPLEX(fish) and fish.imag == 0
+
+def RATIONAL(fish: Any) -> bool:        
+    'fish is REAL and fish can be represented as p / q where q ≠ 0'
+    return REAL(fish) and isinstance(fish, numbers.Rational)
+
+def INTEGER(fish: Any) -> bool:         
+    'fish is RATIONAL and fish is divisible by 1'
+    return RATIONAL(fish) and fish % 1 == 0
+
+def IRRATIONAL(fish: Any) -> bool:      
+    'fish is REAL and fish is not RATIONAL'
+    return REAL(fish) and not RATIONAL(fish)
+
+def PRIME(fish: Any) -> bool:           
+    'fish is NATURALSTART_2 and fish has two prime divisors'
+    raise NotImplementedError('developer hasnt defined this yet')
+    return NATURALSTART
+
+def COMPOSITE(fish: Any) -> bool:       
+    'fish is NATURAL_1 and fish has more than two prime divisors'
+    raise NotImplementedError('developer hasnt defined this yet')
+    return NATURALSTART_1(fish)
+
+# 2nd order domains (domain constructors):
+
+def NATURALFROM(start: int) -> Callable[[Any], bool]:
+    'natural numbers starting from N'
+    if not INTEGER(start) or start < 0:
+        raise ValueError('start must be non-negative integer')
+    
+    def NATURALFROM(fish: Any) -> bool:
+        return INTEGER(fish) and fish >= start
+    return NATURALFROM
+
+NATURALFROM_0: Callable[[Any], bool] = NATURALFROM(0)
+NATURALFROM_1: Callable[[Any], bool] = NATURALFROM(1)
+NATURALFROM_2: Callable[[Any], bool] = NATURALFROM(2)
+
+def INTEGERMODULO(mod: int) -> Callable[[Any], bool]:
+    'integers modulo N, like in modular arithmetic'
+    if mod == 0:
+        return INTEGER
+    if not INTEGER(mod) or mod < 0:
+        raise ValueError(f'sorry, but i want mod to be a non-negative integer. i dont know what integers modulo {mod} would mean')
+    def INTEGERMODULO_N(fish: Any) -> bool:
+        return INTEGER(fish) and fish // mod == 0
+    return INTEGERMODULO
+
+INTEGERMODULO_2: Callable[[Any], bool] = INTEGERMODULO(2)

daamath/enums.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+class ErrorPolicy:
+    SENTINEL = 0
+    FLAG_SENTINEL = 1
+    RAISE_HALT = 2
+    FLAG_RAISE_HALT = 3
+
+class SentinelPolicy:
+    IGNORE = 0
+    PROPAGATE = 1

daamath/exceptions.py

@@ -0,0 +1,53 @@
+from .context import Context
+from collections.abc import Callable
+from typing import Any
+
+class Error(Exception):
+    'the base class of any exception in daamath'
+
+class DomainError(Error, ArithmeticError):
+    'this occurs when something related to the domain goes wrong'
+
+class DataTypeError(Error, TypeError):
+    'this occurs when something related to the datatype goes wrong'
+
+class OutOfDomainError(DomainError):
+    'this occurs when something is unexpectedly not in a domain'
+
+    def __init__(self, function_or_str: Callable | str, args: tuple[...] = None, kwargs: dict[str, Any] = None, output: Any = None, context: Context = None):
+        'the arguments here are entirely optional. these are just here to help you format the error message neater'
+        if args is None and kwargs is None and output is None:
+            super().__init__(function_or_str)
+            return
+        
+        if args is None or kwargs is None or output is None:
+            raise ValueError('developer! lazy developer! give args, kwargs, output for this function')
+
+        raise NotImplementedError
+        
+        args: str = ', '.join(f'{type(input).__name__} {input}' for arg in args)
+        kwargs: str = ', '.join(f'{key}={val!r}' for key, val in kwargs)
+        
+        function: str = function_or_str.__name__
+        inputs: list[Any] = [f'{type(input).__name__} {input}' for arg in args] + []
+        input_types: list[Any] = [f'{type(input).__name__} {input}' for arg in args] + []
+        input_domains: list[Any] = []
+        output_type: str = type(output).__name__
+        output_domain: str = str(getattr(context.functions, function.__name__))
+
+        super().__init__(f'{function}{output_type} {output} which is not {output_domain}')
+        
+    # this cheeky hack allows it to show things like:
+    # ClosureError: float INTEGER div(float INTEGER 1.0, float INTEGER 2.0) returned float 0.5 which is not INTEGER
+    # instead of:
+    # dm.exceptions.ClosureError: float INTEGER div(float INTEGER 1.0, float INTEGER 2.0) returned float 0.5 which is not INTEGER
+    __module__ = 'builtins'
+
+class FidelityError(DataTypeError):
+    'this occurs when a datatype cannot represent something accurately'
+    
+    # this cheeky hack allows it to show things like:
+    # RepresentationError: int REAL div(int REAL 1.0, int REAL 2.0) returned REAL 0.5 which cannot be accurately represented by int
+    # instead of:
+    # dm.exceptions.RepresentationError: int REAL div(int REAL 1.0, int REAL 2.0) returned REAL 0.5 which cannot be accurately represented by int
+    __module__ = 'builtins'

daamath/functions/__init__.py

@@ -0,0 +1,27 @@
+# hey! you! yeah, you! daa!
+#
+# also, implement vector products like dot product, cross product (just a compositon of wedge product and hodge star. also, in 3D and 7D only! because they tie with quaternions and octonions, but none higher. no more normed algebrae after that), wedge product, 
+
+from . import arithmetic, arithmetic_extra, complex, complex_extra, trigonometry, trigonometry_extra, logic, interval, combinatoric, variadic, quantization, sigmoids, mapping, tensor, miscellaneous
+
+from .arithmetic import h0c, h0b, h1c, h1b, h2c, h2b, h3c, h3b, h3a, h4c, h4b, h4a
+from .arithmetic_extra import h1b_0, h2b_1, h3c_e, h3c_2, h3c_10, h3b__e, h3b__2, h3b__10, h3c__2, h3c__3, h3a__2, h3a__3, h2b_1_h3c__2, h2b_1_h3c__3, h2b_1_h3a__2, h2b_1_h3a__3, h1c_h2c, h1b_h3c_e__1, h3b_h1c_1__e
+
+from .complex import real, imag, arg, rect, polar, conj
+from .complex_extra import cis
+
+from .trigonometry import croh, crah, croa, crao, crha, crho, csoh, csah, csoa, csao, csha, csho, hroh, hrah, hroa, hrao, hrha, hrho, hsoh, hsah, hsoa, hsao, hsha, hsho
+from .trigonometry_extra import csoh2, csah2, csoa2, csao2, csha2, csho2, h2b_croh_S_S
+
+from .logic import tf, ffft, fttt, fttf, ttft, tftt, tttf, tfff, tfft, fftf, ftff
+from .interval import iee, iie, eie, iei, eii, eei, eeiee, eeiie, eiiee, eiiie
+
+from .variadic import vffft, vfttt, vh1c, vh2c, mean, mean__h1b_0_inf, mean__h1b_0_1, mean__0, mean__1, mean__2, mean__3, mean__inf, vparallel
+from .combinatoric import fact, sumt, comb, perm, gcd, lcm
+from .quantization import round, round__true_floor, round__true_ceil, round__true_trunc, round__true_away, round__false_floor, round__false_ceil, round__false_trunc, round__false_away, round__false_even, round__false_odd, quot, rem, quotrem
+from .sigmoids import sigmoid_tan, sigmoid_tanh
+from .mapping import lerp, unlerp, map, fixed_log, fixed_exp, soft_log, soft_exp
+from .tensor import norm, normalize, clamp, norm__2, normalize__2
+from .miscellaneous import ifelse
+
+from .solvers import roots, coeffs

daamath/functions/arithmetic.py

@@ -0,0 +1,228 @@
+# these operators dont treat nested lists as tensors. do you know why?
+# because the tensor object should know itself how to do basic math ops. an operator is an operator.. an object should know what to do with an operator.
+# its also because this tensor mechanism is hard to scale across languages
+
+'''
+instead of:
+                     root   sroot
+                      |      |
+                     pow -- spow -- …
+                   /
+succ -- add -- mul   
+ |       |      |  \
+pred    sub    div   exp -- sexp -- …
+                      |      |
+                     log    slog 
+
+we should have:
+X       h0X     h1X     h2X     h3X     h4X     h5X     …
+c       ++b     a + b   a * b   a ^ b   a ↑ b   a ⇑ b   …
+b       --c     c - a   c / a   c L b   …       …       …
+a       N/A     c - b   c / b   c √ b   …       …       …
+
+where we X is the variable we solve for in the equation a ? b = c
+'''
+
+# NOTE: i expect these function signatures: 
+# hXc(a, b)
+# hXb(c, a)
+# hXa(c, b)
+#
+# i could make it a cycle of variables like so:
+# hXc(a, b)
+# hXb(c, a)
+# hXa(b, c)
+#
+# but this would imply that the three variables are involved in a cyclic relation a → b → c → a when, really, they are involved in a 2 → 1 relation a, b → c. thats why when solving for b and a, we make it intentionally asymmetric
+
+import math, cmath, functools
+from numbers import Number, Real, Integral
+from typing import Literal
+from ..exceptions import DomainError
+
+
+#h0c = functools.partial(h1c, a = 1)
+def h0c(b: Integral) -> Integral:
+    'c = ++b, successor. the 0th hyperoperation'
+    if not isinstance(b, Integral):
+        raise DomainError('')
+    c = b + 1
+
+    if type(c) != type(b):
+        raise DomainError(succ, (b, ), c)
+
+    return c
+    
+#h0b = functools.partial(h1b, x = 1)
+def h0b(c):
+    'b = --c, predecessor. the inverse of the 0th hyperoperation'
+    b = c - 1
+
+    if type(b) != type(c):
+        raise DomainError(pred, (c, ), b)
+
+    return b
+    
+def h1c(a, b):
+    'c = a + b, addition. the 1st hyperoperation'
+    if type(a) != type(b):
+        raise TypeError(f'{a} and {b} must be same type')
+
+    c = a + b
+
+    if type(a) != type(c):
+        raise DomainError(add, (a, b), c)
+    
+    return c
+
+def h1b(c, a):
+    'b = c - a, left subtraction. the inverse of the 1st hyperoperation'
+    if type(c) != type(a):
+        raise TypeError(f'{c} and {a} must be same type')
+    
+    b = c - a
+    
+    if type(b) != type(c):
+        raise DomainError(sub, (c, a), b)
+    
+    return b
+
+def h2c(a, b):
+    'c = a * b, multiplication. the 2nd hyperoperation'
+    if type(a) != type(b):
+        raise TypeError(f'{a} and {b} must be same type')
+
+    c = a * b
+
+    if type(c) != type(a):
+        raise DomainError(mul, (a, b), c)
+    
+    return c
+
+def h2b(c, a):
+    'b = c / a, left division. the inverse of the 2nd hyperoperation'
+    if type(c) != type(a):
+        raise TypeError(f'{c} and {a} must be same type')
+
+    if isinstance(a, int) and a % b != 0:
+        raise DomainError
+    b = c / a
+    
+    if type(b) != type(c):
+        raise DomainError(div, (c, a), b)
+
+    return b
+
+def h3c(a, b):
+    'c = a ^ b, power, exponentiation. the 3rd hyperoperation'
+    if type(a) != type(b):
+        raise TypeError(f'{a} and {b} must be same type')
+
+    c = a ** b
+    
+    if type(c) != type(a):
+        raise DomainError(pow, (a, b), c)
+
+    return c
+
+def h3b(a, c):
+    'b = log_a(c), logarithm. the inverse of the 3rd hyperoperation that solves for b'
+    # c = a ^ b
+    if type(a) != type(c):
+        raise TypeError(f'{a} and {c} must be same type')
+
+    try:
+        b = math.log(c, a)
+    except:
+        b = cmath.log(c, a)
+
+    if type(b) != type(a):
+        raise DomainError(log, (a, c), b)
+
+    return b
+    
+def h3a(b, c):
+    'a = b √ c, n-th root. the inverse of the 3rd hyperoperation that solves for a'
+    if type(b) != type(c):
+        raise TypeError(f'{b} and {c} must be same type')
+    # c = a ^ b
+    a = c ** (1 / b)
+    
+    if type(a) != type(b):
+        raise DomainError(root, (b, c), a)
+
+    return a
+
+def h4c(a, b):
+    'c = a ↑ b, tetration, superexponentiation, the 4th hyperoperation'
+    if type(a) != type(b):
+        raise TypeError(f'{a} and {b} must be same type')
+
+    raise NotImplementedError
+    
+    if type(c) != type(a):
+        raise DomainError(spow, (a, b), c)
+    
+    return c
+
+def h4b(a, c):
+    'b = slog_a(c), superlogarithm, the inverse of the 4th hyperoperation'
+    if type(a) != type(c):
+        raise TypeError(f'{a} and {c} must be same type')
+
+    raise NotImplementedError
+    
+    if type(b) != type(a):
+        raise DomainError(slog, (a, c), b)
+    
+    return b
+
+def h4a(b, c):
+    'superroot. idfk what this is supposed to be in terms of code'
+    if type(b) != type(c):
+        raise TypeError(f'{b} and {c} must be same type')
+
+    raise NotImplementedError
+
+    if type(b) != type(a):
+        raise DomainError(slog, (b, c), a)
+    
+    return a
+
+
+'''
+# this thing is just a novelty
+def hyper(
+        left: Number, 
+        right: Number, 
+        n: int, 
+        solve: Literal['a', 'b', 'c'] = 'c', 
+        ) -> Number:
+    match solve:
+        case 'a':
+            match n:
+                case 0: raise ArithmeticError('this operation simply does not exist in mathematics')
+                case 1: return h1a(left, right)
+                case 2: return h2a(left, right)
+                case 3: return h3a(left, right)
+                case 4: return h4a(left, right)
+                case _: raise NotImplementedError
+        case 'b':
+            match n:
+                case 0: return h0b(right)
+                case 1: return h1b(left, right)
+                case 2: return h2b(left, right)
+                case 3: return h3b(left, right)
+                case 4: return h4b(left, right)
+                case _: raise NotImplementedError
+        case 'c':
+            match n:
+                case 0: return h0c(right)
+                case 1: return h1c(left, right)
+                case 2: return h2c(left, right)
+                case 3: return h3c(left, right)
+                case 4: return h4c(left, right)
+                case _: raise NotImplementedError
+        case _:
+            raise ValueError("invalid solve parameter. must be one of {'a', 'b', 'c'}")
+'''

daamath/functions/arithmetic_extra.py

@@ -0,0 +1,120 @@
+import math, cmath
+from numbers import Number, Real
+from ..exceptions import DomainError
+
+def h1b_0(a: Number) -> Number:
+    'sub(0, a), additive inverse'
+    
+    b = -a
+    
+    if type(a) != type(b):
+        raise DomainError(ainv, (a, ), b)
+    
+    return b
+
+def h2b_1(a: Number) -> Number:
+    'div(1, a), multiplicative inverse'
+    b = 1 / a
+
+    if type(a) != type(b):
+        raise DomainError(minv, (a, ), b)
+
+    return b
+
+'''
+def abs_sq(a: Number) -> Real:
+    if isinstance(x, Complex):
+        return x.real * x.real + x.imag * x.imag 
+    else:
+        return abs(a) ** 2
+'''
+
+def h3c__2(a: Number) -> Number:
+    'pow(a, 2), inverse of sqrt'
+    return a * a
+
+def h3c__3(a: Number) -> Number:
+    'pow(a, 3), inverse of cbrt'
+    return a * a * a
+
+def h3a__2(c: Number) -> Number:
+    'root(2, a). inverse of square'
+    try:    return math.sqrt(c)
+    except:    return cmath.sqrt(c)
+
+def h3a__3(c: Number) -> Number:
+    'root(3, a). inverse of cube'
+    try:    return math.cbrt(c)
+    except: return c ** (1 / 3)
+
+def h2b_1_h3c__2(a: Number) -> Number:
+    'reciprocal square. inverse of rsqrt'
+    return a ** -2
+
+def h2b_1_h3c__3(a: Number) -> Number:
+    'reciprocal cube. inverse of rcbrt'
+    return a ** -2
+
+def h2b_1_h3a__2(c: Number) -> Number:
+    'reciprocal square root. inverse of rsquare'
+    return c ** -0.5
+
+def h2b_1_h3a__3(c: Number) -> Number:
+    'reciprocal cube root. inverse of rcube'
+    return a ** -3
+
+def h3c_e(b: Number) -> Number:
+    'e ^ b'
+    try:    return math.exp(b)
+    except: return cmath.exp(b)
+
+def h3c_2(b: Number) -> Number:
+    'pow(2, b), inverse of log_2'
+    try:    return math.exp2(b)
+    except:    return 2 ** b
+
+def h3c_10(b: Number) -> Number:
+    'pow(10, b), inverse of log_10'
+    return 10 ** b
+
+def h3b__e(c: Number) -> Number:
+    'log_e(c)'
+    try:    return math.log(c)
+    except: return cmath.log(c)
+
+def h3b__2(a: Number) -> Number:
+    'log(2, a), inverse of pow_2'
+    try:    return math.log2(a)
+    except:    return cmath.log(a, 2)
+
+def h3b__10(a: Number) -> Number:
+    'log(10, a), inverse of pow_10'
+    try:    return math.log10(a)
+    except: return cmath.log10(a)
+
+#def pow_m1(a: Number, b: Number) -> Number:
+#    return math.expm1(math.log(a) * b)
+
+#def root_1p(a: Number, b: Number) -> Number:
+#    return math.exp(math.log1p(a) / b)
+
+def h1b_h3c_e__1(b: Number) -> Number:
+    'exp(b) - 1'
+    return e ** b - 1
+
+def h3b_h1c_1__e(c: Number) -> Number:
+    'ln(1 + c)'
+    try:
+        try:
+            return math.log1p(c)
+        except:
+            return math.log(1 + c)
+    except:    
+        return cmath.log(1 + c)
+
+try:
+    from math import fma as h1c_h2c
+except ImportError:
+    def h1c_h2c(a: float, b: float, c: float) -> float:
+        'a * b + c, fused multiply add'
+        return a * b + c