added params to integral macro, start on numeric integration

Author: alanb2718

reactive/integral-preprocessor.rkt

@@ -0,0 +1,40 @@
+#lang s-exp rosette
+
+(provide integral-preprocessor symbolic-integral)
+
+; The integral-preprocessor function takes the expression being integrated, e.g. (integral expr)
+; plus additional arguments, representing keyword arguments in the source.
+;   var is the variable of integration - this has a default value of (milliseconds), provided by the caller though
+;   numeric-kw is #t if the keyword #:numeric was provided
+;   symbolic-kw is #t if the keyword #:symbolic was provided
+;   dt is the time step if the keyword #:dt and an argument was provided
+; Only one of #:numeric or #:symbolic can be given -- a Racket macro ninja would check this in the macro, but
+; here this function checks it.  If neither the code first tries to find a symbolic integral, and if that doesn't
+; work, it returns code to compute it numerically.  #:dt can only be provided if #:numeric is specified.  Again,
+; a macro ninja would check this in the macro rather than here.
+; It returns 3 values:
+;   symbolic?  #t if the result is a symbolic integration, #f if numeric
+;   expr       if symbolic is #t, the symbolic integral; and otherwise null
+;   dt         if symbolic is #f, the time step for numeric integration; and otherwise null
+(define (integral-preprocessor expr var numeric-kw symbolic-kw dt)
+  (when (and numeric-kw symbolic-kw) (error "can only specify one of #:numeric and #:symbolic"))
+  (when (and (not numeric-kw) dt) (error "#:dt can only be specified in conjunction with #:numeric"))
+  ; try to compute the symbolic integral and bind it to s, unless #:numeric is specified
+  (let ([s (if numeric-kw #f (symbolic-integral expr var))])
+    (when (and symbolic-kw (not s)) (error "#:symbolic was specified but unable to find symbolic integral"))
+    (if symbolic-integral (values #t s #f) (values #f (null) dt))))
+                                            
+; Function to do symbolic integration at compile time -- super simple to start with.
+; This doesn't do any simplification of the result -- which seems fine, since it is for evaluation
+; rather than human consumption, and the code is going to be really fast with or without simplication.
+; It is small, but putting it in a separate module makes it easier to test independently.
+(define (symbolic-integral expr var)
+  (match expr
+    [v #:when (equal? v var) (list '* 0.5 (list 'expt var 2))]
+    [(? number? n) (list '* n var)]
+    [(list '+ x y) (list '+ (symbolic-integral x var) (symbolic-integral y var))]
+    [(cons '* (list-no-order (? number? n) x)) (list '* n (symbolic-integral x var))]
+    [(list '/ x (? number? n)) (list '/ (symbolic-integral x var) n)]
+    [(list 'expt v (? number? n)) #:when (equal? v var) (list '/ (list 'expt v (+ n 1)) (+ n 1))]
+    [(list 'integral e) (symbolic-integral (symbolic-integral e var) var)]
+    [_ #f]))

reactive/reactive-thing.rkt

@@ -90,21 +90,36 @@
     [(_ fn expr)
      (with-syntax ([id (datum->syntax stx (gensym))])
        #'(send this max-min-helper fn (lambda () (send this wally-evaluate expr)) 'id (interesting-time?)))]))
+
 ; integral macro
 ; The form is (integral expr) with additional optional keyword arguments as follows:
 ;     #:var v  -- variable of integration; default is (milliseconds) -- note that an expression is allowed here
-;     #:numeric or #:symbolic -- which kind of integration to use.  Default is to try symbolic, and if that doesn't work, use numeric
+;     #:numeric or #:symbolic -- which kind of integration to use.  Can provide at most one of these, or omit.
+;         The default is to try symbolic, and if that doesn't work, use numeric.  However, if #:symbolic is listed
+;         explicitly, then either symbolic integration must succeed or the system raises an exception.
 ;     #:dt d -- time step (only allowed with #:numeric)
 ; Example: (integral (sin x) #:var x #:numeric #:dt 0.1)
-(require (for-syntax "symbolic-integration.rkt"))  ; function to do simple symbolic integration
+(require (for-syntax "integral-preprocessor.rkt"))
 (require (for-syntax syntax/parse))
 (define-syntax (integral stx)
   (syntax-parse stx
-    [(integral e:expr (~or (~optional (~seq #:var v:expr)) (~optional #:numeric) (~optional #:symbolic) (~optional (~seq #:dt d:expr))) ...)
-     (with-syntax ([intgl (datum->syntax stx (symbolic-integral (syntax->datum #'e)
-                                                                (if (attribute v) (syntax->datum #'v) '(milliseconds))))]
-                   [id (datum->syntax stx (gensym))])
-       #'(send this integral-helper (lambda () (send this wally-evaluate intgl)) 'id (interesting-time?)))]))
+    [(integral e:expr (~or (~optional (~seq #:var v:expr))
+                           (~optional (~seq (~and #:numeric numeric-kw)))
+                           (~optional (~seq (~and #:symbolic symbolic-kw)))
+                           (~optional (~seq #:dt dt:expr))) ...)
+     (let-values ([(symbolic? symbolic-integral dt)
+                   (integral-preprocessor (syntax->datum #'e)
+                                          (if (attribute v) (syntax->datum #'v) '(milliseconds))
+                                          (attribute numeric-kw)
+                                          (attribute symbolic-kw)
+                                          (if (attribute dt) (syntax->datum #'dt) #f))])
+       (if symbolic? 
+           (with-syntax ([s (datum->syntax stx symbolic-integral)]  ; symbolic version
+                         [id (datum->syntax stx (gensym))])
+             #'(send this integral-symbolic-run-time-fn (lambda () (send this wally-evaluate s)) 'id (interesting-time?)))
+           (with-syntax ([d (datum->syntax stx dt)]
+                         [id (datum->syntax stx (gensym))])  ; numeric version
+             #'(send this integral-numeric-run-time-fn (lambda () (send this wally-evaluate e)) 'id d))))]))
 
 
 (define reactive-thing%
@@ -146,15 +161,19 @@
                                (max-or-min (f) (hash-ref accumulator-values id)))])
         (hash-set! accumulator-values id updated-value)
         updated-value))
-    ; helper for code generated by integral macro
-    (define/public (integral-helper f id interesting)
+    ; runtime function for code generated by integral macro for symbolic integration -- this should evaluate to the
+    ; correct value for (integral expr) at the current time
+    (define/public (integral-symbolic-run-time-fn f id interesting)
       ; If the value for this integral isn't stored already, or if this is the first time through a 'while', save that value.
       ; Hack (hopefully temporary): if time=0, also save the value (i.e., reset the value for this integral).  This is
       ; to get around a bug where the integral expression is being evaluated on startup before all variables have values.
       (cond [(or (not (hash-has-key? accumulator-values id)) (eq? interesting 'first) (equal? (send this milliseconds-evaluated) 0))
              (hash-set! accumulator-values id (f))
              0.0]
             [else (- (f) (hash-ref accumulator-values id))]))
+    ; version for code for numeric integration
+    (define/public (integral-numeric-run-time-fn f id dt)
+      (error "not finished\n"))
 
     (define/override (milliseconds)
       symbolic-time)

reactive/symbolic-integration.rkt

@@ -15,8 +15,9 @@
  "when-tests.rkt"
  "while-tests.rkt"
  "max-min-tests.rkt"
- "symbolic-integration-tests.rkt"
- "integral-tests.rkt"
+ "integral-preprocessor-tests.rkt"
+ "integral-symbolic-tests.rkt"
+ "integral-bad-arg-tests.rkt"
  "integrals-and-events.rkt"
  "viewer-tests.rkt"
  "compiled-reactive-thing-tests.rkt"

tests/all-tests.rkt

@@ -0,0 +1,65 @@
+#lang s-exp rosette
+;; unit tests for bad argument combinations for integral in reactive-thing%
+
+(require rackunit rackunit/text-ui rosette/lib/roseunit)
+(require syntax/macro-testing)
+(require "../core/wallingford.rkt")
+(require "../reactive/reactive.rkt")
+
+(provide integral-bad-arg-tests)
+
+(define (both-symbolic-and-numeric)
+  (test-case
+   "test call to integral with both #:symbolic and #:numeric"
+   (define tester%
+     (class reactive-thing%
+       (inherit milliseconds)
+       (super-new)
+       (define-public-symbolic* x real?)
+       (convert-compile-time-error (always (equal? x (integral 2 #:symbolic #:numeric))))))
+   (check-exn #rx"can only specify one of #:numeric and #:symbolic" (lambda () (new tester%)))))
+
+(define (dt-with-symbolic)
+  (test-case
+   "test call to integral with #:symbolic and #:dt"
+   (define tester%
+     (class reactive-thing%
+       (inherit milliseconds)
+       (super-new)
+       (define-public-symbolic* x real?)
+       (convert-compile-time-error (always (equal? x (integral 2 #:symbolic #:dt 1))))))
+   (check-exn #rx"#:dt can only be specified in conjunction with #:numeric" (lambda () (new tester%)))))
+
+(define (dt-alone)
+  (test-case
+   "test call to integral with #:dt alone (no #:numeric as required)"
+   (define tester%
+     (class reactive-thing%
+       (inherit milliseconds)
+       (super-new)
+       (define-public-symbolic* x real?)
+       (convert-compile-time-error (always (equal? x (integral 2 #:dt 1))))))
+   (check-exn #rx"#:dt can only be specified in conjunction with #:numeric" (lambda () (new tester%)))))
+
+(define (symbolic-but-too-hard)
+  (test-case
+   "test call to integral with #:symbolic and an expression that is too difficult to find the symbolic integral"
+   (define tester%
+     (class reactive-thing%
+       (inherit milliseconds)
+       (super-new)
+       (define-public-symbolic* x real?)
+       (convert-compile-time-error (always (equal? 0 (integral (sin x) #:symbolic))))))
+   (check-exn #rx"#:symbolic was specified but unable to find symbolic integral" (lambda () (new tester%)))))
+
+
+(define integral-bad-arg-tests 
+  (test-suite+
+   "run tests for integral with bad arguments"
+   (both-symbolic-and-numeric)
+   (dt-with-symbolic)
+   (dt-alone)
+   (symbolic-but-too-hard)
+   ))
+
+(time (run-tests integral-bad-arg-tests))

tests/integral-bad-arg-tests.rkt

@@ -1,10 +1,10 @@
 #lang s-exp rosette
-;; unit tests for symbolic-integration helper function
+;; unit tests for integration preprocessor
 
 (require rackunit rackunit/text-ui rosette/lib/roseunit)
-(require "../reactive/symbolic-integration.rkt")
+(require "../reactive/integral-preprocessor.rkt")
 
-(provide symbolic-integration-tests)
+(provide integral-preprocessor-tests)
 
 ; The only tests with various different expressions to integrate are integral-in-always and integral-with-explict-variable-of-integration.
 ; The other tests just use a constant (because arguably the other functionality being tested is independent of the symbolic integration function).
@@ -39,13 +39,13 @@
 
 (define (too-difficult-expression-test)
   (test-case
-   "expressions that are too difficult"
-   (check-exn exn:fail? (lambda () (symbolic-integral '(sin x) 'x)))
-   (check-exn exn:fail? (lambda () (symbolic-integral '(* x x) 'x)))  ; needs to use expt
-   (check-exn exn:fail? (lambda () (symbolic-integral '(/ 2 x) 'x)))
+   "expressions that are too difficult for the symbolic integrator - these should return #f"
+   (check-false (symbolic-integral '(sin x) 'x))
+   (check-false (symbolic-integral '(* x x) 'x))  ; needs to use expt
+   (check-false (symbolic-integral '(/ 2 x) 'x))
    ))
 
-(define symbolic-integration-tests 
+(define integral-preprocessor-tests 
   (test-suite+
    "run tests for symbolic integration function"
    (atomic-expression-tests)
@@ -54,4 +54,4 @@
    (too-difficult-expression-test)
    ))
 
-(time (run-tests symbolic-integration-tests))
+(time (run-tests integral-preprocessor-tests))

tests/symbolic-integration-tests.rkt tests/integral-preprocessor-tests.rkt

@@ -1,12 +1,12 @@
 #lang s-exp rosette
-;; unit tests for integral in reactive-thing%
+;; unit tests for integral in reactive-thing% using the symbolic option, either explicitly or implicitly
 
 (require rackunit rackunit/text-ui rosette/lib/roseunit)
 (require "../core/wallingford.rkt")
 (require "../applications/geothings.rkt")
 (require "../reactive/reactive.rkt")
 
-(provide integral-tests)
+(provide integral-symbolic-tests)
 
 ; The only tests with various different expressions to integrate are integral-in-always and integral-with-explict-variable-of-integration.
 ; The other tests just use a constant (because arguably the other functionality being tested is independent of the symbolic integration function).
@@ -24,7 +24,7 @@
        (inherit milliseconds)
        (super-new)
        (define-public-symbolic* x y real?)
-       (always (equal? x (integral 2)))
+       (always (equal? x (integral 2 #:symbolic)))  ; do one that explicitly insists that this be symbolic
        (always (equal? y (integral (milliseconds))))))
    (define r (new tester%))
    (send r start)
@@ -122,7 +122,7 @@
 
 (define (integral-with-explict-variable-of-integration)
   (test-case
-   "test call to integral in an always"
+   "test call to integral with an explicit variable of integration"
    (define tester%
      (class reactive-thing%
        (inherit milliseconds seconds)
@@ -149,14 +149,14 @@
    (check equal? (send r get-z2) 20000)))
 
 
-(define integral-tests 
+(define integral-symbolic-tests 
   (test-suite+
-   "run tests for integral in reactive-thing"
+   "run tests for integral in reactive-thing% using the symbolic option, either explicitly or implicitly"
    (integral-in-always)
    (integral-in-simple-while-hit-start)
    (integral-in-simple-while-miss-start)
    (integral-in-repeating-while)
    (integral-with-explict-variable-of-integration)
    ))
 
-(time (run-tests integral-tests))
+(time (run-tests integral-symbolic-tests))