symexpress3 0.0.5__py3-none-any.whl

symexpress3/__init__.py

@@ -0,0 +1,26 @@
+"""
+Initilization of the functions and modules symexpress3
+"""
+
+from .symexpress3 import *
+from .version     import __version__,__author__,__copyright__,__credits__,__license__,__maintainer__,__email__,__status__
+
+
+from .symfunc.symRegisterFunctions              import SymRegisterFunctions
+from .optimize.symRegisterOptimize              import SymRegisterOptimize
+from .optSymNumber.symRegisterOptSymNumber      import SymRegisterOptimize as SymRegisterOptSymNumber
+from .optSymVariable.symRegisterOptSymVariable  import SymRegisterOptimize as SymRegisterOptSymVariable
+from .optSymFunction.symRegisterOptSymFunction  import SymRegisterOptimize as SymRegisterOptSymFunction
+from .optSymAny.symRegisterOptSymAny            import SymRegisterOptimize as SymRegisterOptSymAny
+
+
+SymRegisterFunctions()
+SymRegisterOptimize()
+SymRegisterOptSymNumber()
+SymRegisterOptSymVariable()
+SymRegisterOptSymFunction()
+SymRegisterOptSymAny()
+
+RegisterOptimzeActions()
+
+# print( "Symexpress3.__init__ name: " + __name__ )

symexpress3/__main__.py

@@ -0,0 +1,10 @@
+# pylint: disable=invalid-name
+"""
+Commandline handling
+"""
+
+import sys
+
+if __name__ == '__main__':
+  from symexpress3 import symexp3cmd
+  symexp3cmd.CommandLine( sys.argv )

