!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd e f g h i j k l m n o p q r s t u v w x y z { | } ~     ",classes abstracting function approximations portable experimentalmik@konecny.aow.cz$This class extends   by: G making the domain of the function enclosure available for inspection; 8 allowing the construction of basic function enclosures , where the domain has to be specified. ;A function enclosure with no information about the function' s values. 9Construct a constant enclosure for a tuple of functions. 8Construct the exact enclosure for a projection function  (ie a variable). -Return the domain of the function enclosure. DSplit the domain into two halves, yoelding two function enclosures. 5Merge function enclosures with neighbouring domains. Safely integrate a  R^n -> R^m function enclosure E with some initial condition (origin and function at origin). Safely integrate a R -> R^m function enclosure. Safely integrate a  R^n -> R^m function enclosure ? intersecting it with a prior enclosure for the result. >The prior enclosure could contains one of more initial value. Safely integrate a R -> R^m function enclosure ? intersecting it with a prior enclosure for the result. >The prior enclosure could contains one of more initial value. =A class of types that approximate first-order real functions   R^n -> R^m3 using some type of graph enclosures. The domains @ of the functions can be neither specified nor investigated ! by operations in this class. This class extends  % so that we could perform point-wise ! operations on the functions. This class is associated with: % two real number types (instances of  () for working with parts of the function's domain and range; 3 a type of boxes indexed by variables (instance of ) for working with  parts of the function' s domain. 7Check internal consistency and report problem if any. @Get the internal degree of quality (usually polynomial degree)  of the approximation. ASet an upper bound on the degree of this function approximation. :This reduces the degree immediately if necessary and also @ affects all operations performed with this value later. AMay also set the maximum size of the approximations to a default A based on the degree and the dimension of this enclosure. 7Get the current uppend bound on the degree associated + with this function approximation. ,Get the internal size of the approximation / (usually number of polynomial terms). ?Set an upper bound on the size of this function approximation. 8This reduces the size immediately if necessary and also @ affects all operations performed with this value later. 5Get the current uppend bound on the size associated + with this function approximation. @List all variables that are actually used in the approximation. 8Give a close upper bound of the precision of the range 6 at the best approximated point in the domain. 6Find some upper and lower bounds of the function over [-1,1]^n. 8Combine several functions with the same domain into one tuple function. 0Reveal how many functions are bundled together. &Modify a tuple of functions in a way : that does not treat the tuple elements uniformly. IFind close upper and lower bounds of the volume of the entire enclosure. N A negative volume means that the enclosure is certainly inconsistent. BMultiply a function approximation by a real number approximation. LIntersect one approximation by another but only on a box within its domain. KIntersect two enclosures and measure the global improvement as one number. (Use  defined in module Data.Number.ER.Real.Approx B to measure the improvement using a function enclosure.) *Evaluate the function at the given point. >Fix some variables in the function to the given exact values. !9A simple and limited composition of functions applicable B only when the range-defining function is non-decreasing. "9A simple and limited composition of functions applicable B only when the range-defining function is non-increasing. #4Recursively perform a number of bisections and then # glue the bits back together. This way we can ensure that 5 a piece-wise enclosure has a partition that goes " to at least the given depth. $UCheck that a pointwise operation previously performed on function approximations is 3 consistent with the same operation performed on 5 selected points in the domain of these functions. G The selected points are the centres of all faces of all dimensions,  which includes the corners. <The result of this function is the list of points in which > the consistency check failed. The result of the operation = is also included both for the real number version and the # function approximation version. %7Check that a function approximation is consistent with ? a real function that is meant to compute the same function. <The result of this function is the list of points in which > the consistency check failed. The result of the operation = is also included both for the real number version and the # function approximation version. &  !"#$%&  !" #%$&     !"  !"#$%.a list of approximations over the same domain portable experimentalmik@konecny.aow.cz&=A tuple of function approximations allowing one to get from  functions R^n->R to a function  R^n -> R^m. &'(&'(&'('(2separate approximations per domain-box hyper-edge portable experimentalmik@konecny.aow.cz)=Use some function approximation type and for each domain box E keep a structure of function approximations of this type indexed E by the hyper-edge structure. For each hyper-edge of the domain, 3 the approximation has this edge as its domain. 'E.g. for a 2D square domain there are: ( one approximation for the whole square + four 1D approximations, one for each edge > eight 0D approximations, one for each endpoint of each edge )*+,)*+,)*+,*+, addressing and modifying leaves portable experimentalmik@konecny.aow.cz-3A representation of a binary tree with a hole that  can be efficiently filled. 1A path in a binary tree. ) It is used mainly in connection with BisectionTree.BisectionTree. 5@Assuming that bisection happens at default points as defined by  * and starts from the given root interval. 6@Lookup a subdomain of a function according to a bisection path. B Return the restrited function as well as a zipper that allows ? an efficient modification of the function on the looked up  subdomain. 73Modify a function in its subdomain as expressed by  the zipper. -./01234567 14325-0/.67 -0/../01432234567 hierarchical domain partitions portable experimentalmik@konecny.aow.cz9+value splitter function - parameters are: : depth, domain of value, value, variable to split by, 4 point to split at; returns the two split values ;1 The root of the tree often represents the whole R^n.  Each node splits the parent's space into two using K a specified variable (ie direction) and an optional splitting point. A By default, a split is taken at the point defined by the method  RA.bisect. =direction to split in >point that the split is at ?%the half towards -Infty in split dir @%the half towards +Infty in split dir Bdepth of this node Cdomain Dvalue estimate I:Apply a function to all values, thus creating a new tree. J:Apply a function to all values, thus creating a new tree. CApply a function to all values, thus creating a list of new trees. KKPerform a given action on all branches of a bisection tree, left to right. 1 (optionally now going below the given depth) LKPerform a given action on all branches of a bisection tree, left to right. 1 (optionally now going below the given depth) MJPerform a given action on all branches of a bisection tree, left to right 3 with the option of further branching the tree. 1 (optionally now going below the given depth) O9Ensure both trees have equal structure at the top level: = either they are all leaves or they all split at the same - direction with the same splitting point. *Also, unify the domains at the top level. P<Ensure all the trees have equal structure at the top level: = either they are all leaves or they all split at the same - direction with the same splitting point. *Also, unify the domains at the top level. QDCombine two bisection trees using a given value combining function. @ Where necessary, leaves are split so that the resulting tree' s structure I is the union of the two argument tree structures. Such splitting of = values in leaves is performed by the provided functions. RAreturn all values in leafs (except those within some CE subtree) 3 as a list (from the leftmost to the rightmost) SAreturn all values in leafs (except those within some CE subtree) 3 as a list (from the leftmost to the rightmost) T#linear ordering on bisection trees UGlookup all maximal subtrees whose domain intersect the given rectangle &Update a value on a given sub-domain, . bisecting the tree if necessary to obtain / a better fit for the domain, but not below  a given depth limit. ?With multiple domain dimensions, split the domain according to  . 89:;<=>?@ABCDEFGHIJKLMNOPQRSTU ;A<BCDBC=>?@:98EFNOPGHIJKLMQRSTU89:; A<BCDBC=>?@<=>?@ABCDEFGHIJKLMNOPQRSTU;abstract zipping of domain partitions used for integration portable experimentalmik@konecny.aow.czV;Transform a bunch of bisection trees over the same domain  by  integrating" them in a very abstract sense. F The trees are unified in their splitting patterns in the process. ? By supplying certain parameters, this function can in fact F perform numerical integration of piece-wise polynomial functions. It can be also viewed as a zipping+folding$ operator over bisection trees that \ generates another bunch of bisection trees, synchronously traversing the original trees J from a certain point on a selected axis outwards in both directions,  carrying some data along. W<Zip a list of bisection trees in synchrony but do something 2 else inside and not inside a given subdomain. GFurther splitting at default points will be done up to the given depth A in an attempt to separate the subdomain as well as possible. BIf the subdomain is not properly isolated by the splitting at the P maximum depth, splits are made at irregular points to ensure full isolation  of the subdomain. VWVWVW=arbitrary precision piece-wise-something function enclosures portable experimentalmik@konecny.aow.czX*Arbitrary precision piece-wise something 2 (eg linear, polynomial, rational) enclosures  of functions R^n->R^m. 7The type of approximation within segments is specified  by an instance of . 8The piece-wise construction defines another instance of . XYXYXYY)class abstracting function enclosures on [-1,1]^n portable experimentalmik@konecny.aow.cz ZThis class extends  ERFnApprox by: ? assuming that the domain of the function enclosures is always [-1,1]^n for some n; 8 allowing the construction of basic function enclosures ( where the domain has to be known. [;A function enclosure with no information about the function' s values. \9Construct a constant enclosure for a tuple of functions. ]7Construct the exact enclosure of an affine function on [-1,1]^n. ^/A simple and limited composition of functions. NIt is primarily intended to be used for precomposition with affine functions. _IFind close upper and lower bounds of the volume of the entire enclosure. N A negative volume means that the enclosure is certainly inconsistent. JExplicitly specify the variables to identify the dimension of the domain. `KIntersect two enclosures and measure the global improvement as one number. (Use  defined in module Data.Number.ER.Real.Approx B to measure the improvement using a function enclosure.) JExplicitly specify the variables to identify the dimension of the domain. aSafely integrate a [-1,1] ^n -> R^m function enclosure E with some initial condition (origin and function at origin). bUCheck that a pointwise operation previously performed on function approximations is 3 consistent with the same operation performed on 5 selected points in the domain of these functions. G The selected points are the centres of all faces of all dimensions,  which includes the corners. <The result of this function is the list of points in which > the consistency check failed. The result of the operation = is also included both for the real number version and the # function approximation version. c7Check that a function approximation is consistent with ? a real function that is meant to compute the same function. <The result of this function is the list of points in which > the consistency check failed. The result of the operation = is also included both for the real number version and the # function approximation version. Z[\]^_`abc Z[\]^_`acb Z[\]^_`a[\]^_`abc 8class abstracting imprecise function arithmetic on [-1,1]^n portable experimentalmik@konecny.aow.cz*eHThis should be evaluated before using any of the following operations. f<Convert from the associated interval type to the base type. B (The types are determined by the given example function.) g=Convert from the base type to the associated interval type. B (The types are determined by the given example function.) hTA linear ordering on basic functions, which can be syntactic and rather arbitrary. jLCheck internal consistency of the basic function, typically absence of NaN. kLCheck internal consistency of the basic function and report problem if any. lDGet the granularity of the coefficients inside this basic function. o'Get the degree of this basic function. 6If the function is a polynomial, this function should  return its degree. pEDecrease the degree of a basic function, rounding pointwise upwards. q*Get the term size of this basic function. 6If the function is a polynomial, this function should 7 return the number of terms in the polynomial. rFDecrease the size of this basic function, rounding pointwise upwards. s=Get a list of all variables featured in this basic function. t&Construct a constant basic function. uJConstruct a constant basic enclosure (negated lower bound, upper bound). v%Construct an affine basic function. w-Find an upper bound of a basic function over [-1,1]^n. xApproximate the function  max(f1,f2) from above. yApproximate the function  min(f1,f2) from above. z.Pointwise exact negation of a basic function {9Multiply a basic function by a scalar, rounding upwards. |<Multiply a basic function by an approximation of a scalar,  rounding upwards. }$Pointwise upwards rounded addition ~'Pointwise upwards rounded subtraction *Pointwise upwards rounded multiplication Enclosure multiplication >IMPORTANT: enclosure = (negated lower bound, upper bound) Approximate the function 1/f from above, assuming  f' does not hit zero in the unit domain. 5Approximate the reciprocal of an enclosure, assuming  f' does not hit zero in the unit domain. >IMPORTANT: enclosure = (negated lower bound, upper bound) 7Evaluate a basic function at a point rounding upwards @ using a basic number for both the point and the result. NSafely evaluate a basic function at a point using a real number approximation + for both the point and the result. BPartially evaluate a basic function at a lower-dimensional point 1 given using a real number approximation. 7 Approximate the resulting function from above. >Compose two basic functions, rounding downwards and upwards,  assuming f_v ranges within the domain [-1,1]. >Compose two basic functions, rounding downwards and upwards,  assuming f_v ranges within the domain [-1,1]. NSubstitute several variables in a basic function with other basic functions, 6 rounding downwards and upwards, assuming each f_v ranges  within the domain [-1,1]. NSubstitute several variables in a basic function with other basic functions, 6 rounding downwards and upwards, assuming each f_v ranges  within the domain [-1,1].  Approximate sqrt(f) for enclosures.  Approximate exp(f) for enclosures.  Approximate log(f) for enclosures.  Approximate sin(f) for enclosures,  assuming the range of f is within [-pi2,pi2].  Approximate cos(f) for enclosures,  assuming the range of f is within [-pi2,pi2].  Approximate atan(f) for enclosures. &Approximate the primitive function of f from below and from above. 'Measure the volume between a function . and the zero hyperplane on the domain [-1,1]^n. .defghijklmnopqrstuvwxyz{|}~.defghijklmnopqrstuvwxyz{|}~.d-efghijklmnopqrstuvwxyz{|}~efghijklmnopqrstuvwxyz{|}~ +arbitrary precision function enclosures on [-1,1]^n portable experimentalmik@konecny.aow.cz   enclosures translated from [-1,1]^n to another domain portable experimentalmik@konecny.aow.czThe canonical translation of 8 any compact non-empty and non-singleton interval in R " to and from the unit interval [-1,1]. 3This structure holds the two coefficients for both  linear mappings. the interval being mapped %Datatype translating enclosures from [-1,1]^n to any compact  interval in R^n with non-empty interior ; using a bunch of linear maps, one for each dimension.  4(internal) polynomial datatype and simple functions portable experimentalmik@konecny.aow.cz EA polynomial represented by its coefficients it the Chebyshev basis. 8The polynomials are never to be used outside the domain [-1,1]^n. GAll operations are rounded in such a way that the resulting polynomial  is a point-wise upper or lower bound of the exact result. 4Inspect all terms of the polynomial and return the ' degree of the highest degree term. 4If the polynomial is constant, return the constant,  otherwise return Nothing.  Make a basic x* polynomial for a given variable number.  Construct an affine polynomial. 1Convert a polynomial to a string representation, " using the ordinary x^n basis. @conversion of polynomials from Chebyshev basis to the X^n basis E(not exact - suffering from rounding in the coefficient conversions) 2conversion of one Chebyshev term to the X^n basis EChebyshev polynomials expressed as associative lists power -> coeff VChebyshev polynomials expressed as lists of integer coefficients for powers 0,1,2...  9(internal) uniformly roudned pointwise ring operations portable experimentalmik@konecny.aow.czNegate a polynomial exactly. AAdd a constant to a polynomial, rounding downwards and upwards. 6Add two polynomials, rounding downwards and upwards. ;Multiply two polynomials, rounding downwards and upwards. CMultiply a polynomial by a scalar rounding downwards and upwards. AMultiply a polynomial by itself, rounding downwards and upwards.  !"#$%&':(internal) uniformly roudned polynomial size reductions portable experimentalmik@konecny.aow.czQConvert a polynomial to a lower-order one that is dominated by (resp. dominates) " it closely on the domain [-1,1]. ()*+0(internal) evaluation of polynomials at a point portable experimentalmik@konecny.aow.czPEvaluate a polynomial at a point, consistently rounding upwards and downwards. 6Evaluate a polynomial at a real number approximation NSubstitute several variables in a polynomial with real number approximations, $ rounding downwards and upwards. 5(internal) bounds of single and multiple polynomials portable experimentalmik@konecny.aow.cz .Find an upper bound on a polynomial over the  unit domain [-1,1]^n. -Find a lower bound on a polynomial over the  unit domain [-1,1]^n. ;Find both lower and upper bounds on a polynomial over the  unit domain [-1,1]^n. 6Find bounds on a polynomial over the unit domain [-1,1]^n. 'Fast but inaccurate method, in essence 6 taking the maximum of the upper affine reduction. =Find a close upper bound on a quadratic polynomial over the  unit domain [-1,1]^n. :Much slower and somewhat more accurate method, in essence 9 taking the maximum of the upper quadratic reduction.  !!! Not yet properly tested !!! PApproximate from below and from above the pointwise maximum of two polynomials PApproximate from below and from above the pointwise minimum of two polynomials @Approximate the function max(0,p(x)) by a polynomial from below  and from above.  A version of  using a cubic approximation. FMultiply a polynomial by an enclosure (with non-negated lower bound). ,-./01234 B(internal) basic operations for primitive polynomial enclosures portable experimentalmik@konecny.aow.cz#Multiply an enclosure by a scalar E assuming the enclosure is non-negative on the whole unit domain. #Multiply an enclosure by a scalar. DMultiply a polynomial by a scalar interval, returning an enclosure. 5Evaluate the Chebyshev polynomials of the first kind N applied to a given polynomial, yielding a list of polynomial enclosures. /Multiply a polynomial by an enclosure using min/max 56789:;<=>?@AB #(internal) division of polynomials portable experimentalmik@konecny.aow.cz2Approximate the pointwise cosine of a polynomial 4 by another polynomial from below and from above  using the tau method  as described in [Mason & Handscomb 2003, p 62]. 9(internal) elementary functions applied to polynomials portable experimentalmik@konecny.aow.czCApproximate the pointwise exponential of a square root enclosure. AApproximate the pointwise exponential of a polynomial enclosure. 9Approximate the pointwise integer power of an enclosure. >Approximate the pointwise natural logarithm of an enclosure. 0Approximate the pointwise sine of an enclosure. %Assuming the polynomial range is [-pi2, pi2]. 2Approximate the pointwise cosine of an enclosure. %Assuming the polynomial range is [-pi2, pi2]. :Approximate the pointwise arcus tangens of an enclosure. C+(testing) generating polynomials for tests portable experimentalmik@konecny.aow.czQDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxy,(testing) properties of bounding operations portable experimentalmik@konecny.aow.czz{|((testing) properties of ring operations portable experimentalmik@konecny.aow.cz}~3(testing) properties of basic enclosure operations portable experimentalmik@konecny.aow.cz8(testing) properties of enclosure elementary operations portable experimentalmik@konecny.aow.cz-(testing) properties of reduction operations portable experimentalmik@konecny.aow.cz 6(testing) properties of polynomial enclosure division portable experimentalmik@konecny.aow.cz&(internal) composition of polynomials portable experimentalmik@konecny.aow.czOCompose a polynomial and an enclosure, producing a correcly rounded enclosure, - assuming the second polynomial maps [-1,1] into [-1,1]. *Compose two polynomials, rounding upwards - provided the second polynomial maps [-1,1] into [-1,1]. !.(testing) properties of enclosure composition portable experimentalmik@konecny.aow.cz"2(testing) running all polynomial tests in a batch portable experimentalmik@konecny.aow.cz,(internal) integration of polynomials etc portable experimentalmik@konecny.aow.czDApproximate from below and from above the integral of a polynomial. ;Based on the following formulas for Chebyshev polynomials:   \int T_n(x)dx = . T_{n+1}(x)/2(n+1) - T_{n-1}(x)/2(n-1)   \int T_1(x)dx =  T_2(x)/4 + 1/4  \int T_0(x)dx =  T_1(x) #0multivariate polynomials in the Chebyshev basis portable experimentalmik@konecny.aow.cz3concise names for default function representations non-portable (requires fenv.h) experimentalmik@konecny.aow.cz         $'definitions useful for testing in ghci non-portable (requires fenv.h) experimentalmik@konecny.aow.cz-%overview of AERN-RnToRm non-portable (requires fenv.h) experimentalmik@konecny.aow.czY  !"#$%   &'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLLMNNOPQRSTUVWXYZ[\]^_`abcdefghi(jklmnopqrstuvwxyz{{|'(}~AD-JK  2 5 8 ; ( } -                  D        ! " # $ % & ' ( ) *+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   !!!!"""""""$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$wkAERN-RnToRm-0.4.9.1Data.Number.ER.RnToRm.Approx"Data.Number.ER.RnToRm.Approx.Tuple%Data.Number.ER.RnToRm.Approx.DomEdges(Data.Number.ER.RnToRm.BisectionTree.Path#Data.Number.ER.RnToRm.BisectionTree/Data.Number.ER.RnToRm.BisectionTree.Integration&Data.Number.ER.RnToRm.Approx.PieceWise$Data.Number.ER.RnToRm.UnitDom.Approx"Data.Number.ER.RnToRm.UnitDom.Base-Data.Number.ER.RnToRm.UnitDom.Approx.Interval&Data.Number.ER.RnToRm.Approx.DomTransl9Data.Number.ER.RnToRm.UnitDom.ChebyshevBase.Polynom.Basic8Data.Number.ER.RnToRm.UnitDom.ChebyshevBase.Polynom.Ring:Data.Number.ER.RnToRm.UnitDom.ChebyshevBase.Polynom.Reduce8Data.Number.ER.RnToRm.UnitDom.ChebyshevBase.Polynom.Eval:Data.Number.ER.RnToRm.UnitDom.ChebyshevBase.Polynom.Bounds=Data.Number.ER.RnToRm.UnitDom.ChebyshevBase.Polynom.EnclosureData.Number.ER.RnToRm.UnitDom.ChebyshevBase.Polynom.ElementaryBData.Number.ER.RnToRm.UnitDom.ChebyshevBase.Polynom.Tests.Generate;Data.Number.ER.RnToRm.UnitDom.ChebyshevBase.Polynom.Compose?Data.Number.ER.RnToRm.UnitDom.ChebyshevBase.Polynom.Integration!Data.Number.ER.RnToRm.DefaultReprAERN-Real-0.9.9Data.Number.ER.Real.ApproxData.Number.ER.Real.DomainBox@Data.Number.ER.RnToRm.UnitDom.ChebyshevBase.Polynom.Tests.Bounds>Data.Number.ER.RnToRm.UnitDom.ChebyshevBase.Polynom.Tests.RingCData.Number.ER.RnToRm.UnitDom.ChebyshevBase.Polynom.Tests.EnclosureDData.Number.ER.RnToRm.UnitDom.ChebyshevBase.Polynom.Tests.Elementary@Data.Number.ER.RnToRm.UnitDom.ChebyshevBase.Polynom.Tests.ReduceBData.Number.ER.RnToRm.UnitDom.ChebyshevBase.Polynom.Tests.DivisionAData.Number.ER.RnToRm.UnitDom.ChebyshevBase.Polynom.Tests.Compose=Data.Number.ER.RnToRm.UnitDom.ChebyshevBase.Polynom.Tests.Run3Data.Number.ER.RnToRm.UnitDom.ChebyshevBase.Polynom!Data.Number.ER.RnToRm.TestingDefsData.Number.ER.RnToRm ERFnDomApprox bottomApproxconstprojdombisectunBisect integrateintegrateUnaryintegrateMeasureImprovement integrateMeasureImprovementUnary ERFnApproxcheck domra2ranra ranra2domra getDegree setMaxDegree getMaxDegreegetSize setMaxSize getMaxSize getVariablesgetBestPrecisiongetRangeApproxtuple getTupleSize applyTupleFnvolumescalepartialIntersectintersectMeasureImprovementeval partialEvalcomposeNonDecreasingcomposeNonIncreasingbisectUnbisectDepth"keyPointsPointwiseConsistencyCheckkeyPointsConsistencyCheck ERFnTuple erfnTupleERFnDomEdgesApproxerfnMainVolume erfnEdgesFnZipperFnZ_RFnZ_LFnZ_H BisecTreePathBTP_LBTP_RBTP_Hpath2domlookupSubdomain updateFnZ ValueCombiner ValueSplitterDepth BisectionTreeNodebistrDirbistrPtbistrLObistrHILeaf bistrDepthbistrDombistrValisLeafsetDepthsplit mapWithDom mapLeavesdoBistrdoMap doMapLeaves removeVarssync2syncMany combineWith collectValuescollectDomValuescomparelookupSubtreeDoms zipFromOriginzipOnSubdomain ERFnPiecewiseERUnitFnApproxaffinecomposeWithThin ERUnitFnBaseinitialiseBaseArithmetic raEndpointsraFromEndpoints compareApprox showDiGrCmpisValidgetGranularitysetMinGranularitysetGranularityreduceDegreeUp reduceSizeUp constEncl upperBoundmaxUpminUpnegscaleUp scaleApproxUp+^-^*^ multiplyEnclrecipUp recipEnclevalUp evalApproxpartialEvalApproxUp composeUp composeEncl composeManyUpcomposeManyEnclssqrtEnclexpEncllogEnclsinEnclcosEnclatanEnclvolumeAboveZeroUp ERFnContext erfnMaxDegree erfnMaxSizeerfnCoeffGranularity ERFnInterval erfnLowerNeg erfnUpper erfnGlobalERFnIntervalAny erfnContext DomTransldtrDomdtrFromUnitSlopedtrFromUnitConstdtrToUnitSlopedtrToUnitConstERFnDomTranslApproxerfnUnitApprox erfnDomTranslTermKey ERChebPoly chplCoeffschplConstTermKeychplIsConstTermKey chplTermOrder chplTermArity chplGetDegree chplGetConst chplConstchplVar chplAffinechplRemoveZeroTermsUpchplCountTermschplShow chebToXBasis termXtermschebyXCoeffsLists chebyXCoeffs chplAddConstchplAdd chplMultiply chplScale chplSquarechplReduceTermCountchplReduceDegreechplEval chplEvalUp chplEvalDownchebyEvalTsExact chplRAEvalchplPartialRAEvalchplUpperBoundchplLowerBound chplBoundschplBoundsAffinechplUpperBoundQuadrchplMaxchplMin chplNonnegchplNonnegCubic chplTimesLoHienclThin enclConst enclRAConst enclMultiply enclSquareenclScaleNonneg enclScale enclRAScale chplScaleRA enclEvalTs enclThinTimes enclRecipenclSqrtenclExpenclPowenclLogenclSine enclCosinesincosTaylorAuxenclAtanE SmallRatio Deg20Size20Int20PSize30PSize10PSize10Degree10PSize10Degree3 PNoLimitsPchplAtKeyPointsCanBeLeq.chplAtKeyPointsPointwiseBinaryDownUpConsistent.enclAtKeyPointsPointwiseBinaryDownUpConsistent-enclAtKeyPointsPointwiseUnaryDownUpConsistentenclAtKeyPointsConsistentvarsvarsEoneoneE enclComposeenclComposeMany chplIntegrateFAFAPWPFAPEFAPTFAPDFAPUERApprox ERIntApprox DomainBox bisectDomainmapMultiLeaves updateVal bestSplit errorModule chplHasNoNaNchplHasNoNaNOrInfty chplCheckchplCompareApprox chplGetVarschplGetGranularitychplSetMinGranularitychplSetGranularitychplNegchplAddConstUpchplAddConstDown+.-.*. chplScaleDown chplScaleUpchplReduceTermCountDownchplReduceTermCountUpchplReduceDegreeDownchplReduceDegreeUp chplMaxDn chplMaxUp chplMinDn chplMinUpchplNonnegDown chplNonnegUpchplNonposDown chplNonposUp chplNonpos enclBoundsenclEval enclEvalInner enclRAEvalenclRAEvalInner enclAddErrenclReduceDegreeenclReduceSize enclAddConstenclNeg+:-:chplScaleRADown chplScaleRAUp enclAtanAuxpolynomials1200ishSize10Degree3 polynomials1200ishSize10Degree10polynomials1200ishSize10polynomials1200ishSize30polynomials200ishSize30 getKeyPointsgetKeyPointsForVars makeThickEncl makeParalEnclenclRestrictRangex0x1x2x3x4x0Ex1Ex2Ex3Ex4EmonetwothreeseventhousandmilliontinyhugemoneEtwoEthreeEsevenE thousandEmillionEtinyEhugeEpolynomials1200ishpolynomials200ishpolynomials40ishpolynomials200ishSmallpolynomials40ishSmall polyBase5 polyBase13 powersAll powersForExpspowers10powers4 powers4Smallpowers2 powers2Small addConsts3 multConsts3 addConsts2 multConsts2prop_chplBounds_consistentprop_chplMax_consistentprop_chplMin_consistentprop_chplAdd_consistentprop_chplAddConst_consistentprop_chplMult_consistentprop_chplScale_consistent"prop_enclAdd_ThickEncls_consistent'prop_enclMultiply_ThickEncls_consistent'prop_enclMultiply_ParalEncls_consistent#prop_enclScale_ThickEncl_consistent#prop_enclScale_ParalEncl_consistent!prop_enclExp_ThickEncl_consistent!prop_enclExp_ParalEncl_consistent prop_enclExp_ThinEncl_consistent"prop_enclSine_ThickEncl_consistent"prop_enclSine_ParalEncl_consistent!prop_enclSine_ThinEncl_consistent$prop_enclCosine_ThickEncl_consistent$prop_enclCosine_ParalEncl_consistent#prop_enclCosine_ThinEncl_consistent"prop_enclAtan_ThickEncl_consistent"prop_enclAtan_ParalEncl_consistent!prop_enclAtan_ThinEncl_consistent sincosDomainnoDomainRestrictionencl_op_ThickEncl_consistentencl_op_ParalEncl_consistentencl_op_ThinEncl_consistent#prop_chplReduceTermCount_consistent prop_chplReduceDegree_consistent#prop_enclRecip_ThickEncl_consistent#prop_enclRecip_ParalEncl_consistentrecip_encl_consistent$prop_enclCompose_ThinEncl_consistent%prop_enclCompose_ThickEncl_consistent%prop_enclCompose_ParalEncl_consistentcompose_encl_consistent initArithrunPolynomTests mkRunTestschplTestOptions chplTests enclTestsfailed2$Data.Number.ER.Real.DomainBox.IntMapVarIDBox fapuConst1 fapdConst1 fapdConstU fapdConst01fapd04X0fapd13X0fapd12X1fapdUX0fapdUX1fapdUX2fapdT1fapdT2fapdT3 fapeConst1 fapeConstU fapeConst01fape13X0fape12X1fapeUX0fapeUX1 fapeTestMult fapeMultiVar fapeTestPEval fapeUConst1 fapeUConst13fapeUConst13InitPtfapwUUX0fapwUUX1fapwUPX0fapwUPX1fapwUMX0fapwUMX1 fapwUConst1 fapwUConst13fapwUConst13InitPt testIntegrE testIntegrPjas1fxyxLRfn1fn2fn3showVar defaultVarnewVarID VariableIDlookupfindWithDefaultzipWithDefaultSecondzipWithDefaultzipWith foldWithKeyfoldfilterelemskeys unionWithunion notMembermemberdelete insertWithinsert fromAscList toAscListfromListtoList singletonunarysizeisNoinfonoinfo differenceintersectionWith mapWithKeymapDomainBoxMappableclassifyPositionunify compatible DomainIntBox