lyonlh / plop Goto Github PK

Currently the predicates commutativep, associativep, etc. are hard-coded to
recognize only built-in operations (and, or, etc.)

They should be extended to handle composition, user-defined functions, and
eventually uncertainty as well (they will need to take a context argument)

Do large-scale testing of Boolean and mixed simplification against the C++
implementation, complete the Boolean reduction rule implementation

Hi,
The first DEFPACKAGE form fails on compilation; it might make sense to use
:DEPENDS-ON in the DEFSYSTEM form instead:

$ svn diff 
Index: src/plop.asd
===================================================================
--- src/plop.asd    (revision 24)
+++ src/plop.asd    (working copy)
@@ -15,11 +15,15 @@
 Author: [email protected] (Moshe Looks) |#

 (in-package :cl-user)
-(defpackage :plop-asd (:use :cl :cl-utilities :anaphora))
+(defpackage :plop-asd (:use :cl))
 (setf *print-circle* t) ; markup may contain circular references to parents

+(assert (find-package :lisp-unit) nil
+        "Package LISP-UNIT not found. Try (load
\"plop-dir/thirdparty/lisp-unit.lisp\").")
+
 (in-package :plop-asd)
 (asdf:defsystem "plop"
+  :depends-on (:cl-utilities :anaphora)
   :serial t
   :components ((:file "packages")
                (:file "util")

see maxima mailing list thread:
http://www.math.utexas.edu/pipermail/maxima/2008/013097.html

In order to do scalable evolution of numerical functions we need a
heuristic procedure for determining if a particular subexpression is
nonzero over a particular range of inputs (e.g. for an expressions of n
variables, and n-dimensional cube). There are a bunch of ways to do this,
interval arithmetic being the simplest, affine arithmetic being better
(http://en.wikipedia.org/wiki/Affine_arithmetic), etc. Maxima also has a
built-in function for this. How good is it? What method does it use? I
don't know...

Add some routines for randomly sampling trees (based e.g. on an extension
of the [http://metacog.org/papers/gecco07b.pdf GECCO diversity paper])

The current routine used for maxima simplification is maxima::simplify. It
would be nice at some point to try other routines and their combinations,
e.g. maxima::factor and maxima::ratsimp and maxima::trigsimp