All Packages  Class Hierarchy  This Package  Previous  Next  Index

Class ia_math.IAMath

java.lang.Object
   |
   +----ia_math.IAMath

public class IAMath
extends Object
the class IAMath contains methods for performing basic arithmetic operations on intervals. Currently the elementary functions rely on the underlying implementation which uses the netlib fdlibm library. The resulting code is therefore probably unsound for the transcendental functions.


Constructor Index

 o IAMath()

Method Index

 o acos(RealInterval)
 o acos2pi(RealInterval)
 o add(RealInterval, RealInterval)
 o asin(RealInterval)
 o asin2pi(RealInterval)
 o atan(RealInterval)
 o atan2pi(RealInterval)
 o cos(RealInterval)
 o cos2pi(RealInterval)
 o div(RealInterval, RealInterval)
The Natural Extension of division in Interval Arithmetic
 o evenPower(RealInterval, double)
this is the Natural Interval extension of |x|**y<\code} where x is an interval and y is a double.
 o evenRoot(RealInterval, double)
this is the Natural Interval extension of xpos**(1/y)<\code} where x is an interval and xpos is the set of positive numbers contained in x and y is a non-zero double.
 o exp(RealInterval)
 o integerPower(RealInterval, RealInterval)
returns (x**y) assuming that y is restricted to integer values currently returns (-infty,infty) if y is not bound to an interval containing a single integer
 o integerRoot(RealInterval, RealInterval)
returns (x**1/y) assuming that y is restricted to integer values currently returns (-infty,infty) if y is not bound to an interval containing a single integer
 o intersect(RealInterval, RealInterval)
 o intersect_odiv(RealInterval, RealInterval, RealInterval)
this performs (y := y intersect z/x) and succeeds if y is nonempty.
 o intersectIntegerRoot(RealInterval, RealInterval, RealInterval)
computes u := (u intersect ((x**1/y) union -(x**1/y))) and returns true if u is nonempty Also, assumes that y is a constant integer interval
 o leftendpoint(RealInterval)
 o log(RealInterval)
 o main(String[])
 o midpoint(RealInterval)
 o mul(RealInterval, RealInterval)
 o nonempty(RealInterval)
 o oddPower(RealInterval, double)
this is the Natural Interval extension of sgn(x)*(|x|**y)<\code} where x is an interval and y is a double.
 o oddRoot(RealInterval, double)
this is the Natural Interval extension of sgn(x)*|x|**(1/y)<\code} where x is an interval and y is a non-zero double.
 o odiv(RealInterval, RealInterval)
This is identical to the standard div(x,y) method, except that if y is identically zero, then the infinite interval (-infinity, infinity) is returned.
 o oldcos2pi(RealInterval)
 o power(RealInterval, RealInterval)
returns (x**y) computed as exp(y*log(x))
 o rightendpoint(RealInterval)
 o sin(RealInterval)
 o sin2pi(RealInterval)
 o sinRange(int, int)
 o sub(RealInterval, RealInterval)
 o tan(RealInterval)
 o tan2pi(RealInterval)
 o uminus(RealInterval)
 o union(RealInterval, RealInterval)

Constructors

 o IAMath
 public IAMath()

Methods

 o nonempty
 public static final boolean nonempty(RealInterval x)
 o intersect
 public static RealInterval intersect(RealInterval x,
                                      RealInterval y) throws IAException
 o union
 public static RealInterval union(RealInterval x,
                                  RealInterval y) throws IAException
 o add
 public static RealInterval add(RealInterval x,
                                RealInterval y)
 o sub
 public static RealInterval sub(RealInterval x,
                                RealInterval y)
 o mul
 public static RealInterval mul(RealInterval x,
                                RealInterval y)
 o div
 public static RealInterval div(RealInterval x,
                                RealInterval y)
The Natural Extension of division in Interval Arithmetic

