;; -*- Mode: Lisp; -*-

;;;; Operators for JSAINT
;; Last edited 1/29/93, by KDF

;;; Copyright (c) 1993, Kenneth D. Forbus, Northwestern University,
;;; and Johan de Kleer, the Xerox Corporation.
;;; All rights reserved.

;;; See the file legal.txt for a paragraph stating scope of permission
;;; and disclaimer of warranty.  The above copyright notice and that
;;; paragraph must be included in any separate copy of this file.

(in-package :cl-user)

(defIntegration Integral-of-constant
  (integral ?t ?var) 
  :test (not (occurs-in? ?var ?t))
  :result (* ?t ?var))

(defIntegration Integral-of-Self
  (integral ?exp ?exp)
  :result (/ (expt ?exp 2) 2))

(defIntegration Move-constant-outside
  (integral (* ?const ?nonconst) ?var)
  :test (and (not (occurs-in? ?var ?const))
	     (occurs-in? ?var ?nonconst))
  :subproblems ((?int (integrate (integral ?nonconst ?var))))
  :result (* ?const ?int))

(defIntegration Integral-of-Sum
  (integral (+ ?t1 ?t2) ?var)
  :subproblems ((?int1 (integrate (integral ?t1 ?var)))
		(?int2 (integrate (integral ?t2 ?var))))
  :result (+ ?int1 ?int2))

(defIntegration Integral-of-Nary-sum
  (integral (+ ?t1 ?t2 . ?trest) ?var)
  :subproblems ((?int1 (integrate (integral ?t1 ?var)))
		(?int2 (integrate (integral ?t2 ?var)))
		(?intr (integrate (integral (+ . ?trest) ?var))))
  :test (not (null ?trest))
  :result (+ ?int1 ?int2 ?intr))

(defIntegration Integral-of-uminus
  (integral (- ?term) ?var)
  :subproblems ((?int (integrate (integral ?term ?var))))
  :result (- ?int))

(defIntegration Integral-of-minus
  (integral (- ?t1 ?t2) ?var)
  :subproblems ((?int1 (integrate (integral ?t1 ?var)))
		(?int2 (integrate (integral ?t2 ?var))))
  :result (- ?int1 ?int2))

(defIntegration Integral-of-SQR
  (integral (sqr ?var) ?var)
  :result (/ (expt ?var 3) 3))

(defIntegration Integral-of-polyterm
  (integral (expt ?var ?n) ?var)
  :test (not (same-constant? ?n -1))
  :result (/ (expt ?var (+ 1 ?n)) (+ 1 ?n)))
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; Some exponentials and trig functions

(defIntegration Simple-e-integral
  (integral (expt %e ?var) ?var)
  :result (expt %e ?var))

(defIntegration e-integral
  (integral (expt %e (* ?a ?var)) ?var)
  :test (not (occurs-in? ?var ?a))
  :result (/ (expt %e (* ?a ?var)) ?a))

(defIntegration non-e-power-integral
  (integral (expt ?b (* ?a ?var)) ?var)
  :test (and (not (occurs-in? ?var ?a))
	     (not (occurs-in? ?var ?b)))
  :result (/ (expt ?b (* ?a ?var)) (* ?a (log ?b %e))))

(defIntegration Log-Integral
  (integral (log ?var %e) ?var)
  :result (- (* ?var (log ?var %e)) ?var))

(defIntegration sin-integral
  (integral (sin (* ?a ?var)) ?var)
  :test (not (occurs-in? ?var ?a))
  :result (- (/ (cos (* ?a ?var)) ?a)))

(defIntegration cos-integral
  (integral (cos (* ?a ?var)) ?var)
  :test (not (occurs-in? ?var ?a))
  :result (/ (sin (* ?a ?var)) ?a))

(defIntegration sin-sqr-integral
  (integral (sqr (sin ?var)) ?var)
  :result (- (/ ?var 2) (/ (sin (* 2 ?var)) 4)))

(defIntegration cos-sqr-integral
  (integral (sqr (cos ?var)) ?var)
  :result (+ (/ ?var 2) (/ (sin (* 2 ?var)) 4)))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; Some not-so-clever operators

(defIntegration SinToCosSqrSub
  (integral ?exp ?var)
  :test (and (occurs-in? ?var ?exp)
	     (occurs-in? `(sin ,?var) ?exp))
  :subproblems
  ((?Int (integrate (integral
		     (:eval (subst `(sqrt (- 1 (expt (cos ,?var) 2)))
				   `(sin ,?var)
				   ?exp :test 'equal)) ?var))))
  :result ?Int)

(defIntegration CosToSinSqrSub
  (integral ?exp ?var)
  :test (and (occurs-in? ?var ?exp)
	     (occurs-in? `(cos ,?var) ?exp))
  :subproblems
  ((?Int (integrate (integral
		     (:eval (subst `(sqrt (- 1 (expt (sin ,?var) 2)))
				   `(cos ,?var)
				   ?exp :test 'equal)) ?var))))
  :result ?Int)

(defIntegration SinSqrToTanCosSub
  (integral ?exp ?var)
  :test (and (occurs-in? ?var ?exp)
	     (occurs-in? `(sin ,?var) ?exp))
  :subproblems ((?int (integrate (integral
				  (:eval (subst `(* (sqr (tan ,?var))
						    (sqr (cos ,?var)))
						`(sin ,?var)
						?exp :test 'equal))
				  ?var))))
  :result ?Int)