Changeset 7819:256fb33dd86c

Timestamp:

12/20/07 17:35:04 (5 years ago)

Author:

Robert Miller <rlmillster@…>

Branch:

default

Parents:

7817:e526ad576440 (diff), 7818:b2d99e388e5c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

local merge

Files:

• sage/calculus/calculus.py (modified) (3 diffs)
• sage/calculus/calculus.py (modified) (4 diffs)

sage/calculus/calculus.py

@@ -5537 +5537 @@
 class Function_atanh(PrimitiveFunction):
     """
-    The inverse of the hyperbolic tane function.
+    The inverse of the hyperbolic tangent function.
 
     EXAMPLES:
@@ -5559 +5559 @@
 _syms['atanh'] = atanh
 
+class Function_acoth(PrimitiveFunction):
+    """
+    The inverse of the hyperbolic cotangent function.
+
+    EXAMPLES:
+        sage: acoth(2.)
+        0.549306144334055
+        sage: acoth(2)
+        acoth(2)
+        sage: acoth(1 + I*1.0)
+        0.402359478108525 - 0.553574358897045*I
+    """
+    def _repr_(self, simplify=True):
+        return "acoth"
+
+    def _latex_(self):
+        return "\\coth^{-1}"
+
+    def _approx_(self, x):
+        return float(pari(float(1/x)).atanh())
+
+acoth = Function_acoth()
+_syms['acoth'] = acoth
+
+class Function_asech(PrimitiveFunction):
+    """
+    The inverse of the hyperbolic secant function.
+
+    EXAMPLES:
+        sage: asech(.5)
+        1.316957896924817
+        sage: asech(1/2)
+        asech(1/2)
+        sage: asech(1 + I*1.0)
+        0.530637530952518 - 1.118517879643706*I
+    """
+    def _repr_(self, simplify=True):
+        return "asech"
+
+    def _latex_(self):
+        return "\\sech^{-1}"
+
+    def _approx_(self, x):
+        return float(pari(float(1/x)).acosh())
+
+asech = Function_asech()
+_syms['asech'] = asech
+
+class Function_acsch(PrimitiveFunction):
+    """
+    The inverse of the hyperbolic cosecant function.
+
+    EXAMPLES:
+        sage: acsch(2.)
+        0.481211825059603
+        sage: acsch(2)
+        acsch(2)
+        sage: acsch(1 + I*1.0)
+        0.530637530952518 - 0.452278447151191*I
+    """
+    def _repr_(self, simplify=True):
+        return "acsch"
+
+    def _latex_(self):
+        return "\\csch^{-1}"
+
+    def _approx_(self, x):
+        return float(pari(float(1/x)).asinh())
+
+acsch = Function_acsch()
+_syms['acsch'] = acsch
+
 class Function_acos(PrimitiveFunction):
     """
@@ -5607 +5679 @@
 atan = Function_atan()
 _syms['atan'] = atan
+
+class Function_acot(PrimitiveFunction):
+    """
+    The arccotangent function.
+
+    EXAMPLES:
+        sage: acot(1/2)
+        acot(1/2)
+        sage: RDF(acot(1/2))
+        1.10714871779
+        sage: acot(1 + I)
+        acot(I + 1)
+    """
+    def _repr_(self, simplify=True):
+        return "acot"
+
+    def _latex_(self):
+        return "\\cot^{-1}"
+
+    def _approx_(self, x):
+        return math.pi/2 - math.atan(x)
+
+acot = Function_acot()
+_syms['acot'] = acot
+
+class Function_acsc(PrimitiveFunction):
+    """
+    The arccosecant function.
+
+    EXAMPLES:
+        sage: acsc(2)
+        acsc(2)
+        sage: RDF(acsc(2))
+        0.523598775598
+        sage: acsc(1 + I)
+        acsc(I + 1)
+    """
+    def _repr_(self, simplify=True):
+        return "acsc"
+
+    def _latex_(self):
+        return "\\csc^{-1}"
+
+    def _approx_(self, x):
+        return math.asin(1/x)
+
+acsc = Function_acsc()
+_syms['acsc'] = acsc
+
+class Function_asec(PrimitiveFunction):
+    """
+    The arcsecant function.
+
+    EXAMPLES:
+        sage: asec(2)
+        asec(2)
+        sage: RDF(asec(2))
+        1.0471975512
+        sage: asec(1 + I)
+        asec(I + 1)
+    """
+    def _repr_(self, simplify=True):
+        return "asec"
+
+    def _latex_(self):
+        return "\\sec^{-1}"
+
+    def _approx_(self, x):
+        return math.acos(1/x)
+
+asec = Function_asec()
+_syms['asec'] = asec
 
 

sage/calculus/calculus.py

@@ -1997 +1997 @@
             There is also a function \code{numerical_integral} that implements
             numerical integration using the GSL C library.  It is potentially
-            much faster and applies to arbitrary user defined functions. 
+            much faster and applies to arbitrary user defined functions.
+
+            Also, there are limits to the precision that Maxima can compute
+            the integral to due to limitations in quadpack.
+
+            sage: f = x
+            sage: f = f.nintegral(x,0,1,1e-14)
+            Traceback (most recent call last):
+            ...
+            ValueError: Maxima (via quadpack) cannot compute the integral to that precision
 
         EXAMPLES:
@@ -2049 +2058 @@
         syntax. 
         """
-        v = self._maxima_().quad_qags(var(x),
+        try:
+            v = self._maxima_().quad_qags(var(x),
                                       a, b, desired_relative_error,
                                       maximum_num_subintervals)
+        except TypeError, err:
+            if "ERROR NUMBER = 6" in str(err):
+                raise ValueError, "Maxima (via quadpack) cannot compute the integral to that precision"
+            else:
+                raise TypeError, err
+            
         return float(v[0]), float(v[1]), Integer(v[2]), Integer(v[3])
 
@@ -2459 +2475 @@
             sage: v = 0.004*(9600*e^(-(1200*t)) - 2400*e^(-(300*t)))
             sage: v.find_root(0, 0.002)
-            0.0015403270679114178
+            0.001540327067911417...
 
              sage: a = .004*(8*e^(-(300*t)) - 8*e^(-(1200*t)))*(720000*e^(-(300*t)) - 11520000*e^(-(1200*t))) +.004*(9600*e^(-(1200*t)) - 2400*e^(-(300*t)))^2
@@ -2472 +2488 @@
         However \code{find_root} works beautifully:
             sage: a.find_root(0,0.002)
-            0.00041105140493493411
+            0.0004110514049349341...
         """
         a = float(a); b = float(b)