Parameters:
x - an interval
y - an interval
Returns:
s the smallest IEEE interval containing the set x/y.
Throws: IAException
is thrown with the message Division by Zero.
 o odiv
 public static RealInterval odiv(RealInterval x,
                                 RealInterval y)
This is identical to the standard div(x,y) method, except that if y is identically zero, then the infinite interval (-infinity, infinity) is returned.

 o intersect_odiv
 public static boolean intersect_odiv(RealInterval y,
                                      RealInterval z,
                                      RealInterval x) throws IAException
this performs (y := y intersect z/x) and succeeds if y is nonempty.

 o uminus
 public static RealInterval uminus(RealInterval x)
 o exp
 public static RealInterval exp(RealInterval x)
 o log
 public static RealInterval log(RealInterval x) throws IAException
 o sin
 public static RealInterval sin(RealInterval x)
 o cos
 public static RealInterval cos(RealInterval x)
 o tan
 public static RealInterval tan(RealInterval x)
 o asin
 public static RealInterval asin(RealInterval x) throws IAException
 o acos
 public static RealInterval acos(RealInterval x)
 o atan
 public static RealInterval atan(RealInterval x)
 o sinRange
 public static RealInterval sinRange(int a,
                                     int b)
 o sin2pi
 public static RealInterval sin2pi(RealInterval x)
 o cos2pi
 public static RealInterval cos2pi(RealInterval x)
 o oldcos2pi
 public static RealInterval oldcos2pi(RealInterval x)
 o tan2pi
 public static RealInterval tan2pi(RealInterval x)
 o asin2pi
 public static RealInterval asin2pi(RealInterval x) throws IAException
 o acos2pi
 public static RealInterval acos2pi(RealInterval x)
 o atan2pi
 public static RealInterval atan2pi(RealInterval x)
 o midpoint
 public static RealInterval midpoint(RealInterval x)
 o leftendpoint
 public static RealInterval leftendpoint(RealInterval x)
 o rightendpoint
 public static RealInterval rightendpoint(RealInterval x)
 o power
 public static RealInterval power(RealInterval x,
                                  RealInterval y) throws IAException
returns (x**y) computed as exp(y*log(x))

 o evenPower
 public static RealInterval evenPower(RealInterval x,
                                      double y) throws IAException
this is the Natural Interval extension of |x|**y<\code} where x is an interval and y is a double.

 o oddPower
 public static RealInterval oddPower(RealInterval x,
                                     double y) throws IAException
this is the Natural Interval extension of sgn(x)*(|x|**y)<\code} where x is an interval and y is a double.

 o evenRoot
 public static RealInterval evenRoot(RealInterval x,
                                     double y) throws IAException
this is the Natural Interval extension of xpos**(1/y)<\code} where x is an interval and xpos is the set of positive numbers contained in x and y is a non-zero double.

 o oddRoot
 public static RealInterval oddRoot(RealInterval x,
                                    double y) throws IAException
this is the Natural Interval extension of sgn(x)*|x|**(1/y)<\code} where x is an interval and y is a non-zero double.

 o integerPower
 public static RealInterval integerPower(RealInterval x,
                                         RealInterval y) throws IAException
returns (x**y) assuming that y is restricted to integer values currently returns (-infty,infty) if y is not bound to an interval containing a single integer

 o integerRoot
 public static RealInterval integerRoot(RealInterval x,
                                        RealInterval y) throws IAException
returns (x**1/y) assuming that y is restricted to integer values currently returns (-infty,infty) if y is not bound to an interval containing a single integer

 o intersectIntegerRoot
 public static boolean intersectIntegerRoot(RealInterval x,
                                            RealInterval y,
                                            RealInterval u) throws IAException
computes u := (u intersect ((x**1/y) union -(x**1/y))) and returns true if u is nonempty Also, assumes that y is a constant integer interval

 o main
 public static void main(String argv[])

All Packages  Class Hierarchy  This Package  Previous  Next  Index