• Home
• com.soartech
• jsoar-performance-testing
• 5.0.1
• source code
• add.soar

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

APT.all-test.Algebra.algebra.solve-problem.add.soar Maven / Gradle / Ivy

## Add
## Includes proposals for add, subtract, multiply, divide between numbers
## Includes special cases for when one is not a value and other is
##    0 (multiply, add, subtract, divide) or 1
##    1 (multiply, divide)

sp {algebra*propose*add*value
   (state  ^name solve-problem
              ^current-clause )
   ( ^operation { << multiply divide add subtract >>  }
         ^right-side.type number
         ^left-side.type number)
-->
   ( ^operator  + = 90)
   ( ^name )
}

sp {algebra*propose*subtract-divide*value
   (state  ^name solve-problem
              ^current-clause )
   ( ^operation { << divide subtract >>  }
         ^right-side.type variable
         ^left-side.type variable)
-->
   ( ^operator  + = 90)
   ( ^name )
}

sp {algebra*propose*add*value-0*right
   (state  ^name solve-problem
              ^current-clause )
   ( ^operation { << multiply add subtract >>  }
         ^right-side.value << 0. 0 >>
        -^left-side.type number)
-->
   ( ^operator  + = 90)
   ( ^name )
}

sp {algebra*propose*add*value-0*left
   (state  ^name solve-problem
              ^current-clause )
   ( ^operation { << multiply divide add >>  }
         ^left-side.value << 0 0. >>
        -^right-side.type number)
-->
   ( ^operator  + = 90)
   ( ^name )
}

sp {algebra*propose*mulitply*value-1*right
   (state  ^name solve-problem
              ^current-clause )
   ( ^operation { << multiply divide >>  }
        -^dont-multiply true
         ^right-side.value << 1. 1 >>
        -^left-side.type number)
-->
   ( ^operator  + = 90)
   ( ^name )
}

sp {algebra*propose*multiply*value-1*left
   (state  ^name solve-problem
              ^current-clause )
   ( ^operation { << multiply >>  }
        -^dont-multiply true
         ^left-side.value << 1 1. >>
        -^right-side.type number)
-->
   ( ^operator  + = 90)
   ( ^name )
}

################ ADD

sp {algebra*apply*add*values
   (state  ^operator.name add
              ^current-clause )
   ( ^right-side 
         ^left-side 
         ^operation add)
   ( ^type number
         ^value )
   ( ^type number
         ^value )
-->
   (write (crlf) |Add |  |+|  )
   ( ^right-side  -
         ^left-side  -
         ^operation add -
         ^type number
         ^value (+  ))
}


sp {algebra*apply*add*values-0-right-left-variable
   (state  ^operator 
              ^current-clause )
   ( ^name add
        ^clause )
   ( ^right-side 
         ^left-side 
         ^parent-clause 
         ^operation add)
   ( ^ { << left-side right-side >>  } )
   ( ^type number
         ^value << 0. 0 >>)
   ( -^type number)
-->
   (write (crlf) |Add |  | + | 0 )
   ( ^  -
         ^ )
   ( ^current-clause  -
                        )
}

sp {algebra*apply*add*values-0-left-right-variable
   (state  ^operator 
              ^current-clause )
   ( ^name {  << add subtract >> }
        ^clause )
   ( ^right-side 
         ^left-side 
         ^parent-clause 
         ^operation )
   ( ^ { << left-side right-side >>  } )
   ( ^type number
         ^value << 0. 0 >>)
   ( -^type number)
-->
   (write (crlf)  | |  | | 0 )
   ( ^  -
         ^ )
   ( ^current-clause  -
                        )
}

############Subtract##############

sp {algebra*apply*subtract
   (state  ^operator.name subtract
              ^current-clause )
   ( ^right-side 
         ^left-side 
         ^operation subtract)
   ( ^type number
         ^value )
   ( ^type number
         ^value )
-->
   (write (crlf) |Subtract |  | - |  )
   ( ^right-side  -
         ^left-side  -
         ^operation subtract -
         ^type number
         ^value (-  ))
}

sp {algebra*apply*subtract*variable
   (state  ^operator.name subtract
              ^current-clause )
   ( ^right-side 
         ^left-side 
         ^operation subtract)
   ( ^type variable
         ^value )
   ( ^type variable
         ^value )
-->
   (write (crlf) |Subtract |  | - |  |= 0| )
   ( ^right-side  -
         ^left-side  -
         ^operation subtract -
         ^type number
         ^value 0)
}
##############Multiply

sp {algebra*apply*multiply
   (state  ^operator.name multiply
              ^current-clause )
   ( ^right-side 
         ^left-side 
         ^operation multiply)
   ( ^type number
         ^value )
   ( ^type number
         ^value )
-->
   (write (crlf) |Multiply |  | * |  )
   ( ^right-side  -
         ^left-side  -
         ^operation multiply -
         ^type number
         ^value (*  ))
}

