aboutsummaryrefslogtreecommitdiff
path: root/src/algebra/defintef.spad.pamphlet
diff options
context:
space:
mode:
authordos-reis <gdr@axiomatics.org>2007-08-14 05:14:52 +0000
committerdos-reis <gdr@axiomatics.org>2007-08-14 05:14:52 +0000
commitab8cc85adde879fb963c94d15675783f2cf4b183 (patch)
treec202482327f474583b750b2c45dedfc4e4312b1d /src/algebra/defintef.spad.pamphlet
downloadopen-axiom-ab8cc85adde879fb963c94d15675783f2cf4b183.tar.gz
Initial population.
Diffstat (limited to 'src/algebra/defintef.spad.pamphlet')
-rw-r--r--src/algebra/defintef.spad.pamphlet267
1 files changed, 267 insertions, 0 deletions
diff --git a/src/algebra/defintef.spad.pamphlet b/src/algebra/defintef.spad.pamphlet
new file mode 100644
index 00000000..d76f8a01
--- /dev/null
+++ b/src/algebra/defintef.spad.pamphlet
@@ -0,0 +1,267 @@
+\documentclass{article}
+\usepackage{axiom}
+\begin{document}
+\title{\$SPAD/src/algebra defintef.spad}
+\author{Manuel Bronstein}
+\maketitle
+\begin{abstract}
+\end{abstract}
+\eject
+\tableofcontents
+\eject
+\section{package DEFINTEF ElementaryFunctionDefiniteIntegration}
+<<package DEFINTEF ElementaryFunctionDefiniteIntegration>>=
+)abbrev package DEFINTEF ElementaryFunctionDefiniteIntegration
+++ Definite integration of elementary functions.
+++ Author: Manuel Bronstein
+++ Date Created: 14 April 1992
+++ Date Last Updated: 2 February 1993
+++ Description:
+++ \spadtype{ElementaryFunctionDefiniteIntegration}
+++ provides functions to compute definite
+++ integrals of elementary functions.
+ElementaryFunctionDefiniteIntegration(R, F): Exports == Implementation where
+ R : Join(EuclideanDomain, OrderedSet, CharacteristicZero,
+ RetractableTo Integer, LinearlyExplicitRingOver Integer)
+ F : Join(TranscendentalFunctionCategory, PrimitiveFunctionCategory,
+ AlgebraicallyClosedFunctionSpace R)
+
+ B ==> Boolean
+ SE ==> Symbol
+ Z ==> Integer
+ P ==> SparseMultivariatePolynomial(R, K)
+ K ==> Kernel F
+ UP ==> SparseUnivariatePolynomial F
+ OFE ==> OrderedCompletion F
+ U ==> Union(f1:OFE, f2:List OFE, fail:"failed", pole:"potentialPole")
+
+ Exports ==> with
+ integrate: (F, SegmentBinding OFE) -> U
+ ++ integrate(f, x = a..b) returns the integral of
+ ++ \spad{f(x)dx} from a to b.
+ ++ Error: if f has a pole for x between a and b.
+ integrate: (F, SegmentBinding OFE, String) -> U
+ ++ integrate(f, x = a..b, "noPole") returns the
+ ++ integral of \spad{f(x)dx} from a to b.
+ ++ If it is not possible to check whether f has a pole for x
+ ++ between a and b (because of parameters), then this function
+ ++ will assume that f has no such pole.
+ ++ Error: if f has a pole for x between a and b or
+ ++ if the last argument is not "noPole".
+ innerint: (F, SE, OFE, OFE, B) -> U
+ ++ innerint(f, x, a, b, ignore?) should be local but conditional
+
+ Implementation ==> add
+ import ElementaryFunctionSign(R, F)
+ import DefiniteIntegrationTools(R, F)
+ import FunctionSpaceIntegration(R, F)
+
+ polyIfCan : (P, K) -> Union(UP, "failed")
+ int : (F, SE, OFE, OFE, B) -> U
+ nopole : (F, SE, K, OFE, OFE) -> U
+ checkFor0 : (P, K, OFE, OFE) -> Union(B, "failed")
+ checkSMP : (P, SE, K, OFE, OFE) -> Union(B, "failed")
+ checkForPole: (F, SE, K, OFE, OFE) -> Union(B, "failed")
+ posit : (F, SE, K, OFE, OFE) -> Union(B, "failed")
+ negat : (F, SE, K, OFE, OFE) -> Union(B, "failed")
+ moreThan : (OFE, Fraction Z) -> Union(B, "failed")
+
+ if R has Join(ConvertibleTo Pattern Integer, PatternMatchable Integer)
+ and F has SpecialFunctionCategory then
+ import PatternMatchIntegration(R, F)
+
+ innerint(f, x, a, b, ignor?) ==
+ ((u := int(f, x, a, b, ignor?)) case f1) or (u case f2)
+ or ((v := pmintegrate(f, x, a, b)) case "failed") => u
+ [v::F::OFE]
+
+ else
+ innerint(f, x, a, b, ignor?) == int(f, x, a, b, ignor?)
+
+ integrate(f:F, s:SegmentBinding OFE) ==
+ innerint(f, variable s, lo segment s, hi segment s, false)
+
+ integrate(f:F, s:SegmentBinding OFE, str:String) ==
+ innerint(f, variable s, lo segment s, hi segment s, ignore? str)
+
+ int(f, x, a, b, ignor?) ==
+ a = b => [0::OFE]
+ k := kernel(x)@Kernel(F)
+ (z := checkForPole(f, x, k, a, b)) case "failed" =>
+ ignor? => nopole(f, x, k, a, b)
+ ["potentialPole"]
+ z::B => error "integrate: pole in path of integration"
+ nopole(f, x, k, a, b)
+
+ checkForPole(f, x, k, a, b) ==
+ ((u := checkFor0(d := denom f, k, a, b)) case "failed") or (u::B) => u
+ ((u := checkSMP(d, x, k, a, b)) case "failed") or (u::B) => u
+ checkSMP(numer f, x, k, a, b)
+
+-- true if p has a zero between a and b exclusive
+ checkFor0(p, x, a, b) ==
+ (u := polyIfCan(p, x)) case UP => checkForZero(u::UP, a, b, false)
+ (v := isTimes p) case List(P) =>
+ for t in v::List(P) repeat
+ ((w := checkFor0(t, x, a, b)) case "failed") or (w::B) => return w
+ false
+ (r := retractIfCan(p)@Union(K, "failed")) case "failed" => "failed"
+ k := r::K
+-- functions with no real zeros
+ is?(k, "exp"::SE) or is?(k, "acot"::SE) or is?(k, "cosh"::SE) => false
+-- special case for log
+ is?(k, "log"::SE) =>
+ (w := moreThan(b, 1)) case "failed" or not(w::B) => w
+ moreThan(-a, -1)
+ "failed"
+
+-- returns true if a > b, false if a < b, "failed" if can't decide
+ moreThan(a, b) ==
+ (r := retractIfCan(a)@Union(F, "failed")) case "failed" => -- infinite
+ whatInfinity(a) > 0
+ (u := retractIfCan(r::F)@Union(Fraction Z, "failed")) case "failed" =>
+ "failed"
+ u::Fraction(Z) > b
+
+-- true if p has a pole between a and b
+ checkSMP(p, x, k, a, b) ==
+ (u := polyIfCan(p, k)) case UP => false
+ (v := isTimes p) case List(P) =>
+ for t in v::List(P) repeat
+ ((w := checkSMP(t, x, k, a, b)) case "failed") or (w::B) => return w
+ false
+ (v := isPlus p) case List(P) =>
+ n := 0 -- number of summand having a pole
+ for t in v::List(P) repeat
+ (w := checkSMP(t, x, k, a, b)) case "failed" => return w
+ if w::B then n := n + 1
+ zero? n => false -- no summand has a pole
+-- one? n => true -- only one summand has a pole
+ (n = 1) => true -- only one summand has a pole
+ "failed" -- at least 2 summands have a pole
+ (r := retractIfCan(p)@Union(K, "failed")) case "failed" => "failed"
+ kk := r::K
+ -- nullary operators have no poles
+ nullary? operator kk => false
+ f := first argument kk
+ -- functions which are defined over all the reals:
+ is?(kk, "exp"::SE) or is?(kk, "sin"::SE) or is?(kk, "cos"::SE)
+ or is?(kk, "sinh"::SE) or is?(kk, "cosh"::SE) or is?(kk, "tanh"::SE)
+ or is?(kk, "sech"::SE) or is?(kk, "atan"::SE) or is?(kk, "acot"::SE)
+ or is?(kk, "asinh"::SE) => checkForPole(f, x, k, a, b)
+ -- functions which are defined on (-1,+1):
+ is?(kk, "asin"::SE) or is?(kk, "acos"::SE) or is?(kk, "atanh"::SE) =>
+ ((w := checkForPole(f, x, k, a, b)) case "failed") or (w::B) => w
+ ((w := posit(f - 1, x, k, a, b)) case "failed") or (w::B) => w
+ negat(f + 1, x, k, a, b)
+ -- functions which are defined on (+1, +infty):
+ is?(kk, "acosh"::SE) =>
+ ((w := checkForPole(f, x, k, a, b)) case "failed") or (w::B) => w
+ negat(f - 1, x, k, a, b)
+ -- functions which are defined on (0, +infty):
+ is?(kk, "log"::SE) =>
+ ((w := checkForPole(f, x, k, a, b)) case "failed") or (w::B) => w
+ negat(f, x, k, a, b)
+ "failed"
+
+-- returns true if it is certain that f takes at least one strictly positive
+-- value for x in (a,b), false if it is certain that f takes no strictly
+-- positive value in (a,b), "failed" otherwise
+-- f must be known to have no poles in (a,b)
+ posit(f, x, k, a, b) ==
+ z :=
+ (r := retractIfCan(a)@Union(F, "failed")) case "failed" => sign(f, x, a)
+ sign(f, x, r::F, "right")
+ (b1 := z case Z) and z::Z > 0 => true
+ z :=
+ (r := retractIfCan(b)@Union(F, "failed")) case "failed" => sign(f, x, b)
+ sign(f, x, r::F, "left")
+ (b2 := z case Z) and z::Z > 0 => true
+ b1 and b2 =>
+ ((w := checkFor0(numer f, k, a, b)) case "failed") or (w::B) => "failed"
+ false
+ "failed"
+
+-- returns true if it is certain that f takes at least one strictly negative
+-- value for x in (a,b), false if it is certain that f takes no strictly
+-- negative value in (a,b), "failed" otherwise
+-- f must be known to have no poles in (a,b)
+ negat(f, x, k, a, b) ==
+ z :=
+ (r := retractIfCan(a)@Union(F, "failed")) case "failed" => sign(f, x, a)
+ sign(f, x, r::F, "right")
+ (b1 := z case Z) and z::Z < 0 => true
+ z :=
+ (r := retractIfCan(b)@Union(F, "failed")) case "failed" => sign(f, x, b)
+ sign(f, x, r::F, "left")
+ (b2 := z case Z) and z::Z < 0 => true
+ b1 and b2 =>
+ ((w := checkFor0(numer f, k, a, b)) case "failed") or (w::B) => "failed"
+ false
+ "failed"
+
+-- returns a UP if p is only a poly w.r.t. the kernel x
+ polyIfCan(p, x) ==
+ q := univariate(p, x)
+ ans:UP := 0
+ while q ^= 0 repeat
+ member?(x, tower(c := leadingCoefficient(q)::F)) => return "failed"
+ ans := ans + monomial(c, degree q)
+ q := reductum q
+ ans
+
+-- integrate f for x between a and b assuming that f has no pole in between
+ nopole(f, x, k, a, b) ==
+ (u := integrate(f, x)) case F =>
+ (v := computeInt(k, u::F, a, b, false)) case "failed" => ["failed"]
+ [v::OFE]
+ ans := empty()$List(OFE)
+ for g in u::List(F) repeat
+ (v := computeInt(k, g, a, b, false)) case "failed" => return ["failed"]
+ ans := concat_!(ans, [v::OFE])
+ [ans]
+
+@
+\section{License}
+<<license>>=
+--Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd.
+--All rights reserved.
+--
+--Redistribution and use in source and binary forms, with or without
+--modification, are permitted provided that the following conditions are
+--met:
+--
+-- - Redistributions of source code must retain the above copyright
+-- notice, this list of conditions and the following disclaimer.
+--
+-- - Redistributions in binary form must reproduce the above copyright
+-- notice, this list of conditions and the following disclaimer in
+-- the documentation and/or other materials provided with the
+-- distribution.
+--
+-- - Neither the name of The Numerical ALgorithms Group Ltd. nor the
+-- names of its contributors may be used to endorse or promote products
+-- derived from this software without specific prior written permission.
+--
+--THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+--IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+--TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+--PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
+--OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+--EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+--PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+--PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+--LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+--NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+--SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+@
+<<*>>=
+<<license>>
+
+<<package DEFINTEF ElementaryFunctionDefiniteIntegration>>
+@
+\eject
+\begin{thebibliography}{99}
+\bibitem{1} nothing
+\end{thebibliography}
+\end{document}