From ab8cc85adde879fb963c94d15675783f2cf4b183 Mon Sep 17 00:00:00 2001 From: dos-reis Date: Tue, 14 Aug 2007 05:14:52 +0000 Subject: Initial population. --- src/algebra/numeric.spad.pamphlet | 520 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 520 insertions(+) create mode 100644 src/algebra/numeric.spad.pamphlet (limited to 'src/algebra/numeric.spad.pamphlet') diff --git a/src/algebra/numeric.spad.pamphlet b/src/algebra/numeric.spad.pamphlet new file mode 100644 index 00000000..cb575e80 --- /dev/null +++ b/src/algebra/numeric.spad.pamphlet @@ -0,0 +1,520 @@ +\documentclass{article} +\usepackage{axiom} +\begin{document} +\title{\$SPAD/src/algebra numeric.spad} +\author{Manuel Bronstein, Mike Dewar} +\maketitle +\begin{abstract} +\end{abstract} +\eject +\tableofcontents +\eject +\section{package NUMERIC Numeric} +<>= +)abbrev package NUMERIC Numeric +++ Author: Manuel Bronstein +++ Date Created: 21 Feb 1990 +++ Date Last Updated: 17 August 1995, Mike Dewar +++ 24 January 1997, Miked Dewar (added partial operators) +++ Basic Operations: numeric, complexNumeric, numericIfCan, complexNumericIfCan +++ Related Constructors: +++ Also See: +++ AMS Classifications: +++ Keywords: +++ References: +++ Description: Numeric provides real and complex numerical evaluation +++ functions for various symbolic types. + +Numeric(S:ConvertibleTo Float): with + numeric: S -> Float + ++ numeric(x) returns a real approximation of x. + numeric: (S, PositiveInteger) -> Float + ++ numeric(x, n) returns a real approximation of x up to n decimal + ++ places. + complexNumeric: S -> Complex Float + ++ complexNumeric(x) returns a complex approximation of x. + complexNumeric: (S, PositiveInteger) -> Complex Float + ++ complexNumeric(x, n) returns a complex approximation of x up + ++ to n decimal places. + if S has CommutativeRing then + complexNumeric: Complex S -> Complex Float + ++ complexNumeric(x) returns a complex approximation of x. + complexNumeric: (Complex S, PositiveInteger) -> Complex Float + ++ complexNumeric(x, n) returns a complex approximation of x up + ++ to n decimal places. + complexNumeric: Polynomial Complex S -> Complex Float + ++ complexNumeric(x) returns a complex approximation of x. + complexNumeric: (Polynomial Complex S, PositiveInteger) -> Complex Float + ++ complexNumeric(x, n) returns a complex approximation of x up + ++ to n decimal places. + if S has Ring then + numeric: Polynomial S -> Float + ++ numeric(x) returns a real approximation of x. + numeric: (Polynomial S, PositiveInteger) -> Float + ++ numeric(x,n) returns a real approximation of x up to n decimal + ++ places. + complexNumeric: Polynomial S -> Complex Float + ++ complexNumeric(x) returns a complex approximation of x. + complexNumeric: (Polynomial S, PositiveInteger) -> Complex Float + ++ complexNumeric(x, n) returns a complex approximation of x + ++ up to n decimal places. + if S has IntegralDomain then + numeric: Fraction Polynomial S -> Float + ++ numeric(x) returns a real approximation of x. + numeric: (Fraction Polynomial S, PositiveInteger) -> Float + ++ numeric(x,n) returns a real approximation of x up to n decimal + ++ places. + complexNumeric: Fraction Polynomial S -> Complex Float + ++ complexNumeric(x) returns a complex approximation of x. + complexNumeric: (Fraction Polynomial S, PositiveInteger) -> Complex Float + ++ complexNumeric(x, n) returns a complex approximation of x + complexNumeric: Fraction Polynomial Complex S -> Complex Float + ++ complexNumeric(x) returns a complex approximation of x. + complexNumeric: (Fraction Polynomial Complex S, PositiveInteger) -> + Complex Float + ++ complexNumeric(x, n) returns a complex approximation of x + ++ up to n decimal places. + if S has OrderedSet then + numeric: Expression S -> Float + ++ numeric(x) returns a real approximation of x. + numeric: (Expression S, PositiveInteger) -> Float + ++ numeric(x, n) returns a real approximation of x up to n + ++ decimal places. + complexNumeric: Expression S -> Complex Float + ++ complexNumeric(x) returns a complex approximation of x. + complexNumeric: (Expression S, PositiveInteger) -> Complex Float + ++ complexNumeric(x, n) returns a complex approximation of x + ++ up to n decimal places. + complexNumeric: Expression Complex S -> Complex Float + ++ complexNumeric(x) returns a complex approximation of x. + complexNumeric: (Expression Complex S, PositiveInteger) -> Complex Float + ++ complexNumeric(x, n) returns a complex approximation of x + ++ up to n decimal places. + if S has CommutativeRing then + complexNumericIfCan: Polynomial Complex S -> Union(Complex Float,"failed") + ++ complexNumericIfCan(x) returns a complex approximation of x, + ++ or "failed" if \axiom{x} is not constant. + complexNumericIfCan: (Polynomial Complex S, PositiveInteger) -> Union(Complex Float,"failed") + ++ complexNumericIfCan(x, n) returns a complex approximation of x up + ++ to n decimal places, or "failed" if \axiom{x} is not a constant. + if S has Ring then + numericIfCan: Polynomial S -> Union(Float,"failed") + ++ numericIfCan(x) returns a real approximation of x, + ++ or "failed" if \axiom{x} is not a constant. + numericIfCan: (Polynomial S, PositiveInteger) -> Union(Float,"failed") + ++ numericIfCan(x,n) returns a real approximation of x up to n decimal + ++ places, or "failed" if \axiom{x} is not a constant. + complexNumericIfCan: Polynomial S -> Union(Complex Float,"failed") + ++ complexNumericIfCan(x) returns a complex approximation of x, + ++ or "failed" if \axiom{x} is not a constant. + complexNumericIfCan: (Polynomial S, PositiveInteger) -> Union(Complex Float,"failed") + ++ complexNumericIfCan(x, n) returns a complex approximation of x + ++ up to n decimal places, or "failed" if \axiom{x} is not a constant. + if S has IntegralDomain then + numericIfCan: Fraction Polynomial S -> Union(Float,"failed") + ++ numericIfCan(x) returns a real approximation of x, + ++ or "failed" if \axiom{x} is not a constant. + numericIfCan: (Fraction Polynomial S, PositiveInteger) -> Union(Float,"failed") + ++ numericIfCan(x,n) returns a real approximation of x up to n decimal + ++ places, or "failed" if \axiom{x} is not a constant. + complexNumericIfCan: Fraction Polynomial S -> Union(Complex Float,"failed") + ++ complexNumericIfCan(x) returns a complex approximation of x, + ++ or "failed" if \axiom{x} is not a constant. + complexNumericIfCan: (Fraction Polynomial S, PositiveInteger) -> Union(Complex Float,"failed") + ++ complexNumericIfCan(x, n) returns a complex approximation of x, + ++ or "failed" if \axiom{x} is not a constant. + complexNumericIfCan: Fraction Polynomial Complex S -> Union(Complex Float,"failed") + ++ complexNumericIfCan(x) returns a complex approximation of x, + ++ or "failed" if \axiom{x} is not a constant. + complexNumericIfCan: (Fraction Polynomial Complex S, PositiveInteger) -> + Union(Complex Float,"failed") + ++ complexNumericIfCan(x, n) returns a complex approximation of x + ++ up to n decimal places, or "failed" if \axiom{x} is not a constant. + if S has OrderedSet then + numericIfCan: Expression S -> Union(Float,"failed") + ++ numericIfCan(x) returns a real approximation of x, + ++ or "failed" if \axiom{x} is not a constant. + numericIfCan: (Expression S, PositiveInteger) -> Union(Float,"failed") + ++ numericIfCan(x, n) returns a real approximation of x up to n + ++ decimal places, or "failed" if \axiom{x} is not a constant. + complexNumericIfCan: Expression S -> Union(Complex Float,"failed") + ++ complexNumericIfCan(x) returns a complex approximation of x, + ++ or "failed" if \axiom{x} is not a constant. + complexNumericIfCan: (Expression S, PositiveInteger) -> + Union(Complex Float,"failed") + ++ complexNumericIfCan(x, n) returns a complex approximation of x + ++ up to n decimal places, or "failed" if \axiom{x} is not a constant. + complexNumericIfCan: Expression Complex S -> Union(Complex Float,"failed") + ++ complexNumericIfCan(x) returns a complex approximation of x, + ++ or "failed" if \axiom{x} is not a constant. + complexNumericIfCan: (Expression Complex S, PositiveInteger) -> + Union(Complex Float,"failed") + ++ complexNumericIfCan(x, n) returns a complex approximation of x + ++ up to n decimal places, or "failed" if \axiom{x} is not a constant. + == add + + if S has CommutativeRing then + complexNumericIfCan(p:Polynomial Complex S) == + p' : Union(Complex(S),"failed") := retractIfCan p + p' case "failed" => "failed" + complexNumeric(p') + + complexNumericIfCan(p:Polynomial Complex S,n:PositiveInteger) == + p' : Union(Complex(S),"failed") := retractIfCan p + p' case "failed" => "failed" + complexNumeric(p',n) + + if S has Ring then + numericIfCan(p:Polynomial S) == + p' : Union(S,"failed") := retractIfCan p + p' case "failed" => "failed" + numeric(p') + + complexNumericIfCan(p:Polynomial S) == + p' : Union(S,"failed") := retractIfCan p + p' case "failed" => "failed" + complexNumeric(p') + + complexNumericIfCan(p:Polynomial S, n:PositiveInteger) == + p' : Union(S,"failed") := retractIfCan p + p' case "failed" => "failed" + complexNumeric(p', n) + + numericIfCan(p:Polynomial S, n:PositiveInteger) == + old := digits(n)$Float + ans := numericIfCan p + digits(old)$Float + ans + + if S has IntegralDomain then + numericIfCan(f:Fraction Polynomial S)== + num := numericIfCan(numer(f)) + num case "failed" => "failed" + den := numericIfCan(denom f) + den case "failed" => "failed" + num/den + + complexNumericIfCan(f:Fraction Polynomial S) == + num := complexNumericIfCan(numer f) + num case "failed" => "failed" + den := complexNumericIfCan(denom f) + den case "failed" => "failed" + num/den + + complexNumericIfCan(f:Fraction Polynomial S, n:PositiveInteger) == + num := complexNumericIfCan(numer f, n) + num case "failed" => "failed" + den := complexNumericIfCan(denom f, n) + den case "failed" => "failed" + num/den + + numericIfCan(f:Fraction Polynomial S, n:PositiveInteger) == + old := digits(n)$Float + ans := numericIfCan f + digits(old)$Float + ans + + complexNumericIfCan(f:Fraction Polynomial Complex S) == + num := complexNumericIfCan(numer f) + num case "failed" => "failed" + den := complexNumericIfCan(denom f) + den case "failed" => "failed" + num/den + + complexNumericIfCan(f:Fraction Polynomial Complex S, n:PositiveInteger) == + num := complexNumericIfCan(numer f, n) + num case "failed" => "failed" + den := complexNumericIfCan(denom f, n) + den case "failed" => "failed" + num/den + + if S has OrderedSet then + numericIfCan(x:Expression S) == + retractIfCan(map(convert, x)$ExpressionFunctions2(S, Float)) + + --s2cs(u:S):Complex(S) == complex(u,0) + + complexNumericIfCan(x:Expression S) == + complexNumericIfCan map(coerce, x)$ExpressionFunctions2(S,Complex S) + + numericIfCan(x:Expression S, n:PositiveInteger) == + old := digits(n)$Float + x' : Expression Float := map(convert, x)$ExpressionFunctions2(S, Float) + ans : Union(Float,"failed") := retractIfCan x' + digits(old)$Float + ans + + complexNumericIfCan(x:Expression S, n:PositiveInteger) == + old := digits(n)$Float + x' : Expression Complex S := map(coerce, x)$ExpressionFunctions2(S, Complex S) + ans : Union(Complex Float,"failed") := complexNumericIfCan(x') + digits(old)$Float + ans + + if S has RealConstant then + complexNumericIfCan(x:Expression Complex S) == + retractIfCan(map(convert, x)$ExpressionFunctions2(Complex S,Complex Float)) + + complexNumericIfCan(x:Expression Complex S, n:PositiveInteger) == + old := digits(n)$Float + x' : Expression Complex Float := + map(convert, x)$ExpressionFunctions2(Complex S,Complex Float) + ans : Union(Complex Float,"failed") := retractIfCan x' + digits(old)$Float + ans + else + convert(x:Complex S):Complex(Float)==map(convert,x)$ComplexFunctions2(S,Float) + + complexNumericIfCan(x:Expression Complex S) == + retractIfCan(map(convert, x)$ExpressionFunctions2(Complex S,Complex Float)) + + complexNumericIfCan(x:Expression Complex S, n:PositiveInteger) == + old := digits(n)$Float + x' : Expression Complex Float := + map(convert, x)$ExpressionFunctions2(Complex S,Complex Float) + ans : Union(Complex Float,"failed") := retractIfCan x' + digits(old)$Float + ans + numeric(s:S) == convert(s)@Float + + if S has ConvertibleTo Complex Float then + complexNumeric(s:S) == convert(s)@Complex(Float) + + complexNumeric(s:S, n:PositiveInteger) == + old := digits(n)$Float + ans := complexNumeric s + digits(old)$Float + ans + + else + complexNumeric(s:S) == convert(s)@Float :: Complex(Float) + + complexNumeric(s:S,n:PositiveInteger) == + numeric(s, n)::Complex(Float) + + if S has CommutativeRing then + complexNumeric(p:Polynomial Complex S) == + p' : Union(Complex(S),"failed") := retractIfCan p + p' case "failed" => + error "Cannot compute the numerical value of a non-constant polynomial" + complexNumeric(p') + + complexNumeric(p:Polynomial Complex S,n:PositiveInteger) == + p' : Union(Complex(S),"failed") := retractIfCan p + p' case "failed" => + error "Cannot compute the numerical value of a non-constant polynomial" + complexNumeric(p',n) + + if S has RealConstant then + complexNumeric(s:Complex S) == convert(s)$Complex(S) + + complexNumeric(s:Complex S, n:PositiveInteger) == + old := digits(n)$Float + ans := complexNumeric s + digits(old)$Float + ans + + else if Complex(S) has ConvertibleTo(Complex Float) then + complexNumeric(s:Complex S) == convert(s)@Complex(Float) + + complexNumeric(s:Complex S, n:PositiveInteger) == + old := digits(n)$Float + ans := complexNumeric s + digits(old)$Float + ans + + else + complexNumeric(s:Complex S) == + s' : Union(S,"failed") := retractIfCan s + s' case "failed" => + error "Cannot compute the numerical value of a non-constant object" + complexNumeric(s') + + complexNumeric(s:Complex S, n:PositiveInteger) == + s' : Union(S,"failed") := retractIfCan s + s' case "failed" => + error "Cannot compute the numerical value of a non-constant object" + old := digits(n)$Float + ans := complexNumeric s' + digits(old)$Float + ans + + numeric(s:S, n:PositiveInteger) == + old := digits(n)$Float + ans := numeric s + digits(old)$Float + ans + + if S has Ring then + numeric(p:Polynomial S) == + p' : Union(S,"failed") := retractIfCan p + p' case "failed" => error + "Can only compute the numerical value of a constant, real-valued polynomial" + numeric(p') + + complexNumeric(p:Polynomial S) == + p' : Union(S,"failed") := retractIfCan p + p' case "failed" => + error "Cannot compute the numerical value of a non-constant polynomial" + complexNumeric(p') + + complexNumeric(p:Polynomial S, n:PositiveInteger) == + p' : Union(S,"failed") := retractIfCan p + p' case "failed" => + error "Cannot compute the numerical value of a non-constant polynomial" + complexNumeric(p', n) + + numeric(p:Polynomial S, n:PositiveInteger) == + old := digits(n)$Float + ans := numeric p + digits(old)$Float + ans + + if S has IntegralDomain then + numeric(f:Fraction Polynomial S)== + numeric(numer(f)) / numeric(denom f) + + complexNumeric(f:Fraction Polynomial S) == + complexNumeric(numer f)/complexNumeric(denom f) + + complexNumeric(f:Fraction Polynomial S, n:PositiveInteger) == + complexNumeric(numer f, n)/complexNumeric(denom f, n) + + numeric(f:Fraction Polynomial S, n:PositiveInteger) == + old := digits(n)$Float + ans := numeric f + digits(old)$Float + ans + + complexNumeric(f:Fraction Polynomial Complex S) == + complexNumeric(numer f)/complexNumeric(denom f) + + complexNumeric(f:Fraction Polynomial Complex S, n:PositiveInteger) == + complexNumeric(numer f, n)/complexNumeric(denom f, n) + + if S has OrderedSet then + numeric(x:Expression S) == + x' : Union(Float,"failed") := + retractIfCan(map(convert, x)$ExpressionFunctions2(S, Float)) + x' case "failed" => error + "Can only compute the numerical value of a constant, real-valued Expression" + x' + + complexNumeric(x:Expression S) == + x' : Union(Complex Float,"failed") := retractIfCan( + map(complexNumeric, x)$ExpressionFunctions2(S,Complex Float)) + x' case "failed" => + error "Cannot compute the numerical value of a non-constant expression" + x' + + numeric(x:Expression S, n:PositiveInteger) == + old := digits(n)$Float + x' : Expression Float := map(convert, x)$ExpressionFunctions2(S, Float) + ans : Union(Float,"failed") := retractIfCan x' + digits(old)$Float + ans case "failed" => error + "Can only compute the numerical value of a constant, real-valued Expression" + ans + + complexNumeric(x:Expression S, n:PositiveInteger) == + old := digits(n)$Float + x' : Expression Complex Float := + map(complexNumeric, x)$ExpressionFunctions2(S,Complex Float) + ans : Union(Complex Float,"failed") := retractIfCan x' + digits(old)$Float + ans case "failed" => + error "Cannot compute the numerical value of a non-constant expression" + ans + + complexNumeric(x:Expression Complex S) == + x' : Union(Complex Float,"failed") := retractIfCan( + map(complexNumeric, x)$ExpressionFunctions2(Complex S,Complex Float)) + x' case "failed" => + error "Cannot compute the numerical value of a non-constant expression" + x' + + complexNumeric(x:Expression Complex S, n:PositiveInteger) == + old := digits(n)$Float + x' : Expression Complex Float := + map(complexNumeric, x)$ExpressionFunctions2(Complex S,Complex Float) + ans : Union(Complex Float,"failed") := retractIfCan x' + digits(old)$Float + ans case "failed" => + error "Cannot compute the numerical value of a non-constant expression" + ans + +@ +\section{package DRAWHACK DrawNumericHack} +<>= +)abbrev package DRAWHACK DrawNumericHack +++ Author: Manuel Bronstein +++ Date Created: 21 Feb 1990 +++ Date Last Updated: 21 Feb 1990 +++ Basic Operations: coerce +++ Related Constructors: +++ Also See: +++ AMS Classifications: +++ Keywords: +++ References: +++ Description: Hack for the draw interface. DrawNumericHack provides +++ a "coercion" from something of the form \spad{x = a..b} where \spad{a} +++ and b are +++ formal expressions to a binding of the form \spad{x = c..d} where c and d +++ are the numerical values of \spad{a} and b. This "coercion" fails if +++ \spad{a} and b contains symbolic variables, but is meant for expressions +++ involving %pi. +++ NOTE: This is meant for internal use only. + +DrawNumericHack(R:Join(OrderedSet,IntegralDomain,ConvertibleTo Float)): + with coerce: SegmentBinding Expression R -> SegmentBinding Float + ++ coerce(x = a..b) returns \spad{x = c..d} where c and d are the + ++ numerical values of \spad{a} and b. + == add + coerce s == + map(numeric$Numeric(R),s)$SegmentBindingFunctions2(Expression R, Float) + +@ +\section{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. +@ +<<*>>= +<> + +<> +<> +@ +\eject +\begin{thebibliography}{99} +\bibitem{1} nothing +\end{thebibliography} +\end{document} -- cgit v1.2.3