########## 0

sp {algebra*apply*multiply*variable*multiply*0*right
   (state  ^operator.name multiply
              ^current-clause )
   ( ^right-side 
         ^left-side 
         ^operation multiply)
   ( ^type number
         ^value << 0 0. >>)
   ( ^type variable
         ^value )
-->
   (write (crlf) |Multiply |  |* 0 = 0 |)
   ( ^right-side  -
         ^left-side  -
         ^operation multiply -
         ^type number
         ^value 0)
}

sp {algebra*apply*multiply*variable*multiply*0*left
   (state  ^operator.name multiply
              ^current-clause )
   ( ^right-side 
         ^left-side 
         ^operation << divide multiply >>)
   ( ^type number
         ^value << 0. 0 >>)
   ( ^type variable
         ^value )
-->
   (write (crlf) |Multiply |  |* 0 = 0 |)
   ( ^right-side  -
         ^left-side  -
         ^operation multiply -
         ^type number
         ^value 0)
}

########### 1

sp {algebra*apply*multiply*variable*multiply*1*right
   (state  ^operator.name multiply
              ^current-clause )
   ( ^right-side 
         ^left-side 
         ^operation {  << divide multiply >> })
   ( ^type number
         ^value << 1 1. >>)
   ( ^type variable
         ^value )
-->
   (write (crlf) |Multiply |  | * 1 = | )
   ( ^right-side  -
         ^left-side  -
         ^operation  -
         ^type variable
         ^value )
}

sp {algebra*apply*multiply*variable*multiply*1*right*not-variable
   (state  ^operator.name multiply
              ^current-clause )
   ( ^right-side 
         ^left-side 
         ^operation {  << divide multiply >> })
   ( ^type number
         ^value << 1 1. >>)
   ( ^right-side 
         ^left-side 
         ^operation )
-->
   (write (crlf)  | |  |* 1 =|  | |  | | )
   ( ^right-side  -
                     
         ^left-side  -
                    
         ^operation  -
                    )
}
sp {algebra*apply*multiply*variable*multiply*1*left
   (state  ^operator.name multiply
              ^current-clause )
   ( ^right-side 
         ^left-side 
         ^operation multiply)
   ( ^type number
         ^value << 1. 1 >>)
   ( ^type variable
         ^value )
-->
   (write (crlf) |Multiply |  | * 1 = | )
   ( ^right-side  -
         ^left-side  -
         ^operation multiply -
         ^type variable
         ^value )
}


sp {algebra*apply*multiply*variable*multiply*1*left*not-variable
   (state  ^operator.name multiply
              ^current-clause )
   ( ^right-side 
         ^left-side 
         ^operation multiply)
   ( ^type number
         ^value << 1 1. >>)
   ( ^right-side 
         ^left-side 
         ^operation { <> multiply  })
-->
   (write (crlf)  |Multiply |  |* 1 =|  | |  | | )
   ( ^right-side  -
                     
         ^left-side  -
                    
         ^operation multiply -
                    )
}


sp {algebra*apply*multiply*variable*multiply*1*left*not-variable*multiply
   (state  ^operator.name multiply
              ^current-clause )
   ( ^right-side 
         ^left-side 
         ^operation multiply)
   ( ^type number
         ^value << 1 1. >>)
   ( ^right-side 
         ^left-side 
         ^operation multiply)
-->
   (write (crlf)  |Multiply |  |* 1 =|  | multiply | )
   ( ^right-side  -
                     
         ^left-side  -
                    )
}
######### DIVIDE ################

sp {algebra*apply*divide
   (state  ^operator.name divide
              ^current-clause )
   ( ^right-side 
         ^left-side 
         ^operation divide)
   ( ^type number
         ^value { <> 0  })
   ( ^type number
         ^value )
-->
   (write (crlf) | divide |  | / | )
   ( ^right-side  -
         ^left-side  -
         ^operation divide -
         ^type number
         ^value (/  ))
}

sp {algebra*apply*divide*variable
   (state  ^operator.name divide
              ^current-clause )
   ( ^right-side 
         ^left-side 
         ^operation divide)
   ( ^type variable
         ^value )
   ( ^type variable
         ^value )
-->
   (write (crlf) | divide |  | / |  | = 1|)
   ( ^right-side  -
         ^left-side  -
         ^operation divide -
         ^type number
         ^value 1)
}
sp {algebra*apply*divide*0
   (state  ^operator.name divide
              ^current-clause )
   ( ^right-side.value 0
         ^operation divide)
-->
   (write (crlf) |Error - Divide by 0.|)
   (halt)
}