symexpress3/optFunctionBase.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+    Abstract class for optimze variable type` implementation symexpress3
+
+    Copyright (C) 2024 Gien van den Enden - swvandenenden@gmail.com
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+"""
+
+from symexpress3 import symexpress3
+from symexpress3 import optTypeBase
+
+#
+# base class for a specific sym function type
+#
+class OptFunctionBase( optTypeBase.OptTypeBase ):
+  """
+  Base class for type function optimization
+  """
+  def __init__( self ):
+    super().__init__()
+    self._name         = None                     # must be set by in the real class
+    self._symtype      = symexpress3.SymFunction  # symexpress type class, example symexpress3.SymNumber, symexpress3.SymVariable, symexpress3.SymFunction
+    self._desc         = ""                       # description of the optimization
+    self._funcName     = None                     # name of the function
+    self._minparams    = 1                        # minimum number of parameters
+    self._maxparams    = 1                        # maximum number of parameters
+
+
+  @property
+  def functionName(self):
+    """
+    Name of the function
+    """
+    return self._funcName
+
+  @property
+  def minimumNumberOfParameters(self):
+    """
+    Minimum number of parameters
+    """
+    return self._minparams
+
+  @property
+  def maximumNumberOfParameters(self):
+    """
+    Maximum number of parameters
+    """
+    return self._maxparams
+
+
+  def checkType( self, elem, action ):
+    """
+    Check if the given elem
+    """
+    if super().checkType( elem, action ) != True:
+      # print("Name: " + self.name )
+      # print("Type: " + str( self._symtype ))
+      # print( "test 1")
+      return False
+
+    if elem.name != self.functionName:
+      return False
+
+    numElem = elem.numElements()
+    if  numElem < self._minparams :
+      return False
+
+    if numElem > self._maxparams :
+      return False
+
+    return True

symexpress3/optSymAny/optSymAnyArrayPower.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+    Sym Express 3
+
+    Copyright (C) 2024 Gien van den Enden - swvandenenden@gmail.com
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+"""
+
+from symexpress3 import symexpress3
+from symexpress3 import optTypeBase
+
+class OptSymAnyArrayPower( optTypeBase.OptTypeBase ):
+  """
+  Put the power of an array into his elements
+  """
+  def __init__( self ):
+    super().__init__()
+    self._name         = "arrayPower"
+    self._desc         = "Put the power of an array into his elements"
+
+  def optimize( self, elem, action ):
+    if self.checkType( elem, action ) != True:
+      return None
+
+    if not isinstance( elem, symexpress3.SymArray) :
+      return None
+
+    if elem.power == 1 and elem.onlyOneRoot == 1 :
+      return None
+      
+    newArray = symexpress3.SymArray()
+    
+    for iCnt, elemsub in enumerate( elem.elements ):
+      symSub = symexpress3.SymExpress( '*' )
+      symSub.powerCounter     = elem.powerCounter
+      symSub.powerDenominator = elem.powerDenominator
+      symSub.powerSign        = elem.powerSign
+      symSub.onlyOneRoot      = elem.onlyOneRoot
+      symSub.add( elemsub )
+      newArray.add( symSub )
+      
+    return newArray
+
+#
+# Test routine (unit test), see testsymexpress3.py
+#
+def Test( display = False):
+  """
+  Unit test
+  """
+  symTest = symexpress3.SymFormulaParser( "[ 4 | 2 ]^^2" )
+  symTest.optimize()
+  symTest = symTest.elements[ 0 ]
+  testClass = OptSymAnyArrayPower()
+  symNew    = testClass.optimize( symTest, "arrayPower" )
+
+  if display == True :
+    print( f"naam      : {testClass.name}" )
+    print( f"orginal   : {str( symTest )}" )
+    print( f"optimized : {str( symNew  )}" )
+
+  if str( symNew ).strip() != "[ (4)^^2 | (2)^^2 ]":
+    print( f"Error unit test {testClass.name} function" )
+    raise NameError( f'SymAny optimze {testClass.name}, unit test error: {str( symTest )}, value: {symNew}' )
+
+
+if __name__ == '__main__':
+  Test( True )

symexpress3/optSymAny/optSymAnyExpandArray.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+    Sym Express 3
+
+    Copyright (C) 2024 Gien van den Enden - swvandenenden@gmail.com
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+"""
+
+from symexpress3 import symexpress3
+from symexpress3 import optTypeBase
+
+class OptSymAnyExpandArray( optTypeBase.OptTypeBase ):
+  """
+  If the expression containts at least 1 array then make the hole expression an array element.
+  """
+  def __init__( self ):
+    super().__init__()
+    self._name         = "expandArrays"
+    self._desc         = "If the expression containts at least 1 array then make the hole expression an array element."
+
+  def optimize( self, elem, action ):
+
+    def _subExpandSymArray( elem ):
+      if elem.power != 1 or elem.onlyOneRoot != 1 : # use arrayPower first
+        return None
+
+      result = None
+      # for iCnt, elemsub in enumerate( elem.elements ):
+      for elemsub in elem.elements:
+        if isinstance( elemsub, symexpress3.SymArray ):
+          if elemsub.power != 1 or elemsub.onlyOneRoot != 1:
+            continue
+          result = symexpress3.SymArray()
+          break
+      if result != None:
+        # power is always 1 on this point
+        for iCnt, elemsub in enumerate( elem.elements ):
+          if isinstance( elemsub, symexpress3.SymArray ) and elemsub.power == 1 and elemsub.onlyOneRoot == 1:
+            # get the sub elements
+            for elemsub2 in elemsub.elements :
+              result.add( elemsub2 )
+          else:
+            result.add( elemsub )
+
+      return result
+
+    def _subExpandSymFunction( elem ):
+      result  = None
+      iArrPos = -1
+      for iCnt, elemsub in enumerate( elem.elements ):
+        if isinstance( elemsub, symexpress3.SymArray ):
+          if elemsub.power != 1 or elemsub.onlyOneRoot != 1:
+            continue
+          iArrPos = iCnt
+      if iArrPos == -1:
+        return None
+
+      result    = symexpress3.SymArray()
+      arrElem   = elem.elements[ iArrPos ].copy()
+      iNumArray = arrElem.numElements()
+      elem.elements[ iArrPos ] = symexpress3.SymNumber() # place holder
+
+      for iCnt in range( 0, iNumArray ):
+        elemSub = elem.copy()
+        elemSub.elements[ iArrPos ] = arrElem.elements[ iCnt ]
+        result.add( elemSub )
+
+      return result
+
+    def _subExpandSymSymExpress( elem ):
+      return _subExpandSymFunction( elem )
+
+
+    if self.checkType( elem, action ) != True:
+      return None
+
+    # if not isinstance( elem, ( symexpress3.SymArray, symexpress3.SymFunction, symexpress3.SymExpress)) :
+    if not isinstance( elem, ( symexpress3.SymArray, symexpress3.SymFunction)) :
+      return None
+
+    result = None
+    if isinstance( elem, symexpress3.SymArray ):
+      result = _subExpandSymArray( elem )
+    elif isinstance( elem, symexpress3.SymFunction ):
+      result = _subExpandSymFunction( elem )
+    # elif isinstance( elem, symexpress3.SymExpress ):
+    #  result = _subExpandSymSymExpress( elem )
+    return result
+
+
+#
+# Test routine (unit test), see testsymexpress3.py
+#
+def Test( display = False):
+  """
+  Unit test
+  """
+  symTest = symexpress3.SymFormulaParser( "[ 4 | [ a | b ] | 4 ]" )
+  symTest.optimize()
+  symTest = symTest.elements[ 0 ]
+  testClass = OptSymAnyExpandArray()
+  symNew    = testClass.optimize( symTest, "expandArrays" )
+
+  if display == True :
+    print( f"naam      : {testClass.name}" )
+    print( f"orginal   : {str( symTest )}" )
+    print( f"optimized : {str( symNew  )}" )
+
+  if str( symNew ).strip() != "[ 4 | a | b | 4 ]":
+    print( f"Error unit test {testClass.name} function" )
+    raise NameError( f'SymAny optimze {testClass.name}, unit test error: {str( symTest )}, value: {symNew}' )
+
+
+  symTest = symexpress3.SymFormulaParser( "cos( 1, [ 2 | 3 ], 4)" )
+  symTest.optimize()
+  symTest = symTest.elements[ 0 ]
+  testClass = OptSymAnyExpandArray()
+  symNew    = testClass.optimize( symTest, "expandArrays" )
+
+  if display == True :
+    print( f"naam      : {testClass.name}" )
+    print( f"orginal   : {str( symTest )}" )
+    print( f"optimized : {str( symNew  )}" )
+
+  if str( symNew ).strip() != "[  cos( 1,2,4 ) |  cos( 1,3,4 ) ]":
+    print( f"Error unit test {testClass.name} function" )
+    raise NameError( f'SymAny optimze {testClass.name}, unit test error: {str( symTest )}, value: {symNew}' )
+
+
+  # symTest = symexpress3.SymFormulaParser( "4 + [ 5 | 6 ]" )
+  # symTest.optimize()
+  # # symTest = symTest.elements[ 0 ]
+  # testClass = OptSymAnyExpandArray()
+  # symNew    = testClass.optimize( symTest, "expandArrays" )
+
+  # if display == True :
+  #   print( f"naam      : {testClass.name}" )
+  #   print( f"orginal   : {str( symTest )}" )
+  #   print( f"optimized : {str( symNew  )}" )
+
+  # if str( symNew ).strip() != "[ 4 + 5 | 4 + 6 ]":
+  #   print( f"Error unit test {testClass.name} function" )
+  #   raise NameError( f'SymAny optimze {testClass.name}, unit test error: {str( symTest )}, value: {symNew}' )
+
+
+if __name__ == '__main__':
+  Test( True )

symexpress3/optSymAny/symRegisterOptSymAny.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+    Registration any optimze for symexpress3
+
+    Copyright (C) 2024 Gien van den Enden - swvandenenden@gmail.com
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+    Example documentenion:
+            pdoc3 --html symFuncCeilFloor.py
+
+"""
+
+from symexpress3           import symtables
+from symexpress3.optSymAny import optSymAnyArrayPower
+from symexpress3.optSymAny import optSymAnyExpandArray
+
+#
+# automatic called from symepxress3
+#
+def SymRegisterOptimize():
+  """
+  Register all the any optimize classes
+  """
+  symtables.RegisterTableEntry( 'optSymAny', optSymAnyArrayPower.OptSymAnyArrayPower()   )
+  symtables.RegisterTableEntry( 'optSymAny', optSymAnyExpandArray.OptSymAnyExpandArray() )
+
+#
+# Get all the modules from the optSymVariable, used in testsymexpress3.py
+#
+def SymRegisterGetModuleNames():
+  """
+  Get all the modules of the any optimizes
+  """
+
+  symModules = []
+
+  symModules.append( optSymAnyArrayPower             )
+  symModules.append( optSymAnyExpandArray            )
+
+  return symModules
+
+if __name__ == '__main__':
+  SymRegisterOptimize()
+  print( "Modules: " + str( ( SymRegisterGetModuleNames() )))
+  # print( "globals: " + str( globals() ))

symexpress3/optSymFunction/__init__.py

@@ -0,0 +1,5 @@
+"""
+Optimze functions
+"""
+# from .symRegisterOptSymFunction import SymRegisterOptimize
+# SymRegisterOptimize()

symexpress3/optSymFunction/optSymFunctionCosAtanDiv3.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+    Sym Express 3
+
+    Copyright (C) 2024 Gien van den Enden - swvandenenden@gmail.com
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+
+"""
+
+from symexpress3 import symexpress3
+from symexpress3 import optFunctionBase
+
+class OptSymFunctionCosAtanDiv3( optFunctionBase.OptFunctionBase ):
+  """
+  sin(atan(x)/n) to sin i cos
+  """
+  def __init__( self ):
+    super().__init__()
+    self._name         = "cosAtanDiv3"
+    self._desc         = "Convert cos(atan(x)/3) to value"
+    self._funcName     = "cos"                    # name of the function
+    self._minparams    = 1                        # minimum number of parameters
+    self._maxparams    = 1                        # maximum number of parameters
+
+
+  def optimize( self, elem, action ):
+    # https://www.quora.com/Is-there-a-method-to-calculate-cos-%CF%80-7-and-sin-%CF%80-7
+    if self.checkType( elem, action ) != True:
+      return None
+
+    elem1 = elem.elements[0]
+    if not isinstance( elem1, symexpress3.SymExpress ):
+      return None
+
+    if elem1.symType != '*':
+      return None
+
+    if elem1.numElements() != 2: # can be any number greater as 1 but for the moment only atan
+      return None
+
+    elemA = elem1.elements[0]
+    elemB = elem1.elements[1]
+    # one must be a function, second must be number
+
+    if not isinstance( elemA, symexpress3.SymFunction):
+      elemB = elem1.elements[0]
+      elemA = elem1.elements[1]
+
+    if not isinstance( elemA, symexpress3.SymFunction):
+      return None
+
+    if not isinstance( elemB, symexpress3.SymNumber):
+      return None
+
+    if elemA.name != "atan":  # can be anything but for the moment only atan
+      return None
+
+    if elemB.power != 1:
+      return None
+
+    if elemB.factSign != 1:
+      return None
+
+    if elemB.factCounter != 1:
+      return None
+
+    if elemB.factDenominator != 3:
+      return None
+
+    # elemA = atan(x)
+    # elemB = 1/3
+
+    # "(( ((cos(x)^^2 - 1)^^(1/2) + cos(x))^^(1/3) + ( ((cos(x)^^2 - 1)^^(1/2) + cos(x))^^(1/3) )^^(-1))) * 1/2"
+
+    convertFrm = "(( ((cos(" + str( elemA ) + ")^^2 - 1)^^(1/2) + cos(" + str(elemA) + "))^^(1/3) + (( ((cos(" + str( elemA ) + ")^^2 - 1)^^(1/2) + cos(" + str(elemA) + "))^^(1/3) )^^(-1))) * 1/2"
+
+    exprResult = symexpress3.SymFormulaParser( convertFrm  )
+
+    return exprResult
+    # https://www.quora.com/What-is-the-formula-for-sin-x-3-one-third-angle-formula
+    # sin(x/3) =
+    # (
+    #  ( -1 * sin( x ) + (sin(x)^^2 - 1)^^(1/2) ) / 8
+    # )^^(1/3)
+    #  +
+    # (
+    #  ( -1 * sin( x ) - (sin(x)^^2 - 1)^^(1/2) ) / 8
+    # )^^(1/3)
+    #
+    # incorrecte antwoorden in de volgende situaties:
+    # x = pi / 2 - 1/10     -> fout antwoord, dezelfde als  pi / 2 + 1/10
+    # x = pi / 2 + 1/10     -> goed antwoord
+    # x = pi / 2            -> goed antwoord -> dit lijkt een spiegel (mirror) te zijn,
+    #                                           Alles hieronder is fout, alles hierboven is goed`
+
+#
+# Test routine (unit test), see testsymexpress3.py
+#
+def Test( display = False):
+  """
+  Unit test
+  """
+  symTest = symexpress3.SymFormulaParser( "cos(atan(x)/3)" )
+  symTest.optimize()
+  symTest = symTest.elements[ 0 ]
+
+  # print( "symTest: " + str( symTest ))
+
+  testClass = OptSymFunctionCosAtanDiv3()
+  symNew    = testClass.optimize( symTest, "cosAtanDiv3" )
+
+  if display == True :
+    print( f"naam      : {testClass.name}" )
+    print( f"orginal   : {str( symTest )}" )
+    print( f"optimized : {str( symNew  )}" )
+
+  if str( symNew ).strip() != "((( cos(  atan( x ) )^^2 + (-1) * 1)^^(1/2) +  cos(  atan( x ) ))^^(1/3) + ((( cos(  atan( x ) )^^2 + (-1) * 1)^^(1/2) +  cos(  atan( x ) ))^^(1/3))^^-1) * 1 * 2^^-1":
+    print( f"Error unit test {testClass.name} function" )
+    raise NameError( f'SymFunction optimze {testClass.name}, unit test error: {str( symTest )}, value: {str( symNew )}' )
+
+
+if __name__ == '__main__':
+  Test( True )