Edit detail for SandBox Integration revision 3 of 19

Integration

Let's do some integration examples:

(1) -> integrate(%e**x, x)

   There are no library operations named ** 
      Use HyperDoc Browse or issue
                                 )what op **
      to learn if there is any operation containing " ** " in its name.

   Cannot find a definition or applicable library operation named ** 
      with argument type(s) 
                             Expression(Integer)
                                 Variable(x)

      Perhaps you should use "@" to indicate the required return type, 
      or "$" to specify which version of the function you need.

load_package SPECFN;

on ROUNDED,ADJPREC;

Ei(1.00000000000000000001);
*** precision increased to 21

Ei(1.0);

Ei(2.0);

Can Reduce compute Ei in arbitrary precision?

See http://www.uni-koeln.de/REDUCE/3.6/doc/specfn/

Also http://homepages.inf.ed.ac.uk/mtoussai/publications/toussaint-99-mexico.pdf

Reset

off ROUNDED,ADJPREC;

int(cos(x),x,0,pi);

integrate(x^2/sqrt(4-x^2),x)

(1)

integrate(exp(-a*x**2),x=0..%plusInfinity)

   There are no library operations named ** 
      Use HyperDoc Browse or issue
                                 )what op **
      to learn if there is any operation containing " ** " in its name.

   Cannot find a definition or applicable library operation named ** 
      with argument type(s) 
                                 Variable(x)
                               PositiveInteger

      Perhaps you should use "@" to indicate the required return type, 
      or "$" to specify which version of the function you need.

The following won't "work", see CommonMistakes?:

integrate(exp(-a::PositiveInteger*x**2),x=0..%plusInfinity)

   Cannot convert the value from type Variable(a) to PositiveInteger .

integrate((x^3+x^2+2)/(x*(x^2-1)^2), x)

(2)

integrate(2*x/sin(x)^2,x)

(3)

Comparing Axiom and Reduce:

integrate(sin(1/x),x)

(4)

int(sin(1/x),x);

Hell, why does the following blow MathAction??:

  \begin{reduce}
  load_package algint;
  int(sin(1/x),x);
  \end{reduce}

A different problem, where Axiom has to give up:

integrate(sqrt(sin(1/x)),x)

   >> Error detected within library code:
   integrate: implementation incomplete (has polynomial part)

However, in Reduce: Again, why does the following blow MathAction??:

  \begin{reduce}
  load_package algint;
  int(sqrt(sin(1/x)),x);
  \end{reduce}

integrate(exp(-x^2),x)

(5)

integrate(sin(x)/x,x)

(6)

differentiate(%,x)

(7)

integrate(sin(1/x),x=%minusInfinity..%plusInfinity,"noPole")

   >> Error detected within library code:
   integrate: pole in path of integration

integrate(2*x/sin(x)^2,x=1/2..1);

integrate(sin(x),x=0..%pi/2)

(8)

integrate(atan(x/a)/x,x)

(9)

integrate(1/(a+z^3), z=0..1,"noPole")

(10)

integrate(x^3+x^2/4+x,x)

(11)

You cannot integrate Expression Float

integrate(50*%e^(-0.02*t),t)

   There are 9 exposed and 11 unexposed library operations named 
      integrate having 2 argument(s) but none was determined to be 
      applicable. Use HyperDoc Browse, or issue
                            )display op integrate
      to learn more about the available operations. Perhaps 
      package-calling the operation or using coercions on the arguments
      will allow you to apply the operation.

   Cannot find a definition or applicable library operation named 
      integrate with argument type(s) 
                              Expression(Float)
                                 Variable(t)

      Perhaps you should use "@" to indicate the required return type, 
      or "$" to specify which version of the function you need.

But symbolic integration works with integer expressions

integrate(50*%e^(-0.02*t)::Expression Fraction Integer,t)

(12)

integrate(exp(cos(x)),x)

(13)

integrate(sin(x),x)
  integrate(%,x)

   There are 29 exposed and 5 unexposed library operations named elt 
      having 2 argument(s) but none was determined to be applicable. 
      Use HyperDoc Browse, or issue
                               )display op elt
      to learn more about the available operations. Perhaps 
      package-calling the operation or using coercions on the arguments
      will allow you to apply the operation.

   Cannot find a definition or applicable library operation named elt 
      with argument type(s) 
                             Expression(Integer)
                             Expression(Integer)

      Perhaps you should use "@" to indicate the required return type, 
      or "$" to specify which version of the function you need.

integrate(a/h - c*h/12 + (b/h)*r + (c/h)*r^2,r)

(14)

integrate(exp(-(a+b*t)^2/2),t)

(15)

integrate(exp(-(a+b*t)^2/t),t)

(16)

integrate(exp(-1/t),t)

(17)

integrate(exp(-1/t),t=1..x)

(18)

Unfortunately, there is currently no easy way to make "assumptions" about variables. Thus, The following won't work:

  \begin{axiom}
   assume(x, real)
   integrate(exp(-1/t),t=1..x)
   \end{axiom}

integrate(t*exp(-(a+b*t)^2/2),t)

(19)

integrate(1/(a+z^3), z=0..1,"noPole")

(20)

From the ReduceProblem? (what does axiom do?):

int(1/sqrt(2*PI)*exp(-1/2*log(x)**2),x,0,INFINITY);

   There are 31 exposed and 44 unexposed library operations named * 
      having 2 argument(s) but none was determined to be applicable. 
      Use HyperDoc Browse, or issue
                                )display op *
      to learn more about the available operations. Perhaps 
      package-calling the operation or using coercions on the arguments
      will allow you to apply the operation.

   Cannot find a definition or applicable library operation named * 
      with argument type(s) 
                               PositiveInteger
                                    Type

      Perhaps you should use "@" to indicate the required return type, 
      or "$" to specify which version of the function you need.

integrate(1/sqrt(2*%pi)*exp(-1/2*log(x)**2),x=0..k)

   There are no library operations named ** 
      Use HyperDoc Browse or issue
                                 )what op **
      to learn if there is any operation containing " ** " in its name.

   Cannot find a definition or applicable library operation named ** 
      with argument type(s) 
                             Expression(Integer)
                               PositiveInteger

      Perhaps you should use "@" to indicate the required return type, 
      or "$" to specify which version of the function you need.

If you would get a result, you could use limit afterwards, of course.

Mathematical Paradox?

Thu, 10 Feb 2005 17:45:57 -0600 reply