interval-1.4.1/DESCRIPTION0000644000000000000000000000220412657475772013221 0ustar 00000000000000Name: interval Version: 1.4.1 Date: 2016-02-13 Author: Oliver Heimlich Maintainer: Oliver Heimlich Title: Real-valued interval arithmetic Description: The interval package for real-valued interval arithmetic allows one to evaluate functions over subsets of their domain. All results are verified, because interval computations automatically keep track of any errors. These concepts can be used to handle uncertainties, estimate arithmetic errors and produce reliable results. Also it can be applied to computer-assisted proofs, constraint programming, and verified computing. The implementation is based on interval boundaries represented by binary64 numbers and is conforming to IEEE Std 1788-2015, IEEE standard for interval arithmetic. Problems: Comparison with isequal fails for interval matrices in Octave 4.0.0 (bug #44334, fixed in Octave 4.0.1). 3D plotting is not possible with gnuplot as graphics toolkit (bug #45594). Depends: octave (>= 3.8.0) SystemRequirements: mpfr (>= 3.1.0) [Debian] libmpfr4 (>= 3.1.0) BuildRequires: mpfr (>= 3.1.0) [Debian] libmpfr-dev (>= 3.1.0) License: GPL-3.0+ interval-1.4.1/INDEX0000644000000000000000000000624012657475772012311 0ustar 00000000000000interval >> Real-valued interval arithmetic Interval constant empty entire nai Interval constructor hull midrad @infsup/infsup @infsup/newdec @infsupdec/infsupdec Interval function (most with tightest accuracy) @infsup/abs @infsup/acos @infsup/acosh @infsup/asin @infsup/asinh @infsup/atan @infsup/atan2 @infsup/atanh @infsup/cancelminus @infsup/cancelplus @infsup/cbrt @infsup/ceil @infsup/cos @infsup/cosh @infsup/cot @infsup/coth @infsup/csc @infsup/csch @infsup/dilog @infsup/ei @infsup/erf @infsup/erfc @infsup/exp @infsup/expm1 @infsup/factorial @infsup/fix @infsup/floor @infsup/fma @infsup/gamma @infsup/gammaln @infsup/hypot @infsup/ldivide @infsup/linspace @infsup/log @infsup/log10 @infsup/log1p @infsup/log2 @infsup/max @infsup/min @infsup/minus @infsup/nthroot @infsup/plus @infsup/pow @infsup/pow10 @infsup/pow2 @infsup/power @infsup/pown @infsup/psi @infsup/rdivide @infsup/realsqrt @infsup/round @infsup/roundb @infsup/rsqrt @infsup/sec @infsup/sech @infsup/sign @infsup/sin @infsup/sinh @infsup/tan @infsup/tanh @infsup/times @infsup/uminus @infsup/uplus Interval matrix operation @infsup/det @infsup/dot @infsup/expm @infsup/inv @infsup/lu @infsup/mldivide @infsup/mpower @infsup/mrdivide @infsup/mtimes @infsup/norm @infsup/prod @infsup/sum @infsup/sumabs @infsup/sumsq Interval comparison @infsup/disjoint @infsup/eq @infsup/ge @infsup/gt @infsup/interior @infsup/iscommoninterval @infsup/isempty @infsup/isentire @infsup/ismember @infsup/issingleton @infsup/le @infsup/lt @infsup/ne @infsup/overlap @infsup/precedes @infsup/strictprecedes @infsup/subset @infsupdec/isnai Set operation @infsup/bisect @infsup/intersect @infsup/mince @infsup/nextout @infsup/setdiff @infsup/setxor @infsup/union Interval reverse operation @infsup/absrev @infsup/atan2rev1 @infsup/atan2rev2 @infsup/coshrev @infsup/cosrev @infsup/mulrev @infsup/pownrev @infsup/powrev1 @infsup/powrev2 @infsup/sinrev @infsup/sqrrev @infsup/tanrev Interval numeric function @infsup/hdist @infsup/idist @infsup/inf @infsup/mag @infsup/mid @infsup/mig @infsup/rad @infsup/sdist @infsup/smig @infsup/sup @infsup/wid Interval input and output interval_bitpack exacttointerval @infsup/bitunpack @infsup/disp @infsup/display @infsup/intervaltoexact @infsup/intervaltotext @infsup/plot @infsup/plot3 Interval solver or optimizer @infsup/fminsearch @infsup/fsolve @infsup/fzero @infsup/gauss @infsup/polyval Interval contractor arithmetic ctc_intersect ctc_union Utility function @infsup/cat @infsup/columns @infsup/ctranspose @infsup/diag @infsup/horzcat @infsup/iscolumn @infsup/ismatrix @infsup/isrow @infsup/isscalar @infsup/issquare @infsup/isvector @infsup/length @infsup/meshgrid @infsup/ndims @infsup/numel @infsup/postpad @infsup/prepad @infsup/reshape @infsup/resize @infsup/rows @infsup/size @infsup/subsasgn @infsup/subsref @infsup/transpose @infsup/vertcat @infsupdec/decorationpart @infsupdec/intervalpart API function to the MPFR library mpfr_function_d mpfr_linspace_d mpfr_matrix_mul_d mpfr_matrix_sqr_d mpfr_to_string_d mpfr_vector_sum_d mpfr_vector_dot_d interval-1.4.1/doc/.octaverc0000644000000000000000000000025512657475772014073 0ustar 00000000000000set (0, 'defaultaxesfontname', 'Fantasque Sans Mono'); set (0, 'defaulttextfontname', 'Roboto Condensed'); set (0, 'defaultfigurevisible', 'off'); pkg ('load', 'interval'); interval-1.4.1/doc/CITATION.texinfo0000644000000000000000000000141112657475772015067 0ustar 00000000000000\input texinfo @setfilename CITATION @settitle CITATION file @documentencoding UTF-8 @c This is part of the GNU Octave Interval Package. @c Copyright 2015-2016 Oliver Heimlich. @c See the file COPYING for copying conditions. The interval package is a collection of functions for interval arithmetic. It is developed at Octave Forge, a sibling of the GNU Octave project. To cite this particular version of the interval package in publications use: @display @@software@{octave-interval, author = @{Oliver Heimlich@}, title = @{GNU Octave Interval Package@}, url = @{http://octave.sourceforge.net/interval/@}, version = @{@value{version}@}, date = @{@value{date}@}, @} @end display @noindent See also @command{citation} for citing Octave as a whole. @bye interval-1.4.1/doc/COPYING.texinfo0000644000000000000000000000211112657475772014763 0ustar 00000000000000\input texinfo @setfilename COPYING @settitle COPYING file @documentencoding UTF-8 @c This is part of the GNU Octave Interval Package. @c Copyright 2015-2016 Oliver Heimlich. The interval package is free software and can be used under the terms of the GNU General Public License Version 3 (or at your option any later version). The wording of the license can be found below. The interval package contains derivative work, which is based on other free software released under various licenses. Original authors are properly attributed in the manual and copyright statements have been retained in the particular source files. For simplicity, any derivative work has been relicensed in this package. Thus, the GPLv3+ is the only effective license for the software in this package. For legal reasons a copy of the Apache License 2.0 is included in this package. You can find the license in the file @code{doc/license/apache-2.0.texi}. However, that license does not apply to the software in this package. @sp 5 @center The GNU General Public License. @include license/gpl-3.0.texi @bye interval-1.4.1/doc/Makefile0000644000000000000000000000253312657475772013725 0ustar 00000000000000## This is part of the GNU Octave Interval Package. ## Copyright 2015-2016 Oliver Heimlich. ## See the file COPYING for copying conditions. SHELL = /bin/sh M_IMAGE = $(wildcard image/*.m) $(patsubst %.m.texinfo,%.m,$(wildcard image/*.m.texinfo)) IMAGE_OBJ = $(patsubst %,%.png,$(M_IMAGE)) OBJ = manual.html manual.pdf $(IMAGE_OBJ) MAKEINFO ?= makeinfo VERSION ?= $(shell grep "^Version: " ../packinfo/DESCRIPTION ../DESCRIPTION | head -1 | cut -f2 -d" ") OCTAVE ?= octave .PHONY: all clean images all: $(OBJ) images: $(IMAGE_OBJ) manual.html: manual.texinfo $(wildcard chapter/*) license/gpl-3.0.texi $(wildcard image/*.texinfo) $(IMAGE_OBJ) $(MAKEINFO) -D 'version $(VERSION)' --html --no-split --css-include manual.css "$<" manual.pdf: manual.texinfo $(wildcard chapter/*) license/gpl-3.0.texi $(wildcard image/*.texinfo) $(wildcard image/*.pdf) $(IMAGE_OBJ) $(MAKEINFO) --Xopt=--texinfo='@set version $(VERSION)' --pdf "$<" image/%.m.png: image/%.m $(OCTAVE) \ --no-gui --silent --no-history \ --eval "source ('$<');" \ --eval "__print_mesa__ (gcf, '$@');" @# The image size is too large for inclusion in the pdf, @# thus we increase the resolution from 150 to 250 dpi. convert -density 98.425 -units PixelsPerCentimeter "$@" "$@" image/%.m: image/%.m.texinfo $(MAKEINFO) -D m-file --plaintext "$<" > "$@" clean: rm $(OBJ) interval-1.4.1/doc/NEWS.texinfo0000644000000000000000000003147012657475772014441 0ustar 00000000000000\input texinfo @setfilename NEWS @settitle NEWS file @documentencoding UTF-8 @c This is part of the GNU Octave Interval Package. @c Copyright 2015-2016 Oliver Heimlich. @c See the file COPYING for copying conditions. @macro release{version, date} @heading Version \version\ \date\ @end macro @center GNU Octave Interval Package @center Summary of important user-visible changes @release{1.4.1, 2016-02-13} @itemize @item Fixed a compile error for 32-bit systems during package installation (bug #47100) @end itemize @release{1.4.0, 2016-02-09} @itemize @item mpower: Improved accuracy and speed. The interval matrix square can now be computed without dependency errors and with tightest accuracy. @item factorial: New interval arithmetic operation @item expm, norm: New interval matrix operations @item The functions recip and sqr have been deprecated and will be removed in a future release. Please use @code{1 ./ @var{x}} and @code{@var{x} .^ 2} instead. @end itemize @noindent Bugfixes @itemize @item bitunpack, interval_bitpack: The order of inf/sup/dec parts has been fixed. The function documentation describes how the functions behave on little-endian and big-endian systems. @end itemize @release{1.3.0, 2015-12-22} @itemize @item postpad, prepad, subsasgn: Implicit new elements during subscript assignment and padding have been initialized with empty intervals before this release. This behavior has changed. Now, the implicit new element are initialized with zero to make a correct interval extension of the corresponding built-in function. @item fsolve: New function to solve (systems of) equations and compute the inverse of a set under a function @item ctc_intersect, ctc_union: Utility functions for contractors and the fsolve function @item det, prod, recip: New interval arithmetic functions @item diag: New utility function to create diagonal matrices or extract vectors from diagonals of matrices @item decorationpart: Choose between different return types with a second parameter @item For several functions it is now possible to broadcast row vectors against column vectors or vectors against matrices. @item The user manual has been restructured for better accessibility by new users. A bunch of usage examples demonstrates the package's capabilities. @end itemize @noindent Bugfixes @itemize @item sum, sumabs, sumsq: Fixed result for matrices of size zero @item powrev1, powrev2: Fixed indexing for vectors @end itemize @release{1.2.0, 2015-10-01} @itemize @item The output format for intervals has been changed. The number of decimal places now respects what has been set by the user with the @command{format short} or @command{format long} command, and is much shorter by default. Also it is possible to use @command{format hex}. The old format can be accessed with the @command{intervaltotext} function. @item fminsearch: New optimizer function for finding the minimum value of a function over interval constraints using the Skelboe-Moore algorithm @item fzero: Changed function parameters to support optimset options @item power: Improved speed of the general interval power function and monomials with the notation x .^ n @item plot, plot3: Added support for colormaps @end itemize @noindent Bugfixes @itemize @item mldivide: Fixed algorithm to handle more matrices without error @item bisect: Fixed an error during bisection of singleton intervals (thanks to Helmut for finding this during OctConf 2015) @end itemize @release{1.1.0, 2015-08-03} @itemize @item meshgrid, mince: New utility functions to help plotting of interval functions @item linspace: New interval arithmetic function @item intersect, max, min, union: Allow evaluation as aggregate functions within an interval matrix along a common dimension @item Improvements to the documentation @itemize @item Added cross-references between package documentation and function reference @item Extended information about interval arithmetic in general @item Extended information about implemented IEEE Std 1788-2015 functions and fixed references to the standard document @item Added information about plotting intervals @item Simplified package description @item Graphics with higher resolutions, demo of interval sombrero function plot on first page, and minor style fixes @end itemize @end itemize @noindent Bugfixes @itemize @item plot3: Fixed plotting of interval edges when plotting several intervals at once using matrices @end itemize @release{1.0.0, 2015-06-13} @itemize @item IEEE Std 1788-2015, IEEE standard for interval arithmetic, was approved on June 11. To mark the occasion, the major version number has been raised. @item All interval constructors have been extended to create interval matrices from a single string. Commas or spaces may be used as a column separator (consecutive separators are trimmed). Semicolon and new line characters can be used as a row separator. @item hdist, idist, sdist, smig: New interval numeric functions @item User manual: Relicensed under GPL, added examples from the former Octave SIMP package, and various minor improvements. @end itemize @noindent Bugfixes @itemize @item mtimes: Fixed matrix-vector multiplication of decorated intervals @item Fixed a linking error in mkoctfile that could prevent package installation (bug #45280) @end itemize @release{0.2.1, 2015-05-30} @itemize @item plot, plot3: New interval plotting functions. Pay attention to the included examples, which can be executed with @code{demo @@infsup/plot} and @code{demo @@infsup/plot3} respectively. @item polyval: New interval arithmetic algorithm @item bisect: New set operation for bisecting algorithms @item sinrev, cosrev, tanrev, atan2rev1, atan2rev2: Now allow non-scalar arguments @item Simplified licensing: Relicensed parts of the software that were not under GPL @item Updated information for citation of the package @end itemize @noindent Bugfixes @itemize @item Fixed generation of the manual in PDF format @item subsasgn: Fixed cases where decoration could be lost (bug #42735) @end itemize @release{0.2.0, 2015-05-03} @itemize @item User manual included in the package, see doc/manual.texinfo @item New utility functions: cat, postpad, prepad, reshape, resize @item and, or: Removed deprecated functions @item Improved display output for cell arrays and new function: disp @item Minor performance improvements (all decorated interval functions, horzcat, vertcat) @end itemize @noindent Bugfixes @itemize @item issquare, isrow, iscolumn: Fixed compatibility issues with GNU Octave 4.0 @item cbrt: Allow negative values as parameter @item cot: Fixed accuracy for x = 0 @item cos, csc, sec, sin: Fixed correctness in certain cases @item Prevent multibyte characters in Microsoft Windows console @end itemize @release{0.1.5, 2015-04-06} @itemize @item Implicit decoration of bare intervals triggers a warning now and can be allowed or forbidden by the user. Implicit decoration of bare interval literals is not affected. @item newdec: New operation for explicit promotion of bare intervals into decorated intervals (without warning). @item Decorated interval literals with illegal decoration are no longer allowed and produce NaIs. @item hull: In contrast to the union function, the interval constructor is no longer considered a set operation and can create intervals with a non-trivial decoration. @item setdiff, setxor: New set operations @item intersect, union: Renamed set operations; the old function names (and, or) are hereby deprecated and are going to be removed in the next release. @item intervaltotext, intervaltoexact: Decimal fractions no longer omit zero before the point, and unnecessary trailing decimal places can be omitted more consistently and in more cases than before (also affects console output). Improved accuracy and performance with support for interval matrices. @end itemize @noindent Bugfixes @itemize @item mtimes, mldivide: Support for broadcasting of scalar parameters @item nextout: Support for decorated intervals @item An error in GNU Octave core, which could lead to lost or wrong interval decorations, no longer affects decorated intervals (bug #42735) @item Some errors in the function documentation have been fixed (thanks to doctest-for-matlab and Colin's texinfo compatibility patches) @item Fixed interval field access on Windows @end itemize @release{0.1.4, 2015-03-15} @itemize @item New interval constructors: hull, midrad @item New interval arithmetic functions: cbrt, cot, coth, csc, csch, dilog, ei, erf, erfc, gamma, gammaln, psi, rsqrt, sec, sech @item mtimes: Support for fast, less accurate evaluation using BLAS routines @item mldivide, mrdivide, inv: Improved performance by using faster mtimes @item infsup, infsupdec: Enabled broadcasting of scalar boundaries @item rad: May compute mid and rad simultaneously @item subsref: Access to interval properties using field syntax: x.inf and x.sup @end itemize @release{0.1.3, 2015-02-24} @itemize @item Fixed a compile error that could possibly occur during package installation @end itemize @release{0.1.2, 2015-02-22} @itemize @item New interval arithmetic functions: nthroot, hypot, log1p, expm1 @item lu: New operation for LU(P) decomposition of interval matrices @item nai: New decorated interval constant @item mldivide, mrdivide, inv: Greatly improved accuracy and performance of the linear solver @item Improved accuracy of vector sums, dot products, pownrev, and powrev2 @item powrev1, powrev2, pownrev, mulrev: Now allow non-scalar arguments @item overlap: Renamed one overlapping state from equal to equals @item mulrevtopair: No longer available, use mulrev with two output parameters for two-output division @item setdec: No longer available, use infsupdec instead @item Small performance improvements @end itemize @noindent Bugfixes @itemize @item Compatibility with GNU Octave 4.0 (bug #43925) @item Build problems during package installation with environment variables @item iscommoninterval: The decorated variant must return true for common intervals without com decoration @item eq: The decorated variant must not consider the decoration value @item Several decorated functions: When evaluated on a subset of the function's domain, the result's decoration must be dac if the function's restriction to that subset is continuous @item Decorated boolean functions: Must return false when evaluated on NaI input @item Interval constructors: A PossibleUndefined warning must be issued if an interval is created from two very close decimal numbers (which can not be separated in the floating-point context) where the lower boundary is greater than the upper boundary when compared with infinite precision @item Interval constructors: NaNs must produce empty intervals @item Decorated interval constructor: Illegal decorations for empty intervals must be adjusted to trv, and illegal decoration com for unbounded intervals must be adjusted to dac. @item cancelminus/cancelplus: The functions returned wrong results if the interval widths could not be compared in double-precision @item cos: Accuracy for x = [0] improved @item pow, powrev1, powrev2: The function must be defined for x = 0 and y > 0 @item All reverse operations: Must return a trivial decoration information at best (the only exception is mulrev) @end itemize @release{0.1.1, 2015-02-01} @itemize @item Increased speed of computation for large matrices @item Improved performance for fma and dot @item mpfr_vector_dot_d: Changed syntax for faster computation on intervals @item Decorated versions of mtimes, mldivide, mpower, inv and reduction operations sum, dot, subabs, subsquare @item Renamed function sumsquare to sumsq in accordance with GNU Octave function names @item New function: fzero for finding all roots of an interval arithmetic function @end itemize @noindent Bugfixes @itemize @item nextout: Function returned wrong results @item exacttointerval: Now produces bare intervals instead of decorated intervals in conformance with IEEE P1788 @item atanh: Function returned wrong results for ±1 @item dot: Function returned wrong results for some inputs @item fma: Function returned wrong results for some inputs @item infsup: Function returned wrong interval boundaries for decimal numbers, function failed on mixed numerical and string boundaries in single cell array parameter @item mulrevtopair: Fixed order of operands in conformance with IEEE P1788 and wrong results when evaluated on intervals that contain zero @end itemize @release{0.1.0, 2015-01-21} @itemize @item Initial release version, which already contains all required operations of the preliminary standard document IEEE P1788. @end itemize @bye interval-1.4.1/doc/chapter/advanced-topics.texinfo0000644000000000000000000002534312657475772020361 0ustar 00000000000000@c This is part of the GNU Octave Interval Package Manual. @c Copyright 2015-2016 Oliver Heimlich. @c See the file manual.texinfo for copying conditions. @documentencoding UTF-8 @chapter Advanced Topics @section Error Handling Due to the nature of set-based interval arithmetic, one should not observe errors (in the sense of raised GNU Octave error messages) during computation unless operations are evaluated for incompatible data types. Arithmetic operations which are not defined for (parts of) their input, simply ignore anything that is outside of their domain. However, the interval constructors can produce errors depending on the input. The @funref{@@infsup/infsup} constructor will fail if the interval boundaries are invalid. Contrariwise, the (preferred) @funref{@@infsupdec/infsupdec}, @funref{midrad} and @funref{hull} constructors will only issue a warning and return a [NaI] object, which will propagate and survive through computations. NaI stands for “not an interval”. Effects of set-based interval arithmetic on partial functions and the NaI object @example @group ## Evaluation of a function outside of its domain ## returns an empty interval infsupdec (2) / 0 @result{} ans = [Empty]_trv infsupdec (0) ^ infsupdec (0) @result{} ans = [Empty]_trv @end group @end example @example @group ## Illegal interval construction creates a NaI infsupdec (3, 2) @print{} warning: illegal interval boundaries: @print{} infimum greater than supremum @result{} ans = [NaI] @end group @end example @example @group ## NaI even survives through computations ans + 1 @result{} ans = [NaI] @end group @end example There are some situations where the interval package cannot decide whether an error occurred or not and issues a warning. The user may choose to ignore these warnings or handle them as errors, see @command{help warning} for instructions. @float Table,tab:warnings @caption{Warning IDs} @table @option @item interval:PossiblyUndefined @table @asis @item Reason Interval construction with boundaries in decimal format, and the constructor can't decide whether the lower boundary is smaller than the upper boundary. Both boundaries are very close and lie between subsequent binary64 numbers. @item Possible consequences The constructed interval is a valid and tight enclosure of both numbers. If the lower boundary was actually greater than the upper boundary, this illegal interval is not considered an error. @end table @item interval:ImplicitPromote @table @asis @item Reason An interval operation has been evaluated on both, a bare and a decorated interval. The bare interval has been converted into a decorated interval in order to produce a decorated result. Note: This warning does not occur if a bare interval literal string gets promoted into a decorated interval, e. g., @code{infsupdec (1, 2) + "[3, 4]"} does not produce this warning whereas @code{infsupdec (1, 2) + infsup (3, 4)} does. A bare interval can be explicitly promoted with the @funref{@@infsup/newdec} function. @item Possible consequences The implicit conversion applies the best possible decoration for the bare interval. If the bare interval has been produced from an interval arithmetic computation, this branch of computation is not covered by the decoration information and the final decoration could be considered wrong. For example, @code{infsupdec (1, 2) + infsup (0, 1) ^ 0} would ignore that 0^0 is undefined. @end table @item interval:NaI @table @asis @item Reason An error has occurred during interval construction and the NaI object has been produced. The warning text contains further details. A NaI can be explicitly created with the @funref{nai} function. @item Possible consequences Nothing bad is going to happen, because the semantics of NaI are well defined by IEEE Std 1788-2015. However, the user might choose to cancel the algorithm immediately when the NaI is encountered for the first time. @end table @end table @end float @section Decorations The interval package provides a powerful decoration system for intervals, as specified by IEEE Std 1788-2015, IEEE standard for interval arithmetic. By default any interval carries a decoration, which collects additional information about the course of function evaluation on the interval data. Only the (unfavored) @funref{@@infsup/infsup} constructor creates bare, undecorated intervals and the @funref{@@infsupdec/intervalpart} operation may be used to demote decorated intervals into bare, undecorated ones. It is highly recommended to always use the decorated interval arithmetic, which gives additional information about an interval result in exchange for a tiny overhead. The following decorations are available: @float @multitable {Decoration ABC} {Bounded} {Continuous} {Defined} {Definition Definition Definition} @headitem Decoration @tab Bounded @tab Continuous @tab Defined @tab Definition @item com (common) @tab ✓ @tab ✓ @tab ✓ @tab x is a bounded, nonempty subset of Dom(f); f is continuous at each point of x; and the computed interval f(x) is bounded @item dac (defined and continuous) @tab @tab ✓ @tab ✓ @tab x is a nonempty subset of Dom(f); and the restriction of f to x is continuous @item def (defined) @tab @tab @tab ✓ @tab x is a nonempty subset of Dom(f) @item trv (trivial) @tab @tab @tab @tab always true@*(so gives no information) @item ill (ill-formed) @tab @tab @tab @tab Not an interval, at least one interval constructor failed during the course of computation @end multitable @end float The decoration information is especially useful after a very long and complicated function evaluation. For example, when the “def” decoration survives until the final result, it is proven that the overall function is actually defined for all values covered by the input intervals. Examples of using the decoration system @example @group x = infsupdec (3, 4) @result{} x = [3, 4]_com y = x - 3.5 @result{} y = [-0.5, +0.5]_com @end group @end example @example @group ## The square root function ignores any negative part of the input, ## but the decoration indicates whether this has or has not happened. sqrt (x) @result{} ans ⊂ [1.732, 2]_com sqrt (y) @result{} ans ⊂ [0, 0.70711]_trv @end group @end example Please note that decoration information will not survive through reverse operations (see below) and set operations. @section Specialized interval constructors Above mentioned interval construction with decimal numbers or numeric data is straightforward. Beyond that, there are more ways to define intervals or interval boundaries. @itemize @item Hexadecimal-floating-constant form: Each interval boundary may be defined by a hexadecimal number (optionally containing a point) and an exponent field with an integral power of two as defined by the C99 standard @uref{http://www.open-std.org/jtc1/sc22/WG14/www/docs/n1256.pdf,@asis{ISO/IEC9899, N1256, §6.4.4.2}}. This can be used as a convenient way to define interval boundaries in binary64 precision, because the hexadecimal form is much shorter than the decimal representation of many numbers. @item Rational literals: Each interval boundary may be defined as a fraction of two decimal numbers. This is especially useful if interval boundaries shall be tightest enclosures of fractions, that would be hard to write down as a decimal number. @item Uncertain form: The interval as a whole can be defined by a midpoint or upper/lower boundary and an integral number of @uref{http://en.wikipedia.org/wiki/Unit_in_the_last_place,“units in last place” (ULPs)} as an uncertainty. The format is @code{m?ruE}, where @table @code @item m is a mantissa in decimal, @item r is either empty (which means ½ ULP) or is a non-negative decimal integral ULP count or is the @option{?} character (for unbounded intervals), @item u is either empty (symmetrical uncertainty of r ULPs in both directions) or is either @option{u} (up) or @option{d} (down), @item E is either empty or an exponent field comprising the character @code{e} followed by a decimal integer exponent (base 10). @end table @end itemize Examples of different formats during interval construction @example @group infsupdec ("0x1.999999999999Ap-4") # hex-form @result{} ans ⊂ [0.1, 0.10001]_com @end group @end example @example @group infsupdec ("1/3", "7/9") # rational form @result{} ans ⊂ [0.33333, 0.77778]_com @end group @end example @example @group infsupdec ("121.2?") # uncertain form @result{} ans ⊂ [121.14, 121.25]_com @end group @end example @example @group infsupdec ("5?32e2") # uncertain form with ulp count @result{} ans = [-2700, +3700]_com @end group @end example @example @group infsupdec ("-42??u") # unbound uncertain form @result{} ans = [-42, +Inf]_dac @end group @end example The hex-form can be set for output with the @command{format hex} command. @section Reverse Arithmetic Operations Some arithmetic functions also provide reverse mode operations. That is inverse functions with interval constraints. For example the @funref{@@infsup/sqrrev} function can compute the inverse of the @code{@var{x} .^ 2} function on intervals. The syntax is @code{sqrrev (@var{C}, @var{X})} and will compute the enclosure of all numbers x ∈ @var{X} that fulfill the constraint x² ∈ @var{C}. In the following example, we compute the constraints for base and exponent of the power function pow as shown in the figure. @float Figure,reverse @caption{Reverse power operations. A relevant subset of the function's domain is outlined and hatched. In this example we use x^y ∈ [2, 3].} @shortcaption{Reverse power operations} @myimage{image/inverse-power.svg,Reverse Power Functions} @end float @example @group x = powrev1 (infsupdec ("[1.1, 1.45]"), infsupdec (2, 3)) @result{} x ⊂ [1.6128, 2.7149]_trv y = powrev2 (infsupdec ("[2.14, 2.5]"), infsupdec (2, 3)) @result{} y ⊂ [0.75647, 1.4441]_trv @end group @end example @section Tips and Tricks For convenience it is possible to implicitly call the interval constructor during all interval operations if at least one input already is an interval object. @example @group infsupdec ("17.7") + 1 @result{} ans ⊂ [18.699, 18.701]_com ans + "[0, 2]" @result{} ans ⊂ [18.699, 20.701]_com @end group @end example Interval functions with only one argument can be called by using property syntax, e. g. @code{x.inf}, @code{x.sup} or even @code{x.sqrt}. Whilst most functions (@funref{@@infsup/size}, @funref{@@infsup/isvector}, @funref{@@infsup/ismatrix}, …) work as expected on interval data types, the function @funref{@@infsup/isempty} is evaluated element-wise and checks if an interval equals the empty set. @example @group builtin ("isempty", empty ()) @result{} ans = 0 isempty (empty ()) @result{} ans = 1 @end group @end example interval-1.4.1/doc/chapter/examples.texinfo0000644000000000000000000003065112657475772017131 0ustar 00000000000000@c This is part of the GNU Octave Interval Package Manual. @c Copyright 2015-2016 Oliver Heimlich. @c See the file manual.texinfo for copying conditions. @documentencoding UTF-8 @chapter Examples This chapter presents some more or less exotic use cases for the interval package. @section Floating-point Numbers Floating-point numbers are most commonly used in binary64 format, a.k.a. double precision. Internally they are stored in the form @code{± @var{m} * 2 ^ @var{e}} with some integral mantissa @var{m} and exponent @var{e}. Most decimal fractions can only be stored approximately in this format. The @funref{@@infsup/intervaltotext} function can be used to output the approximate value up to the last decimal digit. @example @group intervaltotext (infsup (0.1), "exact decimal") @result{} ans = [0.1000000000000000055511151231257827021181583404541015625] @end group @end example It can be seen that 0.1 is converted into the most accurate floating-point number. In this case that value is greater than 0.1. The next lower value can be seen after producing an interval enclosure around 0.1 with the nearest floating-point numbers in each direction. @example @group intervaltotext (infsup ("0.1"), "exact decimal") @result{} ans = [0.09999999999999999167332731531132594682276248931884765625, 0.1000000000000000055511151231257827021181583404541015625] @end group @end example The error of this approximation can be examined with the @funref{@@infsup/wid} function. @example @group wid (infsup ("0.1")) @result{} ans = 1.3878e-17 @end group @end example With the @funref{@@infsup/nextout} function an interval can be enlarged in each direction up to the next floating-point number. Around zero the distance towards the next floating point number is very small, but gets bigger for numbers of higher magnitude. @example @group wid (nextout (infsup ([0, 1, 1e10, 1e100]))) @result{} ans = 9.8813e-324 3.3307e-16 3.8147e-06 3.8853e+84 @end group @end example @section Arithmetic with System-independent Accuracy According to IEEE Std 754 only the most basic floating-point operations must be provided with high accuracy. This is also true for the arithmetic functions in Octave. It is no surprise that many arithmetic functions fail to provide perfect results and their output may be system dependent. We compute the cosecant for 100 different values. @example @group x = vec (1 ./ magic (10)); sum (subset (csc (x), csc (infsupdec (x)))) @result{} ans = 98 @end group @end example Due to the general containment rule of interval arithmetic @code{x ∈ X ⇒ f (x) ∈ f (X)} one would expect the @code{csc (x)} to always be contained in the interval version of the cosecant for the same input. However, the classic cosecant is not very accurate whereas the interval version is. In 2 out 100 cases the built-in cosecant is less accurate than 1 ULP. @section Prove the Existence of a Fixed Point A weaker formulation of Brower's fixed-point theorem goes: If @var{x} is a bounded interval and function @var{f} is continuous and @var{f} (@var{x}) ⊂ @var{x}, then there exists a point @var{x}₀ ∈ @var{x} such that @var{f} (@var{x}₀) = @var{x}₀. These properties can be tested automatically. Decorated intervals can even prove that the function is continuous. @example @group x = infsupdec ("[-1, +1]"); f = @@cos; subset (f (x), x) @result{} ans = 1 iscommoninterval (x) @result{} ans = 1 continuous = strcmp (decorationpart (f (x)), "com") @result{} continuous = 1 @end group @end example Furthermore it is sometimes possible to approximate the fixed-point by repetitive evaluation of the function, although there are better methods to do so in general. @example @group for i = 1 : 20 x = f (x); endfor display (x) @result{} x ⊂ [0.73893, 0.73919]_com @end group @end example @section Root Finding @subsection Interval Newton Method In numerical analysis, @uref{https://en.wikipedia.org/wiki/Newton%27s_method,Newton's method} can find an approximation to a root of a function. Starting at a location @var{x}₀ the algorithms executes the following step to produce a better approximation: @display @var{x}₁ = @var{x}₀ @minus{} @var{f} (@var{x}₀) / @var{f}' (@var{x}₀) @end display The step can be interpreted geometrically as an intersection of the graph's tangent with the x-axis. Eventually, this may converge to a single root. In interval analysis, we start with an interval @var{x}₀ and utilize the following interval Newton step: @display @var{x}₁ = (mid (@var{x}₀) @minus{} @var{f} (mid (@var{x}₀)) / @var{f}' (@var{x}₀)) ∩ @var{x}₀ @end display Here we use the pivot element @code{mid (@var{x}₀)} and produce an enclosure of all possible tangents with the x-axis. In special cases the division with @code{@var{f}' (@var{x}₀)} yields two intervals and the algorithm bisects the search range. Eventually this algorithm produces enclosures for all possible roots of the function @var{f}. The interval newton method is implemented by the function @funref{@@infsup/fzero}. To produce the derivative of function @var{f}, the automatic differentiation from the symbolic package bears a helping hand. However, be careful since this may introduce numeric errors with coefficients. @example @group f = @@(x) sqrt (x) + (x + 1) .* cos (x); @end group @group pkg load symbolic df = function_handle (diff (formula (f (sym ("x"))))) @result{} df = @@(x) -(x + 1) .* sin (x) + cos (x) + 1 ./ (2 .* sqrt (x)) @end group @group fzero (f, infsup ("[0, 6]"), df) @result{} ans ⊂ 2×1 interval vector [2.059, 2.0591] [4.3107, 4.3108] @end group @end example We could find two roots in the interval [0, 6]. @subsection Bisection Consider the function @code{f (@var{x}, @var{y}) = -(5*@var{y} - 20*@var{y}^3 + 16*@var{y}^5)^6 + (-(5*@var{x} - 20*@var{x}^3 + 16*@var{x}^5)^3 + 5*@var{y} - 20*@var{y}^3 + 16*@var{y}^5)^2}, which has several roots in the area @var{x}, @var{y} ∈ [-1, 1]. @myimage{image/poly-example-surf.m,Surface plot of @code{f (@var{x}, @var{y})} which shows a lot of roots for the function} The function is particular difficult to compute with intervals, because its variables appear several times in the expression, which benefits overestimation from the dependency problem. Computing root enclosures with the @funref{@@infsup/fsolve} function is unfeasible, because many bisections would be necessary until the algorithm terminates with a useful result. It is possible to reduce the overestimation with the @funref{@@infsup/polyval} function to some degree, but since this function is quite costly to compute, it does not speed up the bisecting algorithm. @include image/poly-example-roots-simple.m.texinfo @myimage{image/poly-example-roots-simple.m,Enclosures of roots for the function @code{f (@var{x}, @var{y})}} Now we use the same algorithm with the same number of iterations, but also utilize the @emph{mean value theorem} to produce better enclosures of the function value with first order approximation of the function. The function is evaluated at the interval's midpoint and a range evaluation of the derivative can be used to produce an enclosure of possible function values. @include image/poly-example-roots-with-deriv.m.texinfo By using the derivative, it is possible to reduce overestimation errors and achieve a much better convergence behavior. @myimage{image/poly-example-roots-with-deriv.m,Enclosures of roots for the function @code{f (@var{x}, @var{y})}} @section Parameter Estimation @subsection Small Search Space Consider the model @code{y (@var{t}) = @var{p1} * exp (@var{p2} * t)}. The parameters @var{p1} and @var{p2} are unknown, but it is known that the model fulfills the following constraints, which have been obtained using measurements with known error bounds. @display @verbatim p1, p2 ∈ [-3, 3] y (0.2) ∈ [1.5, 2] y (1) ∈ [0.7, 0.8] y (2) ∈ [0.1, 0.3] y (4) ∈ [-0.1, 0.03] @end verbatim @end display A better enclosure of the parameters @var{p1} and @var{p2} can be estimated with the @funref{@@infsup/fsolve} function. @example @group ## Model y = @@(p1, p2, t) p1 .* exp (p2 .* t); ## Observations / Constraints t = [0.2; 1; 2; 4]; y_t = infsup ("[1.5, 2]; [0.7, 0.8]; [0.1, 0.3]; [-0.1, 0.03]"); ## Estimate parameters f = @@(p1, p2) y (p1, p2, t); p = fsolve (f, infsup ("[-3, 3]; [-3, 3]"), y_t) @result{} p ⊂ 2×1 interval vector [1.9863, 2.6075] [-1.3243, -1.0429] @end group @end example The resulting @code{p} guarantees to contain all parameters @code{[@var{p1}; @var{p2}]} which satisfy all constraints on @var{y}. It is no surprise that @code{f (p)} intersects the constraints for @var{y}. @example @group f (p(1), p(2)) @result{} ans ⊂ 4×1 interval vector [1.5241, 2.1166] [0.52838, 0.91888] [0.14055, 0.32382] [0.0099459, 0.040216] @end group @end example @subsection Larger Search Space Consider the function @code{f (x) = @var{p1} ^ x * (@var{p2} + @var{p3} * x + @var{p4} * x^2)}. Let's say we have some known function values (measurements) and want to find matching parameters @var{p1} through @var{p4}. The data sets (@var{x}, @var{y}) can be simulated. The parameters shall be reconstructed from the observed values on the search range @var{p}. Using plain @funref{@@infsup/fsolve} would take considerably longer, because the search range has 4 dimensions. Bisecting intervals requires an exponential number of steps and can easily become inefficient. Thus we use a contractor for function @var{f}, which in addition to the function value can produce a refinement for its parameter constraints. Contractors can easily be build using interval reverse operations like @funref{@@infsup/mulrev}, @funref{@@infsup/sqrrev}, @funref{@@infsup/powrev1}, etc. @example @group ## Simulate some data sets and add uncertainty x = -6 : 3 : 18; f = @@(p1, p2, p3, p4) ... p1 .^ x .* (p2 + p3 .* x + p4 .* x .^ 2); y = f (1.5, 1, -3, 0.5) .* infsup ("[0.999, 1.001]"); @end group @group function [fval, p1, p2, p3, p4] = ... contractor (y, p1, p2, p3, p4) x = -6 : 3 : 18; ## Forward evaluation a = p1 .^ x; b = p3 .* x; c = p2 + b; d = p4 .* x .^ 2; e = c + d; fval = a .* e; ## Reverse evaluation and ## undo broadcasting of x y = intersect (y, fval); a = mulrev (e, y, a); e = mulrev (a, y, e); p1 = powrev1 (x, a, p1); p1 = intersect (p1, [], 2); c = intersect (c, e - d); d = intersect (d, e - c); p2 = intersect (p2, c - b); p2 = intersect (p2, [], 2); b = intersect (b, c - p2); p3 = mulrev (x, b, p3); p3 = intersect (p3, [], 2); p4 = mulrev (x .^ 2, d, p4); p4 = intersect (p4, [], 2); endfunction @end group @end example Now, search for solutions in the range of @code{p} and try to restore the function parameters. @example @group p = infsup ("[1.1, 2] [1, 5] [-5, -1] [0.1, 5]"); p = fsolve (@@contractor, ... p, y, ... struct ("Contract", true))' @result{} p ⊂ 4×1 interval vector [1.4991, 1.5009] [1, 1.0011] [-3.0117, -2.9915] [0.49772, 0.50578] @end group @end example The function parameters 1.5, 1, @minus{}3, and 0.5 from above could be restored. The contractor function could significantly improve the convergence speed of the algorithm. @subsection Combination of Functions Sometimes it is hard to express the search range in terms of a single function and its constraints, when the preimage of the function consists of a union or intersection of different parts. Several contractor functions can be combined using @funref{ctc_union} or @funref{ctc_intersect} to make a contractor function for more complicated sets. The combined contractor function allows one to solve for more complicated sets in a single step. @include image/contractor-rings-union.m.texinfo @myimage{image/contractor-rings-union.m,Set inversion for two rings} Intersections of contractor functions are especially useful to apply several constraints at once. For example, when it is known that a particular location has a distance of @var{a} ∈ [3, 4] from object A, located at coordinates (1, 3), and a distance of @var{b} ∈ [5, 6] from object B, located at coordinates (2, -1), the intersection of both rings yields all possible locations in the search range. The combined contractor function enables fast convergence of the search algorithm. @include image/contractor-rings-intersect.m.texinfo @myimage{image/contractor-rings-intersect.m,Set inversion for intersection of two rings} interval-1.4.1/doc/chapter/getting-started.texinfo0000644000000000000000000004420212657475772020415 0ustar 00000000000000@c This is part of the GNU Octave Interval Package Manual. @c Copyright 2015-2016 Oliver Heimlich. @c See the file manual.texinfo for copying conditions. @documentencoding UTF-8 @chapter Getting Started This chapter takes you by the hand and gives a quick overview on the interval packages basic capabilities. More detailed information can usually be found in the functions' documentation. @section Installation Unless the package is provided by a third-party distributor, the interval package can be installed with the @command{pkg} command from within Octave. Latest release versions are published at Octave Forge and can be automatically downloaded with the @option{-forge} option. @example @c doctest: +SKIP @group pkg install -forge interval   @print{} For information about changes from previous versions   @print{} of the interval package, run 'news interval'. @end group @end example During this kind of installation parts of the interval package are compiled for the target system, which requires development libraries for GNU Octave (version ≥ 3.8.0) and GNU MPFR (version ≥ 3.1.0) to be installed. The official Octave release for Microsoft Windows already includes these dependencies. For other systems it might be necessary to install packages “liboctave-dev” and “libmpfr-dev”, which are provided by most GNU distributions (names may vary). In order to use the interval package during an Octave session, it must have been loaded, i. e., added to the path. In the following parts of the manual it is assumed that the package has been loaded, which can be accomplished with the @command{pkg load interval} command. Automatic loading of the interval package can be activated with the @command{pkg rebuild -auto interval} command and is recommended for regular use. That's it. After only two commands the package is ready to be used within Octave. @section Set-based Interval Arithmetic The most important and fundamental concepts in the context of the interval package are: @itemize @item Intervals are closed, connected subsets of the real numbers. Intervals may be unbound (in either or both directions) or empty. In special cases @code{+inf} and @code{-inf} are used to denote boundaries of unbound intervals, but any member of the interval is a @emph{finite} real number. @item Classical functions are extended to interval functions as follows: The result of function @var{f} evaluated on interval @var{x} is an interval enclosure of all possible values of @var{f} over @var{x} where the function is defined. Most interval arithmetic functions in this package manage to produce a very accurate such enclosure. @item The result of an interval arithmetic function is an interval in general. It might happen, that the mathematical range of a function consist of several intervals, but their union will be returned, e. g., 1 / [-1, 1] = [Entire]. @end itemize More details can be found in @ref{Introduction to Interval Arithmetic}. @section Input and Output Before exercising interval arithmetic, interval objects must be created from non-interval data. There are interval constants @funref{empty} and @funref{entire} and the interval constructors @funref{@@infsupdec/infsupdec} (create an interval from boundaries), @funref{midrad} (create an interval from midpoint and radius) and @funref{hull} (create an interval enclosure for a list of mixed arguments: numbers, intervals or interval literals). The constructors are very sophisticated and can be used with several kinds of parameters: Interval boundaries can be given by numeric values or string values with decimal numbers. Create intervals for performing interval arithmetic @example @group ## Interval with a single number infsupdec (1) @result{} ans = [1]_com @end group @end example @example @group ## Interval defined by lower and upper bound infsupdec (1, 2) @result{} ans = [1, 2]_com @end group @end example @example @group ## Boundaries are converted from strings infsupdec ("3", "4") @result{} ans = [3, 4]_com @end group @end example @example @group ## Decimal number infsupdec ("1.1") @result{} ans ⊂ [1.0999, 1.1001]_com @end group @end example @example @group ## Decimal number with scientific notation infsupdec ("5.8e-17") @result{} ans ⊂ [5.7999e-17, 5.8001e-17]_com @end group @end example @example @group ## Interval around 12 with uncertainty of 3 midrad (12, 3) @result{} ans = [9, 15]_com @end group @end example @example @group ## Again with decimal numbers midrad ("4.2", "1e-3") @result{} ans ⊂ [4.1989, 4.2011]_com @end group @end example @example @group ## Interval members with arbitrary order hull (3, 42, "19.3", "-2.3") @result{} ans ⊂ [-2.3001, +42]_com @end group @end example @example @group ## Symbolic numbers hull ("pi", "e") @result{} ans ⊂ [2.7182, 3.1416]_com @end group @end example @strong{Warning:} In above examples decimal fractions are passed as a string to the constructor. Otherwise it is possible, that GNU Octave introduces conversion errors when the numeric literal is converted into a floating-point number @emph{before} it is passed to the constructor. The interval construction is a critical process, but after this the interval package takes care of any further conversion errors, representational errors, round-off errors and inaccurate numeric functions. Beware of the conversion pitfall @example @group ## The numeric constant 0.3 is an approximation of the ## decimal number 0.3. An interval around this approximation ## will not contain the decimal number 0.3. output_precision (17) infsupdec (0.3) @result{} ans ⊂ [0.29999999999999998, 0.29999999999999999]_com @end group @end example @example @group ## However, passing the decimal number 0.3 as a string ## to the interval constructor will create an interval which ## actually encloses the decimal number. format short infsupdec ("0.3") @result{} ans ⊂ [0.29999, 0.30001]_com @end group @end example For maximum portability it is recommended to use interval literals, which are standardized by IEEE Std 1788-2015. Both interval boundaries are then given as a string in the form @code{[@var{l}, @var{u}]}. The output in the examples above gives examples of several interval literals. @example @group ## Interval literal infsupdec ("[20, 4.2e10]") @result{} ans = [20, 4.2e+10]_com @end group @end example The default text representation of intervals is not guaranteed to be exact, because this would massively spam console output. For example, the exact text representation of @code{realmin} would be over 700 decimal places long! However, the output is correct as it guarantees to contain the actual boundaries: a displayed lower (upper) boundary is always less (greater) than or equal to the actual boundary. @subsection Interval Vectors and Matrices Vectors and matrices of intervals can be created by passing numerical matrices, string or cell arrays to the interval constructors. With cell arrays it is also possible to mix several types of boundaries. Interval matrices behave like normal matrices in GNU Octave and can be used for broadcasting and vectorized function evaluation. Vectorized function evaluation usually is the key to create very fast programs. Create interval matrices @example @group M = infsupdec (magic (3)) @result{} M = 3×3 interval matrix [8]_com [1]_com [6]_com [3]_com [5]_com [7]_com [4]_com [9]_com [2]_com @end group @end example @example @group infsupdec (magic (3), magic (3) + 1) @result{} ans = 3×3 interval matrix [8, 9]_com [1, 2]_com [6, 7]_com [3, 4]_com [5, 6]_com [7, 8]_com [4, 5]_com [9, 10]_com [2, 3]_com @end group @end example @example @group infsupdec ("0.1; 0.2; 0.3; 0.4; 0.5") @result{} ans ⊂ 5×1 interval vector [0.099999, 0.10001]_com [0.19999, 0.20001]_com [0.29999, 0.30001]_com [0.39999, 0.40001]_com [0.5]_com @end group @end example @example @group infsupdec ("1 [2, 3]; 4, 5, 6") @result{} ans = 2×3 interval matrix [1]_com [2, 3]_com [Empty]_trv [4]_com [5]_com [6]_com @end group @end example @example @group infsupdec (@{1; eps; "4/7"; "pi"@}, @{2; 1; "e"; "0xff"@}) @result{} ans ⊂ 4×1 interval vector [1, 2]_com [2.2204e-16, 1]_com [0.57142, 2.7183]_com [3.1415, 255]_com @end group @end example @section Arithmetic Operations The interval package comprises many interval arithmetic operations. A complete list can be found in its function reference. Function names match GNU Octave standard functions where applicable and follow recommendations by IEEE Std 1788-2015 otherwise, @pxref{Function Names}. The interval arithmetic flavor used by this package is the “set-based” interval arithmetic and follows these rules: Intervals are sets. They are subsets of the set of real numbers. The interval version of an elementary function such as sin(x) is essentially the natural extension to sets of the corresponding point-wise function on real numbers. That is, the function is evaluated for each number in the interval where the function is defined and the result must be an enclosure of all possible values that may occur. By default arithmetic functions are computed with best possible accuracy (which is more than what is guaranteed by GNU Octave core functions). The result will therefore be a tight and very accurate enclosure of the true mathematical value in most cases. Details on each function's accuracy can be found in its documentation, which is accessible with GNU Octave's @command{help} command. Examples of using interval arithmetic functions @example @group sin (infsupdec (0.5)) @result{} ans ⊂ [0.47942, 0.47943]_com @end group @end example @example @group power (infsupdec (2), infsupdec (3, 4)) @result{} ans = [8, 16]_com @end group @end example @example @group atan2 (infsupdec (1), infsupdec (1)) @result{} ans ⊂ [0.78539, 0.7854]_com @end group @end example @example @group midrad (magic (3), 0.5) * pascal (3) @result{} ans = 3×3 interval matrix [13.5, 16.5]_com [25, 31]_com [42, 52]_com [13.5, 16.5]_com [31, 37]_com [55, 65]_com [13.5, 16.5]_com [25, 31]_com [38, 48]_com @end group @end example @section Numerical Operations Some interval functions do not return an interval enclosure, but a single number (in binary64 precision). Most important are @funref{@@infsup/inf} and @funref{@@infsup/sup}, which return the lower and upper interval boundaries. More such operations are @funref{@@infsup/mid} (approximation of the interval's midpoint), @funref{@@infsup/wid} (approximation of the interval's width), @funref{@@infsup/rad} (approximation of the interval's radius), @funref{@@infsup/mag} (interval's magnitude) and @funref{@@infsup/mig} (interval's mignitude). @example @group ## Enclosure of the decimal number 0.1 is not exact ## and results in an interval with a small uncertainty. wid (infsupdec ("0.1")) @result{} ans = 1.3878e-17 @end group @end example @section Boolean Operations Interval comparison operations produce boolean results. While some comparisons are especially for intervals (@funref{@@infsup/subset}, @funref{@@infsup/interior}, @funref{@@infsup/ismember}, @funref{@@infsup/isempty}, @funref{@@infsup/disjoint}, …) others are interval extensions of simple numerical comparison. For example, the less-or-equal comparison is mathematically defined as ∀a ∃b a ≤ b ∧ ∀b ∃a a ≤ b. @example @group infsup (1, 3) <= infsup (2, 4) @result{} ans = 1 @end group @end example @section Matrix Operations Above mentioned operations can also be applied element-wise to interval vectors and matrices. Many operations use vectorization techniques. In addition, there are matrix operations on interval matrices. These operations comprise: dot product, matrix multiplication, vector sums (all with tightest accuracy), matrix inversion, matrix powers, and solving linear systems (the latter are less accurate). As a result of missing hardware / low-level library support and missing optimizations, these operations are relatively slow compared to familiar operations in floating-point arithmetic. Examples of using interval matrix functions @example @group A = infsupdec ([1, 2, 3; 4, 0, 0; 0, 0, 1]); A (2, 3) = "[0, 6]" @result{} A = 3×3 interval matrix [1]_com [2]_com [3]_com [4]_com [0]_com [0, 6]_com [0]_com [0]_com [1]_com @end group @end example @example @group B = inv (A) @result{} B = 3×3 interval matrix [0]_trv [0.25]_trv [-1.5, 0]_trv [0.5]_trv [-0.125]_trv [-1.5, -0.75]_trv [0]_trv [0]_trv [1]_trv @end group @end example @example @group A * B @result{} ans = 3×3 interval matrix [1]_trv [0]_trv [-1.5, +1.5]_trv [0]_trv [1]_trv [-6, +6]_trv [0]_trv [0]_trv [1]_trv @end group @end example @example @group A = infsupdec (magic (3)) @result{} A = 3×3 interval matrix [8]_com [1]_com [6]_com [3]_com [5]_com [7]_com [4]_com [9]_com [2]_com @end group @end example @example @group c = A \ [3; 4; 5] @result{} c ⊂ 3×1 interval vector [0.18333, 0.18334]_trv [0.43333, 0.43334]_trv [0.18333, 0.18334]_trv @end group @end example @example @group A * c @result{} ans ⊂ 3×1 interval vector [2.9999, 3.0001]_trv [3.9999, 4.0001]_trv [4.9999, 5.0001]_trv @end group @end example @subsection Notes on Linear Systems A system of linear equations in the form A@var{x} = b with intervals can be seen as a range of classical linear systems, which can be solved simultaneously. Whereas classical algorithms compute an approximation for a single solution of a single linear system, interval algorithms compute an enclosure for all possible solutions of (possibly several) linear systems. Some characteristics should definitely be known when linear interval systems are solved: @itemize @item If the linear system is underdetermined and has infinitely many solutions, the interval solution will be unbound in at least one of its coordinates. Contrariwise, from an unbound result it can not be concluded whether the linear system is underdetermined or has solutions. @item If the interval result is empty in at least one of its coordinates, the linear system is guaranteed to be overdetermined and has no solutions. Contrariwise, from a non-empty result it can not be concluded whether all or some of the systems have solutions or not. @item Wide intervals within the matrix A can easily lead to a superposition of cases, where the rank of A is no longer unique. If the linear interval system contains cases of linear independent equations as well as linear dependent equations, the resulting enclosure of solutions will inevitably be very broad. @end itemize However, solving linear systems with interval arithmetic can produce useful results in many cases and automatically carries a guarantee for error boundaries. Additionally, it can give better information than the floating-point variants for some cases. Standard floating point arithmetic versus interval arithmetic on ill-conditioned linear systems @example @group A = [1, 0; 2, 0]; ## This linear system has no solutions A \ [3; 0] @print{} warning: ...matrix singular to machine precision... @result{} ans = 0.60000 0.00000 @end group @end example @example @group ## This linear system has many solutions A \ [4; 8] @result{} ans = 4 0 @end group @end example @example @group ## The empty interval vector proves that there is no solution infsup (A) \ [3; 0] @result{} ans = 2×1 interval vector [Empty] [Empty] @end group @end example @example @group ## The unbound interval vector indicates ## that there may be many solutions infsup (A) \ [4; 8] @result{} ans = 2×1 interval vector [4] [Entire] @end group @end example @section Plotting Plotting of intervals in 2D and 3D can be achieved with the functions @funref{@@infsup/plot} and @funref{@@infsup/plot3} respectively. However, some differences in comparison with classical plotting in Octave shall be noted. When plotting classical (non-interval) functions in Octave, one normally uses a vector and evaluates a function on that vector element-wise. The resulting X and Y (and possibly Z) coordinates are then drawn against each other, whilst coordinates can be connected using interpolated lines. The plot shows an approximation of the function's graph and the accuracy (and smoothness of the graph) primarily depends on the number of coordinates where the function has been evaluated. Evaluating the same function on a single interval (e. g. the part of the function's domain that is of interest) yields a single interval result which covers the actual range of the function. Plotting just two intervals, input and output, against each other is boring, because the plot would only show a single rectangle. Contrariwise, evaluating the function for many individual points (e. g. using @funref{@@infsup/linspace}) would hardly fit in the philosophy of interval arithmetic. Individual points of evaluation are not interconnected by the interval plotting functions, because that would introduce errors. The solution for plotting functions with interval arithmetic is called: “mincing”. The @funref{@@infsup/mince} function divides an interval into many smaller adjacent subsets, which can be used for range evaluations of the function. As a result, one gets vectors of intervals, which produce a coverage of the function's graph using rectangles. Please note, how the rectangles cover the sine function's true range from @minus{}1 to 1 in the following example, whilst the interpolated lines make a poor approximation. @include image/interval-vs-normal-plot.m.texinfo @myimage{image/interval-vs-normal-plot.m,Plotting an interval function and a classic function} For 3D plotting the @funref{@@infsup/meshgrid} function, as usual, becomes handy. The following example shows how two different ranges for X and Y coordinates are used to construct a grid, where the function @funref{@@infsup/atan2} is evaluated. In this particular case the interval grid has gaps, because X and Y coordinates have been constructed such that intervals do not intersect. @include image/interval-plot3.m.texinfo @myimage{image/interval-plot3.m,Plotting 3D interval grid points} interval-1.4.1/doc/chapter/ieee-1788.texinfo0000644000000000000000000004645012657475772016633 0ustar 00000000000000@c This is part of the GNU Octave Interval Package Manual. @c Copyright 2015-2016 Oliver Heimlich. @c See the file manual.texinfo for copying conditions. @documentencoding UTF-8 @appendix IEEE Std 1788-2015 The IEEE standard for interval arithmetic is an important asset for the general use of interval arithmetic. Several interval arithmetic libraries have been created (most popular for the language C++), which vary greatly in their philosophy, completeness and—most important—mathematical definition of certain functions and arithmetic evaluation. The standard grants support for several interval arithmetic flavors, but fights incompatibilities on many layers: Interval arithmetic applications shall be portable, predictable, and reproducible. This is especially important since interval arithmetic shall lead to reliable results. Also a common standard is necessary to catalyze the availability of (fast) interval operations in hardware. For all conforming implementations certain accuracy constraints must be satisfied and a good amount of interval functions must be implemented. It is defined how to handle functions that are not globally defined or have limiting values. Also such basic things like interval representation, many useful constructors, and interchange encoding are addressed. The interval package for GNU Octave is the first complete implementation that claims to be standard conforming. @menu * Function Names:: List of functions defined by IEEE Std 1788-2015@*and how they have been implemented in GNU Octave * Conformance Claim:: Official statement and some@*implementation specific details regarding the standard @end menu @node Function Names @appendixsec Function Index In terms of a better integration into the GNU Octave language, several operations use a function name which is different from the name proposed in the standard document. The following table translates and lists the implemented function names of the IEEE standard for interval arithmetic. The implementation provides several additional functions, but this section lists only functions that are mentioned in IEEE Std 1788-2015. @appendixsubsec Interval constants See @funref{empty} and @funref{entire}. @appendixsubsec Constructors The operations textToInterval (@var{S}), numsToInterval (@var{l}, @var{u}), and setDec (@var{x}) are implemented by the class constructors @funref{@@infsup/infsup} for bare intervals and @funref{@@infsupdec/infsupdec} for decorated intervals. @appendixsubsec Required functions @float Table,tab:required-forward-functions @caption{Required forward elementary functions} @shortcaption{Required forward elementary functions} @multitable {roundTiesToAway (x)} {@@infsupdec/iscommoninterval} {Tightness (and comments...)} @headitem Operation @tab Implementation @tab Tightness @ifnottex @headitem @tab @r{@emph{Basic operations}} @tab @end ifnottex @item neg (@var{x}) @tab@funref{@@infsup/uminus} @tab tightest @item add (@var{x}, @var{y}) @tab@funref{@@infsup/plus} @tab tightest @item sub (@var{x}, @var{y}) @tab@funref{@@infsup/minus} @tab tightest @item mul (@var{x}, @var{y}) @tab@funref{@@infsup/times} @tab tightest @item div (@var{x}, @var{y}) @tab@funref{@@infsup/rdivide} @tab tightest @item recip (@var{x}) @tab@code{1 ./ @var{x}} @tab tightest @item sqr (@var{x}) @tab@code{@var{x} .^ 2} @tab tightest @item sqrt (@var{x}) @tab@funref{@@infsup/realsqrt} @tab tightest @item fma (@var{x}, @var{y}, @var{z}) @tab@funref{@@infsup/fma} @tab tightest @ifnottex @headitem @tab @r{@emph{Power functions}} @tab @end ifnottex @item pown (@var{x}, @var{p}) @tab@funref{@@infsup/pown} @tab tightest @item pow (@var{x}, @var{y}) @tab@funref{@@infsup/pow} @tab tightest @item exp (@var{x}) @tab@funref{@@infsup/exp} @tab tightest @item exp2 (@var{x}) @tab@funref{@@infsup/pow2} @tab tightest @item exp10 (@var{x}) @tab@funref{@@infsup/pow10} @tab tightest @item log (@var{x}) @tab@funref{@@infsup/log} @tab tightest @item log2 (@var{x}) @tab@funref{@@infsup/log2} @tab tightest @item log10 (@var{x}) @tab@funref{@@infsup/log10} @tab tightest @ifnottex @headitem @tab @r{@emph{Trigonometric / hyperbolic}} @tab @end ifnottex @item sin (@var{x}) @tab@funref{@@infsup/sin} @tab tightest @item cos (@var{x}) @tab@funref{@@infsup/cos} @tab tightest @item tan (@var{x}) @tab@funref{@@infsup/tan} @tab tightest @item asin (@var{x}) @tab@funref{@@infsup/asin} @tab tightest @item acos (@var{x}) @tab@funref{@@infsup/acos} @tab tightest @item atan (@var{x}) @tab@funref{@@infsup/atan} @tab tightest @item atan2 (@var{y}, @var{x}) @tab@funref{@@infsup/atan2} @tab tightest @item sinh (@var{x}) @tab@funref{@@infsup/sinh} @tab tightest @item cosh (@var{x}) @tab@funref{@@infsup/cosh} @tab tightest @item tanh (@var{x}) @tab@funref{@@infsup/tanh} @tab tightest @item asinh (@var{x}) @tab@funref{@@infsup/asinh} @tab tightest @item acosh (@var{x}) @tab@funref{@@infsup/acosh} @tab tightest @item atanh (@var{x}) @tab@funref{@@infsup/atanh} @tab tightest @ifnottex @headitem @tab @r{@emph{Integer functions}} @tab @end ifnottex @item sign (@var{x}) @tab@funref{@@infsup/sign} @tab tightest @item ceil (@var{x}) @tab@funref{@@infsup/ceil} @tab tightest @item floor (@var{x}) @tab@funref{@@infsup/floor} @tab tightest @item trunc (@var{x}) @tab@funref{@@infsup/fix} @tab tightest @item roundTiesToEven (@var{x}) @tab@funref{@@infsup/roundb} @tab tightest @item roundTiesToAway (@var{x}) @tab@funref{@@infsup/round} @tab tightest @ifnottex @headitem @tab @r{@emph{Absmax functions}} @tab @end ifnottex @item abs (@var{x}) @tab@funref{@@infsup/abs} @tab tightest @item min (@var{x}, @var{y}) @tab@funref{@@infsup/min} @tab tightest @item max (@var{x}, @var{y}) @tab@funref{@@infsup/max} @tab tightest @end multitable @end float @float Table,tab:required-reverse-functions @caption{Required reverse functions} @shortcaption{Required reverse functions} @multitable {roundTiesToAway (x)} {@@infsupdec/iscommoninterval} {Tightness (and comments...)} @headitem Operation @tab Implementation @tab Tightness @ifnottex @headitem @tab @r{@emph{From unary functions}} @tab @end ifnottex @item sqrRev (@var{c}, @var{x}) @tab@funref{@@infsup/sqrrev} @tab tightest @item absRev (@var{c}, @var{x}) @tab@funref{@@infsup/absrev} @tab tightest @item pownRev (@var{c}, @var{x}, @var{p}) @tab@funref{@@infsup/pownrev} @tab valid (tightest for @var{p} ≥ @minus{}2) @item sinRev (@var{c}, @var{x}) @tab@funref{@@infsup/sinrev} @tab valid @item cosRev (@var{c}, @var{x}) @tab@funref{@@infsup/cosrev} @tab valid @item tanRev (@var{c}, @var{x}) @tab@funref{@@infsup/tanrev} @tab valid @item coshRev (@var{c}, @var{x}) @tab@funref{@@infsup/coshrev} @tab tightest @ifnottex @headitem @tab @r{@emph{From binary functions}} @tab @end ifnottex @item mulRev (@var{b}, @var{c}, @var{x}) @tab@funref{@@infsup/mulrev} @tab tightest @item powRev1 (@var{b}, @var{c}, @var{x}) @tab@funref{@@infsup/powrev1} @tab valid @item powRev2 (@var{a}, @var{c}, @var{x}) @tab@funref{@@infsup/powrev2} @tab valid @item atan2Rev1 (@var{b}, @var{c}, @var{x}) @tab@funref{@@infsup/atan2rev1} @tab valid @item atan2Rev2 (@var{a}, @var{c}, @var{x}) @tab@funref{@@infsup/atan2rev2} @tab valid @ifnottex @headitem @tab @r{@emph{Two-output division}} @tab @end ifnottex @item mulRevToPair (@var{b}, @var{c}) @tab@funref{@@infsup/mulrev} @tab tightest @ifnottex @headitem @tab @r{@emph{Cancellative addition@*and subtraction}} @tab @end ifnottex @item cancelMinus (@var{x}, @var{y}) @tab@funref{@@infsup/cancelminus} @tab tightest @item cancelPlus (@var{x}, @var{y}) @tab@funref{@@infsup/cancelplus} @tab tightest @end multitable @end float @float Table,tab:required-set-operations @caption{Required set operations} @shortcaption{Required set operations} @multitable {roundTiesToAway (x)} {@@infsupdec/iscommoninterval} {Tightness (and comments...)} @headitem Operation @tab Implementation @tab Tightness @item intersection (@var{x}, @var{y}) @tab@funref{@@infsup/intersect} @tab tightest @item convexHull (@var{x}, @var{y}) @tab@funref{@@infsup/union} @tab tightest @end multitable @end float @float Table,tab:required-numeric-functions @caption{Required numeric functions of intervals} @shortcaption{Required numeric functions of intervals} @multitable {roundTiesToAway (x)} {@@infsupdec/iscommoninterval} {Tightness (and comments...)} @headitem Operation @tab Implementation @tab Rounding mode @item inf (@var{x}) @tab@funref{@@infsup/inf} @tab @item sup (@var{x}) @tab@funref{@@infsup/sup} @tab @item mid (@var{x}) @tab@funref{@@infsup/mid} @tab to nearest, ties to even @item wid (@var{x}) @tab@funref{@@infsup/wid} @tab toward +∞ @item rad (@var{x}) @tab@funref{@@infsup/rad} @tab toward +∞ @item mag (@var{x}) @tab@funref{@@infsup/mag} @tab @item mig (@var{x}) @tab@funref{@@infsup/mig} @tab @end multitable @end float @float Table,tab:required-boolean-functions @caption{Required boolean functions of intervals} @shortcaption{Required boolean functions of intervals} @multitable {roundTiesToAway (x)} {@@infsupdec/iscommoninterval} {Tightness (and comments...)} @headitem Operation @tab Implementation @tab Description @item isEmpty (@var{x}) @tab@funref{@@infsup/isempty} @tab @var{x} is the empty set @item isEntire (@var{x}) @tab@funref{@@infsup/isentire} @tab @var{x} is the whole line @item equal (@var{a}, @var{b}) @tab@funref{@@infsup/eq} @tab @var{a} equals @var{b} @item subset (@var{a}, @var{b}) @tab@funref{@@infsup/subset} @tab @var{a} is a subset of @var{b} @item less (@var{a}, @var{b}) @tab@funref{@@infsup/le} @tab @var{a} is weakly less than @var{b} @item precedes (@var{a}, @var{b}) @tab@funref{@@infsup/precedes} @tab @var{a} is left of but may touch @var{b} @item interior (@var{a}, @var{b}) @tab@funref{@@infsup/interior} @tab @var{a} is interior to @var{b} @item strictLess (@var{a}, @var{b}) @tab@funref{@@infsup/lt} @tab @var{a} is strictly less than @var{b} @item strictPrecedes (@var{a}, @var{b}) @tab@funref{@@infsup/strictprecedes} @tab @var{a} is strictly left of @var{b} @item disjoint (@var{a}, @var{b}) @tab@funref{@@infsup/disjoint} @tab @var{a} and @var{b} are disjoint @end multitable @end float @appendixsubsec Recommended functions @float Table,tab:recommended-functions @caption{Recommended functions} @shortcaption{Recommended functions} @multitable {roundTiesToAway (x)} {@@infsupdec/iscommoninterval} {Tightness (and comments...)} @headitem Operation @tab Implementation @tab Tightness / Comments @ifnottex @headitem @tab @r{@emph{Elementary functions}} @tab @end ifnottex @item rootn (@var{x}, @var{q}) @tab@funref{@@infsup/nthroot} @tab valid (tightest for @var{q} ≥ @minus{}2) @item expm1 (@var{x}) @tab@funref{@@infsup/expm1} @tab tightest @item logp1 (@var{x}) @tab@funref{@@infsup/log1p} @tab tightest @item hypot (@var{x}, @var{y}) @tab@funref{@@infsup/hypot} @tab tightest @item rSqrt (@var{x}) @tab@funref{@@infsup/rsqrt} @tab tightest @ifnottex @headitem @tab @r{@emph{Boolean functions}} @tab @end ifnottex @item isCommonInterval (@var{x}) @tab@funref{@@infsup/iscommoninterval} @tab (=bound and non-empty) @item isSingleton (@var{x}) @tab@funref{@@infsup/issingleton} @tab (=single real) @item isMember (@var{m}, @var{x}) @tab@funref{@@infsup/ismember} @tab @ifnottex @headitem @tab @r{@emph{Extended comparison}} @tab @end ifnottex @item overlap (@var{a}, @var{b}) @tab@funref{@@infsup/overlap} @tab @end multitable @end float @appendixsubsec Operations on/with decorations See @funref{@@infsup/newdec}, @funref{@@infsupdec/intervalpart}, and @funref{@@infsupdec/decorationpart}. The operation setDec is implemented by @funref{@@infsupdec/infsupdec}. For comparison of decorations with respect to the propagation order @code{com > dac > def > trv > ill} use the numeric value returned by @code{decorationpart (@var{x}, "uint8")}. @appendixsubsec Reduction operations See @funref{mpfr_vector_sum_d} and @funref{mpfr_vector_dot_d}. The operations @code{sumAbs} and @code{sumSquare} can be computed with @code{mpfr_vector_sum_d (@var{rounding mode}, abs (@var{x}))} and @code{mpfr_vector_dot_d (@var{rounding mode}, @var{x}, @var{x})} respectively. @appendixsubsec Input The operation @code{textToInterval} is implemented by the class constructors @funref{@@infsup/infsup} for bare intervals and @funref{@@infsupdec/infsupdec} for decorated intervals. Both are able to operate on interval literals provided as strings. @appendixsubsec Output See @funref{@@infsup/intervaltotext}. @appendixsubsec Exact text representation See @funref{exacttointerval} and @funref{@@infsup/intervaltoexact}. @appendixsubsec Interchange representation and encoding See @funref{interval_bitpack} and @funref{@@infsup/bitunpack}. @node Conformance Claim @appendixsec Conformance Claim The inverval package version @value{version} for GNU Octave is conforming to IEEE Std 1788-2015, IEEE Standard for Interval Arithmetic. It is conforming to the set-based flavor with IEEE 754 conformance for the infsup binary64 interval type and without compressed arithmetic. Additionally it provides no further flavors. @appendixsec Conformance Questionnaire @html
@end html @enumerate a @item Implementation-defined behavior @enumerate 1 @item What status flags or other means to signal the occurrence of certain decoration values in computations does the implementation provide if any? The implementation does not signal the occurrence of decoration values. @end enumerate @item Documentation of behavior @enumerate 1 @item If the implementation supports implicit interval types, how is the interval hull operation realized? The implementation supports explicit interval types only. @item What accuracy is achieved (i.e., tightest, accurate, or valid) for each of the implementation’s interval operations? The accuracy requirements of IEEE Std 1788-2015 are fulfilled. Most operations achieve tightest accuracy, some operations (especially reverse operations) do not. The tightness of each operation is documented in the function's documentation string and can be displayed with the @command{help} command. @item Under what conditions is a constructor unable to determine whether a Level 1 value exists that corresponds to the supplied inputs? When two different string boundaries for an interval both lie between the same two subsequent binary64 numbers, a PossiblyUndefined warning is created. @item How are ties broken in rounding numbers if multiple numbers qualify as the rounded result? Tie-breaking uses the IEEE Std 754 default: round ties to even. @item How are interval datums converted to their exact text representations? The binary64 boundaries are converted into hexadecimal-significand form as required by the standard. It is also possible to convert interval datums to exact interval literals in decimal form, see optional arguments of function @funref{@@infsup/intervaltotext} for that purpose. @end enumerate @item Implementation-defined behavior @enumerate 1 Does the implementation include the interval overlapping function? If so, how is it made available to the user? Yes, the interval overlapping function is implemented under the name @funref{@@infsup/overlap}. @item Does the implementation store additional information in a NaI? What functions are provided for the user to set and read this information? No additional information is stored in a NaI. @item What means if any does the implementation provide for an exception to be signaled when a NaI is produced? The creation of a NaI is signaled with GNU Octave's warning mechanism. @item What interval types are supported besides the required ones? None. @item What mechanisms of exception handling are used in exception handlers provided by the implementation? What additional exception handling is provided by the implementation? The exceptions described by IEEE Std 1788-2015 raise an error, which can be handled with GNU Octave's error mechanism. The implementation provides no additional exception handling. @item [Question does not apply to IEEE 754 conforming types.] @item Does the implementation include different versions of the same operation for a given type and how are these provided to the user? The interval matrix multiplication (see @funref{@@infsup/mtimes}) offers two implementations, with either @option{tightest} or @option{valid} accuracy. The user may chose the desired version with an optional argument during the function call. @item What combinations of formats are supported in interval constructors? Any reasonable combination of the formats described in the standard document is supported. @item [Question does not apply to IEEE 754 conforming types.] @item What methods are used to read or write strings from or to character streams? Does the implementation employ variations in locales (such as specific character case matching)? This includes the syntax used in the strings for reading and writing. Input and output is implemented with GNU Octave string variables in UTF-8 encoding. There is no discrimination between different locales. Character case is ignored during input. The syntax for interval literals is used as described by the standard document. @item What is the tightness for the interval to string conversion for all interval types? The general-purpose interval to string conversion produces the tightest decimal infsup form which has no more digits than are necessary to separate two binary64 numbers. @item What is the result of Level 3 operations for invalid inputs? Interval constructors prevent the creation of invalid Level 3 interval datums. Any non-interval input to Level 3 operations is implicitly converted into an interval and the operation silently continues on interval inputs. If at least one input is a decorated interval, bare interval inputs are implicitly decorated as described by @command{newDec} in the standard document. Implicit promotion from a bare interval to a decorated interval is signaled with GNU Octave's warning mechanism. If implicit conversion fails (e.g., illegal interval literals), bare interval operations raise an error, whereas the decorated interval operations continue on NaI inputs. @item [Question does not apply to IEEE 754 conforming types.] @item What decorations does the implementation provide and what is their mathematical definition? How are these decorations mapped when converting an interval to the interchange format? The implementation provides the decorations com, dac, def, trv, and ill as described by the standard document. @item [Question does not apply to IEEE 754 conforming types.] @end enumerate @item [Question applies to compressed arithmetic only, which is not supported.] @item [Questions apply to non-standard flavors only, which are not supported.] @end enumerate interval-1.4.1/doc/chapter/introduction-to-interval-arithmetic.texinfo0000644000000000000000000003256212657475772024430 0ustar 00000000000000@c This is part of the GNU Octave Interval Package Manual. @c Copyright 2015-2016 Oliver Heimlich. @c Copyright 2008-2009 Simone Pernice. @c See the file manual.texinfo for copying conditions. @documentencoding UTF-8 @chapter Introduction to Interval Arithmetic @quotation Give a digital computer a problem in arithmetic, and it will grind away methodically, tirelessly, at gigahertz speed, until ultimately it produces the wrong answer. … An interval computation yields a pair of numbers, an upper and a lower bound, which are guaranteed to enclose the exact answer. Maybe you still don’t know the truth, but at least you know how much you don’t know. @author Brian Hayes, @uref{http://dx.doi.org/10.1511/2003.6.484,DOI: 10.1511/2003.6.484} @end quotation Interval arithmetic adds two unique features to ordinary computer arithmetic: (1) Functions can be evaluated over (connected) subsets of their domain, and (2) any computational errors are automatically considered and are accumulated in the final outcome. In conjunction they yield a @emph{verified result enclosure} over a range of input values. These possibilities of interval arithmetic enable great new possibilities, but what is wrong with the well-known computer arithmetic in the first place? @section Motivation Floating-point arithmetic, as specified by @uref{http://en.wikipedia.org/wiki/IEEE_floating_point,IEEE Std 754}, is available in almost every computer system today. It is wide-spread, implemented in common hardware and integral part in programming languages. For example, the binary64 format (a.k.a. double-precision) is the default numeric data type in GNU Octave. Benefits are obvious: The results of arithmetic operations are (mostly) well-defined and comparable between different systems and computation is highly efficient. However, there are some downsides of floating-point arithmetic in practice, which will eventually produce errors in computations. Generally speaking, most of these problems occur in any arithmetic with finite precision. @itemize @item Floating-point arithmetic is often used mindlessly by developers. @url{http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html} @url{http://www.cs.berkeley.edu/~wkahan/Mindless.pdf} @url{http://www.ima.umn.edu/~arnold/disasters/} @item The binary (base-2) data types categorically are not suitable for doing financial computations. Very often representational errors are introduced when using “real world” decimal numbers. @url{http://en.wikipedia.org/wiki/Decimal_computer} @item Even if the developer would be proficient, most developing environments / technologies limit floating-point arithmetic capabilities to a very limited subset of IEEE Std 754: Only one or two data types, no rounding modes, missing functions, … @url{http://www.cs.berkeley.edu/~wkahan/JAVAhurt.pdf} @item Results are @uref{https://hal.archives-ouvertes.fr/hal-00128124/en/,hardly predictable}. All operations produce the best possible accuracy at runtime, this is how a floating point works. Contrariwise, financial computer systems typically use a @uref{http://en.wikipedia.org/wiki/Fixed-point_arithmetic,fixed-point arithmetic} (COBOL, PL/I, …), where overflow and rounding can be precisely predicted at @emph{compile-time}. @item Results are system dependent. All but the most basic floating-point operations are @uref{http://www.gnu.org/software/libc/manual/html_node/Errors-in-Math-Functions.html#Errors-in-Math-Functions,not guaranteed to be accurate} and produce different results depending on low level libraries and @uref{http://developer.amd.com/tools-and-sdks/cpu-development/libm/,hardware}. @item If you do not know the technical details (cf. first bullet) you ignore the fact that the computer lies to you in many situations. For example, when looking at numerical output and the computer says “@code{ans = 0.1},” this is not absolutely correct. In fact, the value is only close enough to the value 0.1. Additionally, many functions produce limit values (∞ × −∞ = −∞, ∞ ÷ 0 = ∞, ∞ ÷ −0 = −∞, log (0) = −∞), which is sometimes (but not always!) useful when overflow and underflow occur. @end itemize Interval arithmetic addresses above problems in its very special way. It accepts the fact that numbers cannot be stored or computed with infinite precision and introduces enclosures of exact values, which can be computed on any machine with finite precision. This introduces new possibilities for algorithms. Any errors are covered by the range of an interval during the course of computation. All members of intervals are by definition finite real numbers, which results in an exception free and mathematically well-defined arithmetic. The possibility to actually evaluate a function on a connected range of values and compute a guaranteed enclosure of all possible values is a unique selling point. For example, the @uref{http://en.wikipedia.org/wiki/Interval_arithmetic#Interval_Newton_method,interval newton method} (see @funref{@@infsup/fzero}) is able to find @emph{all} zeros of a particular function. More precisely, the algorithm is able to reliably eliminate ranges of values where the function cannot have a root by a simple interval evaluation of either the function itself or its derivative. Global convergence can be achieved by bisecting the intermediate ranges. @section Error bounds in real life @c This section is largely based on the documentation for the Octave SIMP package by Simone Pernice. Intervals can be used instead of simple numbers to automatically take into account the tolerance (or uncertainty) of the values used in calculation. Every day we need to compute the result of a lot of simple mathematical equations. For example the cost of the apples bought at the farmer's market is given by: @display apple price = apple cost per kilo · kilos of apple bought @end display When we need the result of those mathematical expressions, we put the values on the right hand side of the equation and we compute its result for the left hand side. We usually put wrong (erroneous) numbers into the equation and therefore where is no doubt we get wrong results. There are a lot of reasons why we use incorrect values, for example @enumerate @item Most of the values are measured, therefore they are known within a given tolerance. @uref{http://en.wikipedia.org/wiki/Accuracy_and_precision,Wikipedia sv. accuracy and precision} @item Some values have an infinite number of digits after the (decimal) point, e.g. π. @item Some values change with time or samples (or whatever), like the weight of a person, which can change of 5 percent during the day, or the current gain of a bipolar junction transistor (BJP), which can change of 50 percent on the samples of the same series. @item Some values are estimation or guess—something like between a minimum and a maximum. @end enumerate @noindent For example, if a pipe breaks and you want to buy a new one you need its diameter. If you do not have a caliber, you may measure its circumference and divide it by π. @display diameter = circumference / π @end display Here are two errors: the circumference is known within the tolerance given by your meter, moreover π has an infinite number of digits while only few of them can be used in the operation. You may think the error is negligible, the result is enough accurate to buy a new pipe in a hardware shop. However, the not infinite precision of those operations avoid the use of computers as automatic theorem demonstration tools and so on. This kind of issue is quite common in engineer design. What engineers do is to make sure their design will work in the worst case or in most of the cases (usually more than 99.9 percent). A simple example follows. Let us say you want to repaint the walls of your living room completely messed up by your children. You need to compute how many paint cans you need to buy. The equation is quite simple: @display paint cans = 2 · (room width + room length) · room height / (paint per can · paint efficiency), @end display @noindent where “paint efficiency” is how many square meters of surface can be painted with a liter of paint. The problem here is that usually we do not have a long enough meter to measure the room width and length. It is much simpler to count the number of steps to go through it (1 step is about a meter, let us say from 0.9 to 1.1 meters). Moreover, the paint provider usually declares a paint efficiency range. Here is the data: @itemize @item room width = 6 steps (5.4m to 6.6m) @item room length = 4 steps (3.6m to 4.4m) @item room height = 3m (it is assumed to be correct) @item paint efficiency = from 0.7 to 1.3 square meters per liter @item paint liters per can = 40 (it is assumed to be correct) @end itemize @noindent To compute the average result just put average values in. We get: paint cans = 2 · (6 + 4) · 3 / (40 · 1) = 1.5, which means two paint cans unless you are able to buy just half of the second can. What happens in the worst case? Just put pessimistic values in the equation. We get: paint cans = 2 · (6.6 + 4.4) · 3 / (40 · 0.7) = 2.36. That is, in the worst case we would be short 0.36 cans of paint. It makes sense to buy 3 cans. Last, consider the best case. Is it enough to only buy a single can of paint? Just put optimistic values in the equation. We get: paint cans = 2 · (5.4 + 3.6) · 3 / (40 · 1.3) = 1.04, which means one can of paint would not be enough. You have to buy at least two cans, but probably need one more. For this result we had to go through the equation multiple times (at least twice) and carefully consider for each variable, which would be the most optimistic / pessimistic value assignment, which is not trivial. For example consider the room size versus the paint efficiency: It depends whether the highest or the lowest value takes an optimistic or pessimistic role—and this was a simple example with basic arithmetic operations. Using interval arithmetic it is possible to compute the result in a single run with ranges as inputs. The following example demonstrates this and further below is explained how it works. @example @group step = midrad (1, "0.1"); w = 6 * step; l = 4 * step; h = 3; eff = infsupdec ("[0.7, 1.3]"); cansize = 40; cans = 2 * (w + l) * h / (eff * cansize) @result{} cans ⊂ [1.0384, 2.3572]_com @end group @end example @example @group ## Since we can only buy whole cans ceil (cans) @result{} ans = [2, 3]_def @end group @end example @section Pros and Cons Interval arithmetic, introduced in the 1960s, is a young and powerful technique. Its first application has been to control errors in computations and simplify error analysis for engineers (rounding errors, truncation errors, and conversion errors). The range evaluation of functions has soon been exploited for reliably checking for certain function values and for self-verifying algorithms. Latest usage scenarios comprise root finding, function approximation, and robust pattern recognition. More useful applications are certainly left to be detected. The major problem in interval arithmetic is that errors can easily build up, such that the final result is too wide to be useful. This is especially true when the @emph{dependency problem} applies, that is, a single variable occurs several times within a computation and is represented by an interval in each occurrence. Then, the variable virtually may take different values independently, which introduces a systematic error. For example, computing @code{x .^ 2} will always yield a subset of @code{times (x, x)}, the latter considers two intervals independent of each other. @example @group x = infsupdec ("[-1, 3]"); x .^ 2 @result{} ans = [0, 9]_com times (x, x) @result{} ans = [-3, +9]_com @end group @end example After all, it is possible to reduce overestimation errors by subdividing the function's domain into smaller intervals, e. g., with bisection. This technique is called “mincing”. The computational errors are proportional to the interval width and a linear convergence can be achieved. @example @group x1 = infsupdec ("[-1, 1]"); x2 = infsupdec ("[1, 3]"); hull (x1 .^ 2, x2 .^ 2) @result{} ans = [0, 9]_com hull (times (x1, x1), times (x2, x2)) @result{} ans = [-1, +9]_com @end group @end example However, this does not help when ranges of input values are too big. For certain applications it is better to use statistical models, where infinite domains are supported. @section Theory There are good introductions to interval arithmetic available and should be consulted for a deeper understanding of the topic. The following recommendations can make a starting point. @itemize @item @uref{http://en.wikipedia.org/wiki/Interval_arithmetic,Wikipedia sv. interval arithmetic} @item Introduction to Interval Analysis (2009), by Ramon E. Moore, R. Baker Kearfott, and Michael J. Cloud. Cambridge University Press. ISBN 978-0898716696. @item @uref{http://www-sop.inria.fr/coprin/logiciels/ALIAS/Examples/COURS/index.html,Introduction to the methods used in interval arithmetic (French)}. @item @uref{http://www.maths.manchester.ac.uk/~higham/narep/narep416.pdf,Interval analysis in MATLAB} Note: The INTLAB toolbox for Matlab is not entirely compatible with this interval package for GNU Octave. However, basic operations can be compared and should be compatible for common intervals. @item @uref{http://www.cs.utep.edu/interval-comp/,Interval related collection of links} @end itemize interval-1.4.1/doc/chapter/preface.texinfo0000644000000000000000000002764612657475772016732 0ustar 00000000000000@c This is part of the GNU Octave Interval Package Manual. @c Copyright 2015-2016 Oliver Heimlich. @c See the file manual.texinfo for copying conditions. @documentencoding UTF-8 @unnumbered Preface Welcome to the user manual of the @dfn{interval package} for GNU Octave. This chapter presents background information and may safely be skipped. First-time users who want to cut right to the chase should read @ref{Getting Started}, which teaches basic concepts and first steps with the package. Users who are not familiar with interval arithmetic should read @ref{Introduction to Interval Arithmetic} first. Still feeling undecided? Look at the @ref{Examples} and see how easy you can put this software to great use! Development of the GNU Octave Interval Package started in September 2014. The IEEE standard for interval arithmetic, IEEE Std 1788-2015, had been drafted by its working group until July 2014 and was about to enter the balloting process. In January 2015 a first package release could be made, which contained the full set of functions required by the standard's draft. On June 11 the standard finally became approved and this interval package can be seen as the first ever completed standard conforming interval arithmetic library. The creation of the interval package has been straightforward, although the author had no previous experience with Octave. Octave is a great environment for getting things done and its active community helps a lot. In this spirit, the interval package wants to be an easy to use tool for experimenting with and quick prototyping of interval arithmetic algorithms and applications. Originally it was intended to only implement the operations required by the standard document, but support for fundamental concepts of Octave as well as interval vectors and interval matrices have soon been added. Today the package contains many useful interval analysis algorithms and solvers, which, together with basic arithmetic functions, form a powerful and versatile library. @myimage{image/octave-interval.ly,GNU Octave Interval Pun} Like Octave, the interval package has nothing to do with music. Above picture is a pun and shows an “octave interval” between the notes d' and d''. The frequencies of these notes can be enclosed by an interval which is a subset of [293, 588] Hz. @menu * Acknowledgments:: * Philosophy:: * Distribution and Development:: * Getting Help:: @end menu @node Acknowledgments @section Acknowledgments The GNU Octave interval package is build upon great third-party software. @itemize @item Correctly rounded arithmetic operations are based on the @uref{http://www.mpfr.org/,GNU MPFR library} by Guillaume Hanrot, Vincent Lefèvre, Patrick Pélissier, Philippe Théveny and Paul Zimmermann. @item A linear system solver @funref{@@infsup/mldivide} and a polynomial evaluation algorithm @funref{@@infsup/polyval} for bare intervals are derived from routines developed for @uref{http://www2.math.uni-wuppertal.de/~xsc/,C-XSC} at University of Wuppertal, Germany. @item @ref{Introduction to Interval Arithmetic} is partly based on the documentation for the former SIMP package for Octave by Simone Pernice. @item A French translation of the package description has been made by Rodéric Moitié. @item In the @ref{Examples} for finding root enclosures a function and code by Helmut Podhaisky has been used. @item Most unit tests are written in portable ITL format and converted into GNU Octave test cases with the @uref{https://github.com/nehmeier/ITF1788,Interval Testing Framework for IEEE 1788}. The framework has been developed by Maximilian Kiesner and Marco Nehmeier, Chair of Software Engineering, Department of Computer Science, University of Würzburg, Germany. @item Several unit tests are derived from @uref{https://github.com/nehmeier/libieeep1788,libieeep1788}, a C++ implementation of IEEE Std 1788-2015, IEEE standard for interval arithmetic. The library contains several unit tests for its IEEE 754 flavor, which is compatible with the arithmetic of the GNU Octave interval package. I have converted nearly 6000 of these test cases into portable ITL format for verification of this package. @comment libieeep1788/NOTICE @comment According to the Apache License, this shall be included in the documentation @indentedblock @verbatiminclude license/libieeep1788.NOTICE @end indentedblock @item Several unit tests are derived from @uref{http://perso.ens-lyon.fr/nathalie.revol/software.html,MPFI}, a C++ interval arithmetic library based on GNU MPFR. The library contains several unit tests for binary64 numbers, which are compatible with the arithmetic of the GNU Octave interval package. I have converted nearly 1500 of these test cases into portable ITL format for verification of this package. @item Several unit tests are derived from @uref{http://www2.math.uni-wuppertal.de/wrswt/software/filib.html,FI_LIB}, an ANSI-C interval arithmetic library based on binary64 numbers. The library contains several unit tests, which are compatible with the arithmetic of the GNU Octave interval package. I have converted 800 of these test cases into portable ITL format for verification of this package. @item Some unit tests are derived from @uref{http://www2.math.uni-wuppertal.de/~xsc/xsc/cxsc_new.html,C-XSC}, a C++ class library for interval arithmetic. The library contains some unit tests, which are compatible with the arithmetic of the GNU Octave interval package. I have converted 160 of these test cases into portable ITL format for verification of this package. @item Fast matrix multiplication (see @funref{@@infsup/mtimes}) as well as the linear system solver (see @funref{@@infsup/mldivide}) use BLAS routines with directed rounding. An OCT-file interface for setting the rounding mode has been developed by Kai Torben Ohlus, Institute for Reliable Computing, Hamburg University of Technology, Germany. @end itemize Last, but not least, many thanks to everybody who has contributed to the success of free software! @node Philosophy @section Philosophy @noindent Features @itemize @item Free software licensed under the terms of the GNU General Public License (Version 3 or later) @item Many interval arithmetic functions with high, system-independent accuracy @item Conforming to IEEE Std 1788-2015, IEEE standard for interval arithmetic @item Support for interval vectors and interval matrices @itemize @item very accurate vector sum, vector dot and matrix multiplication (correctly rounded) @item fast matrix multiplication and fast solver for dense linear systems (BLAS routines) @item vectorized function evaluation @end itemize @item Easy usage @itemize @item GNU Octave function names @item convenient interval constructors @item broadcasting @end itemize @end itemize @noindent Limitations @itemize @item No complex numbers @item No sparse matrices (maybe in the future, if requested by users) @item No multidimensional arrays (maybe in the future, if requested by users) @end itemize The interval arithmetic provided by the interval package focuses on easy usage, accuracy and correctness. It is rather slow compared to other arithmetic libraries. If accurate type checking during compile time—a substantial feature for verified computing—is needed, the user is advised to try third-party interval libraries for strongly typed programming languages like C/C++. The interval package for GNU Octave can nonetheless be used for prototyping of interval algorithms. @emph{Why is the interval package slow?} All arithmetic interval operations are simulated in high-level Octave language using C99 or multi-precision floating-point routines, which is a lot slower than a @uref{https://books.google.de/books?id=JTc4XdXFnQIC&pg=PA61,hardware implementation}. Building interval arithmetic operations from floating-point routines is easy for simple monotonic functions, e. g., addition and subtraction, but is complex for others, e. g., interval power function, atan2, or reverse functions. For some interval operations it is not even possible to rely on floating-point routines, since not all required routines are available in C99 or BLAS. For example, accurate multiplication of matrices with many elements becomes unfeasible as it takes a lot of time. @float Table,tab:runtime @caption{Approximate runtime for certain functions (wall clock time in seconds) — Results have been produced with GNU Octave 3.8.2 and Interval package 0.1.4 on an Intel Core i5-4340M CPU (2.9–3.6 GHz)} @shortcaption{Approximate runtime for certain functions} @multitable {matrix size} {accuracy} {accuracy} {accuracy} {accuracy} {accuracy} {accuracy} @headitem @tab@command{plus} @tab@command{log} @tab@command{pow} @tab@command{mtimes} @tab@command{mtimes} @tab@command{inv} @item Interval@*matrix size @tab tightest@*accuracy @tab tightest@*accuracy @tab tightest@*accuracy @tab valid@*accuracy @tab tightest@*accuracy @tab valid@*accuracy @item 10 × 10 @tab < 0.001 @tab 0.001 @tab 0.008 @tab 0.001 @tab 0.002 @tab 0.025 @item 100 × 100 @tab 0.003 @tab 0.055 @tab 0.61 @tab 0.012 @tab 0.53 @tab 0.30 @item 500 × 500 @tab 0.060 @tab 1.3 @tab 15 @tab 0.30 @tab 63 @tab 4.2 @end multitable @end float @emph{Why is the interval package accurate?} The GNU Octave built-in floating-point routines are not useful for interval arithmetic: Their results depend on hardware, system libraries and compilation options. The interval package handles all arithmetic functions with the help of the GNU MPFR library. With MPFR it is possible to compute system-independent, valid and tight enclosures of the correct results for most functions. However, it should be noted that some reverse operations and matrix operations do not exists in GNU MPFR and therefore cannot be computed with the same accuracy. It is possible to use faster (BLAS based) routines during computation of the matrix multiplication @funref{@@infsup/mtimes}, because correctly rounded matrix multiplication could be considered too slow for certain applications. However, this is not the default behavior and must be explicitly activated by the user. @node Distribution and Development @section Distribution The interval package is free software: Everyone is encouraged to use it, copy it and redistribute it, as well as to make changes under the terms of the GNU General Public License. The interval package is part of Octave Forge, a sibling of the GNU Octave project. Official releases are published at @url{http://octave.sourceforge.net/}. Ports for Mac OS X and FreeBSD are know to exist at @uref{https://trac.macports.org/browser/trunk/dports/math/octave-interval,MacPorts} and @uref{http://www.freshports.org/math/octave-forge-interval/,FreshPorts} respectively. @section Development The source code of the interval package is distributed together with its release. The @uref{https://sourceforge.net/p/octave/interval/ci/default/tree/,source code repository} is located at Octave Forge and contains the latest development version. The current status of development is tracked on the @uref{http://wiki.octave.org/Interval_package,package's page at Octave wiki}. Bug reports and feature requests for either the software or this manual may be posted under the @uref{http://savannah.gnu.org/projects/octave,Octave Project at Savannah}. Contributions to the software and this manual are highly appreciated. @node Getting Help @section Getting Help The interval package contains online help for every function, which can be accessed with the @command{help} command from Octave. The interval arithmetic is implemented with specialized data types, which override standard functions. Whilst the command @command{help @var{function name}} shows the documentation for core Octave functions, the interval variants of these functions can be requested with the command @command{help @@infsup/@var{function name}}. Further help can be seeked at the @uref{https://lists.gnu.org/mailman/listinfo/help-octave,Octave Help mailing list}. interval-1.4.1/doc/image/contractor-rings-intersect.m.texinfo0000644000000000000000000000301512657475772022470 0ustar 00000000000000@c This is part of the GNU Octave Interval Package Manual. @c Copyright 2015-2016 Oliver Heimlich. @c See the file manual.texinfo for copying conditions. @documentencoding UTF-8 @example @ifset m-file @group @c doctest: +SKIP ## General ring contractor function [fval, cx1, cx2] = ctc_ring (y, c1, c2, x1, x2) x1_c1 = x1 - c1; x2_c2 = x2 - c2; sqr_x1_c1 = x1_c1 .^ 2; sqr_x2_c2 = x2_c2 .^ 2; fval = hypot (x1_c1, x2_c2); y = intersect (y, fval); sqr_y = y .^ 2; sqr_x1_c1 = intersect (sqr_x1_c1, sqr_y - sqr_x2_c2); sqr_x2_c2 = intersect (sqr_x2_c2, sqr_y - sqr_x1_c1); x1_c1 = sqrrev (sqr_x1_c1, x1_c1); x2_c2 = sqrrev (sqr_x2_c2, x2_c2); cx1 = intersect (x1, x1_c1 + c1); cx2 = intersect (x2, x2_c2 + c2); endfunction @end group @group ## Ring 1 with center at (1, 3) ## Ring 2 with center at (2, -1) ctc_ring1 = @@(y, x1, x2) ctc_ring (y, 1, 3, x1, x2); ctc_ring2 = @@(y, x1, x2) ctc_ring (y, 2, -1, x1, x2); @end group @end ifset @group @c doctest: +SKIP ## Intersect ring 1 with radius 3..4 and ring 2 with radius 5..6 ctc_intersection_of_rings = ctc_intersect (ctc_ring1, "[3, 4]", ... ctc_ring2, "[5, 6]"); @end group @group ## Compute a paving to approximate the intersection of rings ## in the area x, y = -10..10 [~, paving] = fsolve (ctc_intersection_of_rings, ... infsup ("[-10, 10] [-10, 10]"), ... struct ("Contract", true)); plot (paving(1, :), paving(2, :)) axis equal @end group @end example interval-1.4.1/doc/image/contractor-rings-union.m.texinfo0000644000000000000000000000275512657475772021632 0ustar 00000000000000@c This is part of the GNU Octave Interval Package Manual. @c Copyright 2015-2016 Oliver Heimlich. @c See the file manual.texinfo for copying conditions. @documentencoding UTF-8 @example @group @c doctest: skip ## General ring contractor function [fval, cx1, cx2] = ctc_ring (y, c1, c2, x1, x2) ## Forward evaluation x1_c1 = x1 - c1; x2_c2 = x2 - c2; sqr_x1_c1 = x1_c1 .^ 2; sqr_x2_c2 = x2_c2 .^ 2; fval = hypot (x1_c1, x2_c2); ## Reverse evaluation y = intersect (y, fval); sqr_y = y .^ 2; sqr_x1_c1 = intersect (sqr_x1_c1, sqr_y - sqr_x2_c2); sqr_x2_c2 = intersect (sqr_x2_c2, sqr_y - sqr_x1_c1); x1_c1 = sqrrev (sqr_x1_c1, x1_c1); x2_c2 = sqrrev (sqr_x2_c2, x2_c2); cx1 = intersect (x1, x1_c1 + c1); cx2 = intersect (x2, x2_c2 + c2); endfunction @end group @group ## Ring 1 with center at (1, 3) ## Ring 2 with center at (2, -1) ctc_ring1 = @@(y, x1, x2) ctc_ring (y, 1, 3, x1, x2); ctc_ring2 = @@(y, x1, x2) ctc_ring (y, 2, -1, x1, x2); @end group @group ## Unite ring 1 with radius 3..4 and ring 2 with radius 5..6 ctc_union_of_rings = ctc_union (ctc_ring1, "[3, 4]", ... ctc_ring2, "[5, 6]"); @end group @group ## Compute a paving to approximate the union of rings ## in the area x, y = -10..10 [~, paving] = fsolve (ctc_union_of_rings, ... infsup ("[-10, 10] [-10, 10]"), ... struct ("Contract", true)); plot (paving(1, :), paving(2, :)) axis equal @end group @end example interval-1.4.1/doc/image/interval-plot3.m.texinfo0000644000000000000000000000102512657475772020056 0ustar 00000000000000@c This is part of the GNU Octave Interval Package Manual. @c Copyright 2015-2016 Oliver Heimlich. @c See the file manual.texinfo for copying conditions. @documentencoding UTF-8 @example @group @c doctest: skip red = [220 50 47] ./ 255; shade = [238 232 213] ./ 255; @end group @group x = midrad (1 : 6, 0.25); y = midrad (-3 : 3, 0.25); [x, y] = meshgrid (x, y); z = atan2 (y, x); plot3 (x, y, z, shade, red) @end group @group view ([-35, 30]) box off set (gca, "xgrid", "on", "ygrid", "on", "zgrid", "on") @end group @end example interval-1.4.1/doc/image/interval-sombrero.m0000644000000000000000000000243712657475772017202 0ustar 00000000000000## This is part of the GNU Octave Interval Package Manual. ## Copyright 2015-2016 Oliver Heimlich. ## See the file manual.texinfo for copying conditions. clf hold on light = [253 246 227] ./ 255; blue = [38 139 210] ./ 255; green = [133 153 0] ./ 255; yellow = [181 137 0] ./ 255; orange = [203 75 22] ./ 255; red = [220 50 47] ./ 255; range = mince (infsupdec (-8, 8), 13); [x, y] = meshgrid (range); h = hypot (x, y); z = sin (h) ./ h; ## The sombrero function would suffer from the dependency problem ## Thus, we compute an interval version of the function, which works around it. select = mag (h) < pi; z (select) = hull (sin (mag (h (select))) ./ mag (h (select)), ... sin (mig (h (select))) ./ mig (h (select))); z (mig (h) == 0) = union (z (mig (h) == 0), 1); flat = sup (z) < .3; low = ismember (sup (z), infsup (0.3, 0.8)); mid = ismember (sup (z), infsup (0.8, 0.9)); high = ismember (sup (z), infsup (0.9, 1)); top = sup (z) >= 1; plot3 (x (flat), y (flat), z (flat), blue, light) plot3 (x (low), y (low), z (low), green, light) plot3 (x (mid), y (mid), z (mid), yellow, light) plot3 (x (high), y (high), z (high), orange, light) plot3 (x (top), y (top), z (top), red, light) view ([-37.5, 30]) zlim ([-.4, 1]) box off set (gca, "xgrid", "on", "ygrid", "on", "zgrid", "on") interval-1.4.1/doc/image/interval-vs-normal-plot.m.texinfo0000644000000000000000000000115012657475772021706 0ustar 00000000000000@c This is part of the GNU Octave Interval Package Manual. @c Copyright 2015-2016 Oliver Heimlich. @c See the file manual.texinfo for copying conditions. @documentencoding UTF-8 @example @group @c doctest: skip hold on blue = [38 139 210] ./ 255; shade = [238 232 213] ./ 255; @end group @group ## Interval plotting x = mince (2*infsup (0, "pi"), 6); plot (x, sin (x), shade) @end group @group ## Classical plotting x = linspace (0, 2*pi, 7); plot (x, sin (x), 'linewidth', 2, 'color', blue) @end group @group set (gca, 'XTick', 0 : pi : 2*pi) set (gca, 'XTickLabel', @{'0', 'pi', '2 pi'@}) @end group @end example interval-1.4.1/doc/image/inverse-power.svg0000644000000000000000000010454112657475772016677 0ustar 00000000000000 Inserse Power Functionimage/svg+xmlInserse Power Function2012-10-11Oliver HeimlichCopyright 2012-2016 Oliver Heimlichown workGraphical interpretation of reverse power operations. The (twodimensional) inverse image of z is hatched and outlined in the figure, in the shown example it is z = [2, 3]. A, for given intervals y and z find every x with x^y ∩ z ≠ Ø. B, for given intervals x and z find every y with x^y ∩ z ≠ Ø. x x y A B x y y -1 -2 0 1 2 2 1 0 -1 -2 0 1 2 2 1 0 interval-1.4.1/doc/image/octave-interval.ly0000644000000000000000000000122312657475772017013 0ustar 00000000000000%% This is part of the GNU Octave Interval Package Manual. %% Copyright 2015-2016 Oliver Heimlich. %% See the file manual.texinfo for copying conditions. \include "lilypond-book-preamble.ly" \paper { indent = 0\mm line-width = 6\in % offset the left padding, also add 1mm as lilypond creates cropped % images with a little space on the right line-width = #(- line-width (* mm 3.000000) (* mm 1)) } \score { % Between d' and d'' lies an octave interval. \new Voice = "" { { 1 } } % Frequency of d' in just intonation is approx. 293,7 Hz, % wheras d'' has this doubled. \addlyrics { \lyricmode { "[293, 588]" } } \layout { } } interval-1.4.1/doc/image/poly-example-roots-simple.m.texinfo0000644000000000000000000000231212657475772022242 0ustar 00000000000000@c This is part of the GNU Octave Interval Package Manual. @c Copyright 2015-2016 Oliver Heimlich. @c Copyright 2015 Helmut Podhaisky. @c See the file manual.texinfo for copying conditions. @documentencoding UTF-8 @example @group @c doctest: +SKIP f = @@(x,y) ... -(5.*y - 20.*y.^3 + 16.*y.^5).^6 + ... (-(5.*x - 20.*x.^3 + 16.*x.^5).^3 + ... 5.*y - 20.*y.^3 + 16.*y.^5).^2; X = Y = infsup ("[-1, 1]"); has_roots = n = 1; @end group @group for iter = 1 : 10 ## Bisect [i,j] = ind2sub ([n,n], has_roots); X = infsup ([X.inf,X.inf,X.mid,X.mid],[X.mid,X.mid,X.sup,X.sup]); Y = infsup ([Y.inf,Y.mid,Y.inf,Y.mid],[Y.mid,Y.sup,Y.mid,Y.sup]); ii = [2*(i-1)+1,2*(i-1)+2,2*(i-1)+1,2*(i-1)+2] ; jj = [2*(j-1)+1,2*(j-1)+1,2*(j-1)+2,2*(j-1)+2] ; has_roots = sub2ind ([2*n,2*n], ii, jj); n *= 2; ## Check if function value covers zero fval = f (X, Y); zero_contained = find (ismember (0, fval)); ## Discard values without roots has_roots = has_roots(zero_contained); X = X(zero_contained); Y = Y(zero_contained); endfor @end group @group colormap gray B = false (n); B(has_roots) = true; imagesc (B) axis equal axis off @end group @end example interval-1.4.1/doc/image/poly-example-roots-with-deriv.m.texinfo0000644000000000000000000000375412657475772023046 0ustar 00000000000000@c This is part of the GNU Octave Interval Package Manual. @c Copyright 2015-2016 Oliver Heimlich. @c Copyright 2015 Helmut Podhaisky. @c See the file manual.texinfo for copying conditions. @documentencoding UTF-8 @example @group @c doctest: +SKIP f_dx = @@(x,y) ... -6.*(5 - 60.*x.^2 + 80.*x.^4) .* ... (5.*x - 20.*x.^3 + 16.*x.^5).^2 .* ... (-(5.*x - 20.*x.^3 + 16.*x.^5).^3 + ... 5.*y - 20.*y.^3 + 16.*y.^5); f_dy = @@(x,y) ... -6.*(5 - 60.*y.^2 + 80.*y.^4) .* ... (5.*y - 20.*y.^3 + 16.*y.^5).^5 + ... 2.*(5 - 60.*y.^2 + 80.*y.^4) .* ... (-(5.*x - 20.*x.^3 + 16.*x.^5).^3 + ... 5.*y - 20.*y.^3 + 16.*y.^5); @ifset m-file f = @@(x,y) ... -(5.*y - 20.*y.^3 + 16.*y.^5).^6 + ... (-(5.*x - 20.*x.^3 + 16.*x.^5).^3 + ... 5.*y - 20.*y.^3 + 16.*y.^5).^2; X = Y = infsup ("[-1, 1]"); has_roots = n = 1; @end ifset @end group @group for iter = 1 : 10 @ifset m-file ## Bisect [i,j] = ind2sub ([n,n], has_roots); X = infsup ([X.inf,X.inf,X.mid,X.mid],[X.mid,X.mid,X.sup,X.sup]); Y = infsup ([Y.inf,Y.mid,Y.inf,Y.mid],[Y.mid,Y.sup,Y.mid,Y.sup]); ii = [2*(i-1)+1,2*(i-1)+2,2*(i-1)+1,2*(i-1)+2] ; jj = [2*(j-1)+1,2*(j-1)+1,2*(j-1)+2,2*(j-1)+2] ; has_roots = sub2ind ([2*n,2*n], ii, jj); n *= 2; @end ifset @ifclear m-file @dots{} @end ifclear ## Check if function value covers zero fval1 = f (X, Y); fval2 = f (mid (X), mid (Y)) + ... (X - mid (X)) .* f_dx (X, Y) + ... (Y - mid (Y)) .* f_dy (X, Y); fval = intersect (fval1, fval2); @ifclear m-file @dots{} @end ifclear @ifset m-file zero_contained = find (ismember (0, fval)); ## Discard values without roots has_roots = has_roots(zero_contained); X = X(zero_contained); Y = Y(zero_contained); @end ifset endfor @end group @ifset m-file @group colormap gray B = false (n); B(has_roots) = true; imagesc (B) axis equal axis off @end group @end ifset @end example interval-1.4.1/doc/image/poly-example-surf.m0000644000000000000000000000025512657475772017115 0ustar 00000000000000f=@(x,y)-(5.*y - 20.*y.^3 + 16.*y.^5).^6 + (-(5.*x - 20.*x.^3 + 16.*x.^5).^3 + 5.*y - 20.*y.^3 + 16.*y.^5).^2; [x, y] = meshgrid (-1:0.01:1, -1:0.01:1); surf(x, y, f(x, y)) interval-1.4.1/doc/license/apache-2.0.texi0000644000000000000000000002620612657475772016323 0ustar 00000000000000@center Apache License @center Version 2.0, January 2004 @center http://www.apache.org/licenses/ @heading TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION @enumerate 1 @item Definitions. ``License'' shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. ``Licensor'' shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. ``Legal Entity'' shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, ``control'' means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. ``You'' (or ``Your'') shall mean an individual or Legal Entity exercising permissions granted by this License. ``Source'' form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. ``Object'' form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. ``Work'' shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). ``Derivative Works'' shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. ``Contribution'' shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, ``submitted'' means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as ``Not a Contribution." ``Contributor'' shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. @item Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. @item Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. @item Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: @enumerate a @item You must give any other recipients of the Work or Derivative Works a copy of this License; and @item You must cause any modified files to carry prominent notices stating that You changed the files; and @item You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and @item If the Work includes a ``NOTICE'' text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. @end enumerate You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. @item Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. @item Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. @item Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an ``AS IS'' BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. @item Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. @item Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. @end enumerate @heading END OF TERMS AND CONDITIONS @heading APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets ``[]'' replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same ``printed page'' as the copyright notice for easier identification within third-party archives. @smallexample Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at @url{http://www.apache.org/licenses/LICENSE-2.0} Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. @end smallexample interval-1.4.1/doc/license/gpl-3.0.texi0000644000000000000000000010471212657475772015664 0ustar 00000000000000@c The GNU General Public License. @center Version 3, 29 June 2007 @c This file is intended to be included within another document, @c hence no sectioning command or @node. @display Copyright @copyright{} 2007 Free Software Foundation, Inc. @url{http://fsf.org/} Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. @end display @heading Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program---to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. @heading TERMS AND CONDITIONS @html
@end html @enumerate 0 @item Definitions. ``This License'' refers to version 3 of the GNU General Public License. ``Copyright'' also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. ``The Program'' refers to any copyrightable work licensed under this License. Each licensee is addressed as ``you''. ``Licensees'' and ``recipients'' may be individuals or organizations. To ``modify'' a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a ``modified version'' of the earlier work or a work ``based on'' the earlier work. A ``covered work'' means either the unmodified Program or a work based on the Program. To ``propagate'' a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To ``convey'' a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays ``Appropriate Legal Notices'' to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. @item Source Code. The ``source code'' for a work means the preferred form of the work for making modifications to it. ``Object code'' means any non-source form of a work. A ``Standard Interface'' means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The ``System Libraries'' of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A ``Major Component'', in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The ``Corresponding Source'' for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. @item Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. @item Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. @item Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. @item Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: @html
@end html @enumerate a @item The work must carry prominent notices stating that you modified it, and giving a relevant date. @item The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to ``keep intact all notices''. @item You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. @item If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. @end enumerate A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an ``aggregate'' if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. @item Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: @html
@end html @enumerate a @item Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. @item Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. @item Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. @item Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. @item Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. @end enumerate A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A ``User Product'' is either (1) a ``consumer product'', which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, ``normally used'' refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. ``Installation Information'' for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. @item Additional Terms. ``Additional permissions'' are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: @html
@end html @enumerate a @item Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or @item Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or @item Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or @item Limiting the use for publicity purposes of names of licensors or authors of the material; or @item Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or @item Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. @end enumerate All other non-permissive additional terms are considered ``further restrictions'' within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. @item Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. @item Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. @item Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An ``entity transaction'' is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. @item Patents. A ``contributor'' is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's ``contributor version''. A contributor's ``essential patent claims'' are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, ``control'' includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a ``patent license'' is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To ``grant'' such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. ``Knowingly relying'' means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is ``discriminatory'' if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. @item No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. @item Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. @item Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License ``or any later version'' applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. @item Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW@. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM ``AS IS'' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE@. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU@. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. @item Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. @item Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. @end enumerate @heading END OF TERMS AND CONDITIONS @heading How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the ``copyright'' line and a pointer to where the full notice is found. @smallexample @var{one line to give the program's name and a brief idea of what it does.} Copyright (C) @var{year} @var{name of author} This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE@. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see @url{http://www.gnu.org/licenses/}. @end smallexample Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: @smallexample @var{program} Copyright (C) @var{year} @var{name of author} This program comes with ABSOLUTELY NO WARRANTY; for details type @samp{show w}. This is free software, and you are welcome to redistribute it under certain conditions; type @samp{show c} for details. @end smallexample The hypothetical commands @samp{show w} and @samp{show c} should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an ``about box''. You should also get your employer (if you work as a programmer) or school, if any, to sign a ``copyright disclaimer'' for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see @url{http://www.gnu.org/licenses/}. The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read @url{http://www.gnu.org/philosophy/why-not-lgpl.html}. interval-1.4.1/doc/license/libieeep1788.NOTICE0000644000000000000000000000053512657475772016720 0ustar 00000000000000libieeep1788 ============ Copyright 2013 - 2015 Marco Nehmeier (nehmeier@informatik.uni-wuerzburg.de) Department of Computer Science, University of Wuerzburg, Germany This product includes software developed at Chair of Software Engineering, Department of Computer Science, University of Wuerzburg, Germany http://se.informatik.uni-wuerzburg.de/ interval-1.4.1/doc/manual.css0000644000000000000000000001045012657475772014251 0ustar 00000000000000/* This is part of the GNU Octave Interval Package Manual. Copyright 2015-2016 Oliver Heimlich. See the file manual.texinfo for copying conditions. */ @font-face { font-family: 'Roboto Condensed'; src: local('Roboto Condensed'), url('https://fontlibrary.org/assets/fonts/roboto-condensed/71405335c70332d94afd24ae4f06c9b2/4b8b4b377e8cb358cf886d13c7bb287c/RobotoCondensedBold.ttf') format('truetype'); font-weight: bold; font-style: normal; } @font-face { font-family: 'Roboto Condensed'; src: local('Roboto Condensed'), url('https://fontlibrary.org/assets/fonts/roboto-condensed/71405335c70332d94afd24ae4f06c9b2/9b1d05d1b332e5b95ad86e71ca8404fb/RobotoCondensedBoldItalic.ttf') format('truetype'); font-weight: bold; font-style: italic; } @font-face { font-family: 'Roboto Condensed'; src: local('Roboto Condensed'), url('https://fontlibrary.org/assets/fonts/roboto-condensed/71405335c70332d94afd24ae4f06c9b2/d02fffb6890e4f28023dd149916d1b8a/RobotoCondensedItalic.ttf') format('truetype'); font-weight: normal; font-style: italic; } @font-face { font-family: 'Roboto Condensed'; src: local('Roboto Condensed'), url('https://fontlibrary.org/assets/fonts/roboto-condensed/71405335c70332d94afd24ae4f06c9b2/b0b1845ecce8ab6a503971e808a8409c/RobotoCondensedRegular.ttf') format('truetype'); font-weight: normal; font-style: normal; } @font-face { font-family: 'Fantasque Sans Mono'; src: local('Fantasque Sans Mono'), url('https://fontlibrary.org/assets/fonts/fantasque-sans-mono/db52617ba875d08cbd8e080ca3d9f756/b145f0e884b2da8f1b112d26e7cefd3d/FantasqueSansMonoBold.ttf') format('truetype'); font-weight: bold; font-style: normal; } @font-face { font-family: 'Fantasque Sans Mono'; src: local('Fantasque Sans Mono'), url('https://fontlibrary.org/assets/fonts/fantasque-sans-mono/db52617ba875d08cbd8e080ca3d9f756/49319cbd53210c32099631ac89b1e70a/FantasqueSansMonoBoldItalic.ttf') format('truetype'); font-weight: bold; font-style: italic; } @font-face { font-family: 'Fantasque Sans Mono'; src: local('Fantasque Sans Mono'), url('https://fontlibrary.org/assets/fonts/fantasque-sans-mono/db52617ba875d08cbd8e080ca3d9f756/5c07fe59e84e4594ffa87ae1a72b130d/FantasqueSansMonoItalic.ttf') format('truetype'); font-weight: normal; font-style: italic; } @font-face { font-family: 'Fantasque Sans Mono'; src: local('Fantasque Sans Mono'), url('https://fontlibrary.org/assets/fonts/fantasque-sans-mono/db52617ba875d08cbd8e080ca3d9f756/cc70dc22137e92aaef169e1de38a6ec7/FantasqueSansMonoRegular.ttf') format('truetype'); font-weight: normal; font-style: normal; } body > * { max-width: 42em; } div.header { max-width: 100%; } hr { margin-left: 0; border: none; border-top: 3px double #657b83; } div.header, div.float-caption { color: #657b83; } ul, ol { max-width: 39.5em; padding-left: 2.5em; } div.example, div.display, div.indentedblock, div.smalldisplay, div.lisp, div.smallindentedblock, div.smallexample, div.smalllisp { max-width: 38.8em; margin-left: 3.2em; } blockquote { margin-left: 3.2em; margin-right: 3.2em; max-width: 35.6em; } body, span.roman { font-family: 'Roboto Condensed', sans-serif; } body { padding-left: 7.5em; padding-right: 7.5em; } h1, h2, h3, h4, h5, pre.menu-comment { font-family: 'Roboto Condensed', serif; text-align: left !important; } div.float table, img { margin-left: auto; margin-right: auto; } div.float table { width: 38em; } div.float table, div.float th { border-collapse: collapse; border-top: 1px solid black; border-bottom: 1px solid black; } div.float th, div.float td { padding: 0.5em; } dd > p:first-child { margin-top: 0; } a { color: #268bd2; } a:visited { color: #d33682; } div.alpha-list + ol { list-style-type:lower-alpha; } div.zero-list + ol { counter-reset: item -1; } div.zero-list + ol > li { display:block; } div.zero-list + ol > li:before { content: counter(item) "."; counter-increment: item; display:inline-block; margin-left: -2.5em; min-width: 2em; margin-right: 0.2em; text-align: right; } .sf-logo { display:block; text-align: center; padding-top: 2em; padding-bottom: 2em; } code, samp { font-family: 'Fantasque Sans Mono', monospace; padding: 0 0.1em; font-style: italic; } pre.example, pre.smallexample, pre.verbatim { font-family: 'Fantasque Sans Mono', monospace; } pre.example { background-color: #fdf6e3; color: #657b83; padding: 0.5em; } .example { margin-bottom: 1em; } .example + .example { margin-top: -0.5em } interval-1.4.1/doc/manual.texinfo0000644000000000000000000000642012657475772015137 0ustar 00000000000000\input texinfo @setfilename manual.info @settitle GNU Octave Interval Package Manual @documentencoding UTF-8 @tex % U and the following characters have been predefined in TexInfo 6 @ifcommandnotdefined U \DeclareUnicodeCharacter{00A0}{\ } \DeclareUnicodeCharacter{00A7}{\S} \DeclareUnicodeCharacter{00B1}{$\pm$} \DeclareUnicodeCharacter{00B2}{${}^2$} \DeclareUnicodeCharacter{00B7}{$\cdot$} \DeclareUnicodeCharacter{00BD}{1/2} \DeclareUnicodeCharacter{00D7}{$\times$} \DeclareUnicodeCharacter{00F7}{$\div$} @end ifcommandnotdefined \DeclareUnicodeCharacter{03C0}{$\pi$} \DeclareUnicodeCharacter{202F}{\thinspace} \DeclareUnicodeCharacter{2080}{$_0$} \DeclareUnicodeCharacter{2081}{$_1$} \DeclareUnicodeCharacter{2200}{$\forall$} \DeclareUnicodeCharacter{2203}{$\exists$} \DeclareUnicodeCharacter{2208}{$\in$} \DeclareUnicodeCharacter{221E}{$\infty$} \DeclareUnicodeCharacter{2227}{$\wedge$} \DeclareUnicodeCharacter{2229}{$\cap$} \DeclareUnicodeCharacter{2264}{$\leq$} \DeclareUnicodeCharacter{2265}{$\geq$} \DeclareUnicodeCharacter{2282}{$\subset$} \DeclareUnicodeCharacter{2287}{$\supseteq$} \DeclareUnicodeCharacter{2713}{$\ast$} @end tex @copying This manual is for the GNU Octave interval package, version @value{version}. Copyright @copyright{} 2015–2016 Oliver Heimlich Permission is granted to copy, distribute and/or modify this document under the terms of the GNU General Public License, Version 3 or any later version published by the Free Software Foundation. A copy of the license is included in @ref{GNU General Public License}. @end copying @macro myimage{file, description} @ifnothtml @center @image{\file\,,,\description\,} @end ifnothtml @html \description\ @end html @end macro @macro funref{function} @inlinefmtifelse{html,@uref{@inlineifset{octave-forge,..}@inlineifclear{octave-forge,http://octave.sourceforge.net/interval}/function/\function\.html,\function\},@command{\function\}} @end macro @titlepage @title GNU Octave Interval Package @subtitle User Manual @vskip 0pt plus 3filll @myimage{image/interval-sombrero.m,Interval sombrero} @vskip 0pt plus 1filll @author Oliver Heimlich @page @vskip 0pt plus 1filll @insertcopying @end titlepage @ifnottex @insertcopying @end ifnottex @node Top @ifnottex @top @end ifnottex @menu How to install and use the interval package for GNU Octave * Preface:: Background information before usage * Getting Started:: Quick-start guide for the basics * Introduction to Interval Arithmetic:: Fundamental concepts * Examples:: Showcase of use cases * Advanced Topics:: Get the most out of it Appendix * IEEE Std 1788-2015:: IEEE standard for interval arithmetic * GNU General Public License:: The license for this software and its manual @end menu @ifhtml @myimage{image/interval-sombrero.m,Interval sombrero} @end ifhtml @contents @node Preface @include chapter/preface.texinfo @node Getting Started @include chapter/getting-started.texinfo @node Introduction to Interval Arithmetic @include chapter/introduction-to-interval-arithmetic.texinfo @node Examples @include chapter/examples.texinfo @node Advanced Topics @include chapter/advanced-topics.texinfo @node IEEE Std 1788-2015 @include chapter/ieee-1788.texinfo @node GNU General Public License @appendix GNU General Public License @include license/gpl-3.0.texi @bye interval-1.4.1/inst/@infsup/abs.m0000644000000000000000000000565612657475772015035 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} abs (@var{X}) ## ## Compute the absolute value of numbers. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## abs (infsup (2.5, 3.5)) ## @result{} ans = [2.5, 3.5] ## abs (infsup (-0.5, 5.5)) ## @result{} ans = [0, 5.5] ## @end group ## @end example ## @seealso{@@infsup/mag, @@infsup/mig} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-04 function result = abs (x) if (nargin ~= 1) print_usage (); return endif ## This is already correct, if the interval(s) are non-negative. l = x.inf; u = x.sup; ## This is even correct, if the interval(s) are empty. notpositive = x.sup <= 0; l (notpositive) = -x.sup (notpositive); u (notpositive) = -x.inf (notpositive); zerointerior = x.inf < 0 & not (notpositive); l (zerointerior) = 0; u (zerointerior) = max (-x.inf (zerointerior), x.sup (zerointerior)); result = infsup (l, u); endfunction %!test "Empty interval"; %! assert (abs (infsup ()) == infsup ()); %!test "Singleton intervals"; %! assert (abs (infsup (1)) == infsup (1)); %! assert (abs (infsup (0)) == infsup (0)); %! assert (abs (infsup (-1)) == infsup (1)); %! assert (abs (infsup (realmax)) == infsup (realmax)); %! assert (abs (infsup (realmin)) == infsup (realmin)); %! assert (abs (infsup (-realmin)) == infsup (realmin)); %! assert (abs (infsup (-realmax)) == infsup (realmax)); %!test "Bounded intervals"; %! assert (abs (infsup (1, 2)) == infsup (1, 2)); %! assert (abs (infsup (0, 1)) == infsup (0, 1)); %! assert (abs (infsup (-1, 1)) == infsup (0, 1)); %! assert (abs (infsup (-1, 0)) == infsup (0, 1)); %! assert (abs (infsup (-2, -1)) == infsup (1, 2)); %!test "Unbounded intervals"; %! assert (abs (infsup (0, inf)) == infsup (0, inf)); %! assert (abs (infsup (-inf, inf)) == infsup (0, inf)); %! assert (abs (infsup (-inf, 0)) == infsup (0, inf)); %! assert (abs (infsup (1, inf)) == infsup (1, inf)); %! assert (abs (infsup (-1, inf)) == infsup (0, inf)); %! assert (abs (infsup (-inf, -1)) == infsup (1, inf)); %! assert (abs (infsup (-inf, 1)) == infsup (0, inf)); %!test "from the documentation string"; %! assert (abs (infsup (2.5, 3.5)) == infsup (2.5, 3.5)); %! assert (abs (infsup (-0.5, 5.5)) == infsup (0, 5.5)); interval-1.4.1/inst/@infsup/absrev.m0000644000000000000000000000640212657475772015540 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {@var{X} =} absrev (@var{C}, @var{X}) ## @deftypemethodx {@@infsup} {@var{X} =} absrev (@var{C}) ## ## Compute the reverse absolute value function. ## ## That is, an enclosure of all @code{x ∈ @var{X}} where ## @code{abs (x) ∈ @var{C}}. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## absrev (infsup (-2, 1)) ## @result{} ans = [-1, +1] ## @end group ## @end example ## @seealso{@@infsup/abs} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = absrev (c, x) if (nargin < 1 || nargin > 2) print_usage (); return endif if (not (isa (c, "infsup"))) c = infsup (c); endif if (nargin < 2) x = infsup (-inf, inf); elseif (not (isa (x, "infsup"))) x = infsup (x); endif ## Compute the pre-image of abs for positive and negative x separately. p = intersect (c, infsup (0, inf)); n = -p; result = union (intersect (p, x), intersect (n, x)); endfunction %!test "Empty interval"; %! assert (absrev (infsup ()) == infsup ()); %! assert (absrev (infsup (0, 1), infsup ()) == infsup ()); %! assert (absrev (infsup (0, 1), infsup (7, 9)) == infsup ()); %! assert (absrev (infsup (), infsup (0, 1)) == infsup ()); %! assert (absrev (infsup (-2, -1)) == infsup ()); %!test "Singleton intervals"; %! assert (absrev (infsup (1)) == infsup (-1, 1)); %! assert (absrev (infsup (0)) == infsup (0)); %! assert (absrev (infsup (-1)) == infsup ()); %! assert (absrev (infsup (realmax)) == infsup (-realmax, realmax)); %! assert (absrev (infsup (realmin)) == infsup (-realmin, realmin)); %! assert (absrev (infsup (-realmin)) == infsup ()); %! assert (absrev (infsup (-realmax)) == infsup ()); %!test "Bound intervals"; %! assert (absrev (infsup (1, 2)) == infsup (-2, 2)); %! assert (absrev (infsup (1, 2), infsup (0, 2)) == infsup (1, 2)); %! assert (absrev (infsup (0, 1), infsup (-0.5, 2)) == infsup (-0.5, 1)); %! assert (absrev (infsup (-1, 1)) == infsup (-1, 1)); %! assert (absrev (infsup (-1, 0)) == infsup (0)); %!test "Unbound intervals"; %! assert (absrev (infsup (0, inf)) == infsup (-inf, inf)); %! assert (absrev (infsup (-inf, inf)) == infsup (-inf, inf)); %! assert (absrev (infsup (-inf, 0)) == infsup (0)); %! assert (absrev (infsup (1, inf), infsup (-inf, 0)) == infsup (-inf, -1)); %! assert (absrev (infsup (-1, inf)) == infsup (-inf, inf)); %! assert (absrev (infsup (-inf, -1)) == infsup ()); %! assert (absrev (infsup (-inf, 1)) == infsup (-1, 1)); %!test "from the documentation string"; %! assert (absrev (infsup (-2, 1)) == infsup (-1, 1)); interval-1.4.1/inst/@infsup/acos.m0000644000000000000000000000501312657475772015200 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} acos (@var{X}) ## ## Compute the inverse cosine in radians (arccosine). ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## acos (infsup (.5)) ## @result{} ans ⊂ [1.0471, 1.0472] ## @end group ## @end example ## @seealso{@@infsup/cos} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-06 function result = acos (x) if (nargin ~= 1) print_usage (); return endif x = intersect (x, infsup (-1, 1)); ## acos is monotonically decreasing from (-1, pi) to (+1, 0) l = mpfr_function_d ('acos', -inf, x.sup); u = mpfr_function_d ('acos', +inf, x.inf); emptyresult = isempty (x); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "Empty interval"; %! assert (acos (infsup ()) == infsup ()); %!test "Singleton intervals"; %! assert (acos (infsup (-1)) == infsup ("pi")); %! assert (subset (acos (infsup (-.5)), union ((infsup ("pi") / 2), infsup ("pi")))); %! assert (acos (infsup (0)) == infsup ("pi") / 2); %! assert (subset (acos (infsup (.5)), union ((infsup ("pi") / 2), infsup (0)))); %! assert (acos (infsup (1)) == infsup (0)); %!test "Bounded intervals"; %! assert (acos (infsup (-1, 0)) == union ((infsup ("pi") / 2), infsup ("pi"))); %! assert (acos (infsup (0, 1)) == union ((infsup ("pi") / 2), infsup (0))); %! assert (acos (infsup (-1, 1)) == infsup (0, "pi")); %! assert (acos (infsup (-2, 2)) == infsup (0, "pi")); %!test "Unbounded intervals"; %! assert (acos (infsup (0, inf)) == union ((infsup ("pi") / 2), infsup (0))); %! assert (acos (infsup (-inf, 0)) == union ((infsup ("pi") / 2), infsup ("pi"))); %! assert (acos (infsup (-inf, inf)) == infsup (0, "pi")); %!test "from the documentation string"; %! assert (acos (infsup (.5)) == "[0x1.0C152382D7365, 0x1.0C152382D7366]"); interval-1.4.1/inst/@infsup/acosh.m0000644000000000000000000000436112657475772015355 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} acosh (@var{X}) ## ## Compute the inverse hyperbolic cosine. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## acosh (infsup (2)) ## @result{} ans ⊂ [1.3169, 1.317] ## @end group ## @end example ## @seealso{@@infsup/cosh} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-07 function result = acosh (x) if (nargin ~= 1) print_usage (); return endif x = intersect (x, infsup (1, inf)); ## acosh is monotonically increasing from (1, 0) to (inf, inf) l = mpfr_function_d ('acosh', -inf, x.inf); u = mpfr_function_d ('acosh', +inf, x.sup); emptyresult = isempty (x); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "Empty interval"; %! assert (acosh (infsup ()) == infsup ()); %!test "Singleton intervals"; %! assert (acosh (infsup (0)) == infsup ()); %! assert (acosh (infsup (1)) == infsup (0)); %! x = infsup (1 : 3 : 100); %! assert (min (subset (acosh (x), log (x + sqrt (x + 1) .* sqrt (x - 1))))); %!test "Bounded intervals"; %! assert (acosh (infsup (0, 1)) == infsup (0)); %!test "Unbounded intervals"; %! assert (acosh (infsup (-inf, 0)) == infsup ()); %! assert (acosh (infsup (-inf, 1)) == infsup (0)); %! assert (acosh (infsup (0, inf)) == infsup (0, inf)); %! assert (acosh (infsup (1, inf)) == infsup (0, inf)); %! assert (subset (acosh (infsup (2, inf)), infsup (1, inf))); %!test "from the documentation string"; %! assert (acosh (infsup (2)) == "[0x1.5124271980434, 0x1.5124271980435]"); interval-1.4.1/inst/@infsup/asin.m0000644000000000000000000000323012657475772015204 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} asin (@var{X}) ## ## Compute the inverse sine in radians (arcsine). ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## asin (infsup (.5)) ## @result{} ans ⊂ [0.52359, 0.5236] ## @end group ## @end example ## @seealso{@@infsup/sin} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-06 function result = asin (x) if (nargin ~= 1) print_usage (); return endif x = intersect (x, infsup (-1, 1)); ## asin is monotonically increasing from (-1, -pi/2) to (1, pi/2) l = mpfr_function_d ('asin', -inf, x.inf); u = mpfr_function_d ('asin', +inf, x.sup); emptyresult = isempty (x); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "Empty interval"; %! assert (asin (infsup ()) == infsup ()); %!test "from the documentation string"; %! assert (asin (infsup (.5)) == "[0x1.0C152382D7365p-1, 0x1.0C152382D7366p-1]"); interval-1.4.1/inst/@infsup/asinh.m0000644000000000000000000000275412657475772015366 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} asinh (@var{X}) ## ## Compute the inverse hyperbolic sine. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## asinh (infsup (1)) ## @result{} ans ⊂ [0.88137, 0.88138] ## @end group ## @end example ## @seealso{@@infsup/sinh} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-07 function result = asinh (x) if (nargin ~= 1) print_usage (); return endif ## asinh is monotonically increasing ## This also works for empty intervals! l = mpfr_function_d ('asinh', -inf, x.inf); u = mpfr_function_d ('asinh', +inf, x.sup); result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (asinh (infsup (1)) == "[0x1.C34366179D426p-1, 0x1.C34366179D427p-1]"); interval-1.4.1/inst/@infsup/atan.m0000644000000000000000000000303112657475772015174 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} atan (@var{X}) ## ## Compute the inverse tangent in radians. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## atan (infsup (1)) ## @result{} ans ⊂ [0.78539, 0.7854] ## @end group ## @end example ## @seealso{@@infsup/tan, @@infsup/atan2} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-06 function result = atan (x) if (nargin ~= 1) print_usage (); return endif ## atan is monotonically increasing l = mpfr_function_d ('atan', -inf, x.inf); u = mpfr_function_d ('atan', +inf, x.sup); emptyresult = isempty (x); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (atan (infsup (1)) == "[0x1.921FB54442D18p-1, 0x1.921FB54442D19p-1]"); interval-1.4.1/inst/@infsup/atan2.m0000644000000000000000000001027212657475772015263 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} atan2 (@var{Y}, @var{X}) ## ## Compute the inverse tangent with two arguments. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## atan2 (infsup (1), infsup (-1)) ## @result{} ans ⊂ [2.3561, 2.3562] ## @end group ## @end example ## @seealso{@@infsup/tan} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-06 function result = atan2 (y, x) if (nargin ~= 2) print_usage (); return endif if (not (isa (y, "infsup"))) y = infsup (y); endif if (not (isa (x, "infsup"))) x = infsup (x); endif ## Resize, if scalar × matrix if (isscalar (x.inf) ~= isscalar (y.inf)) x.inf = ones (size (y.inf)) .* x.inf; x.sup = ones (size (y.inf)) .* x.sup; y.inf = ones (size (x.inf)) .* y.inf; y.sup = ones (size (x.inf)) .* y.sup; endif ## Partitionize the function's domain ## y ## ^ ## p1 | p2 ## ------0------> ## p4 | p3 x ## x1 = x4 = intersect (x, infsup (-inf, 0)); y1 = y2 = intersect (y, infsup (0, inf)); x2 = x3 = intersect (x, infsup (0, inf)); y3 = y4 = intersect (y, infsup (-inf, 0)); ## Intersect each partition with atan2's domain p1 = not (isempty (x1) | isempty (y1)) & (x1.inf < 0 | y1.sup > 0); p2 = not (isempty (x2) | isempty (y2)) & (x2.sup > 0 | y2.sup > 0); p3 = not (isempty (x3) | isempty (y3)) & (x3.sup > 0 | y3.inf < 0); p4 = not (isempty (x4) | isempty (y4)) & (x4.inf < 0 | y4.inf < 0); ## Prevent wrong limit values of atan2 (0, 0) in cases with y = 0. x1.inf (p1 & y1.sup == 0) = x1.sup (p1 & y1.sup == 0) = -1; x2.inf (p2 & y2.sup == 0) = x2.sup (p2 & y2.sup == 0) = 1; x3.inf (p3 & y3.inf == 0) = x3.sup (p3 & y3.inf == 0) = 1; p4 (y4.inf == 0) = false (); # don't consider y >= 0 in partition 4 ## Prevent wrong limit values of atan2 (0, 0) in cases with x = 0. y1.inf (p1 & x1.inf == 0) = y1.sup (p1 & x1.inf == 0) = 1; y2.inf (p2 & x2.sup == 0) = y2.sup (p2 & x2.sup == 0) = 1; y3.inf (p3 & x3.sup == 0) = y3.sup (p3 & x3.sup == 0) = -1; y4.inf (p4 & x4.inf == 0) = y4.sup (p4 & x4.inf == 0) = -1; ## Fix interval boundaries for y = 0 and x < 0, because atan2 (±0, -eps) = ±pi y1.inf (p1 & y1.inf == 0) = +0; y4.sup (p4 & y4.sup == 0) = -0; ## Compute lower boundary (atan2 is increasing from p4 to p1) l = inf (size (p1)); select = p4; l (select) = mpfr_function_d ('atan2', -inf, y4.sup (select), x4.inf (select)); select = p3 & not (p4); l (select) = mpfr_function_d ('atan2', -inf, y3.inf (select), x3.inf (select)); select = p2 & not (p3 | p4); l (select) = mpfr_function_d ('atan2', -inf, y2.inf (select), x2.sup (select)); select = p1 & not (p2 | p3 | p4); l (select) = mpfr_function_d ('atan2', -inf, y1.sup (select), x1.sup (select)); ## Compute upper boundary (atan2 is decreasing from p1 to p4) u = -inf (size (p1)); select = p1; u (select) = mpfr_function_d ('atan2', +inf, y1.inf (select), x1.inf (select)); select = p2 & not (p1); u (select) = mpfr_function_d ('atan2', +inf, y2.sup (select), x2.inf (select)); select = p3 & not (p1 | p2); u (select) = mpfr_function_d ('atan2', +inf, y3.sup (select), x3.sup (select)); select = p4 & not (p1 | p2 | p3); u (select) = mpfr_function_d ('atan2', +inf, y4.inf (select), x4.sup (select)); ## Now, we have computed l and u for all cases where p1 | p2 | p3 | p4. In all ## other cases, l and u will produce an empty interval. result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (atan2 (infsup (1), infsup (-1)) == "[0x1.2D97C7F3321D2p1, 0x1.2D97C7F3321D3p1]"); interval-1.4.1/inst/@infsup/atan2rev1.m0000644000000000000000000001704712657475772016070 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {@var{Y} =} atan2rev1 (@var{B}, @var{C}, @var{Y}) ## @deftypemethodx {@@infsup} {@var{Y} =} atan2rev1 (@var{B}, @var{C}) ## ## Compute the reverse atan2 function for the first parameter. ## ## That is, an enclosure of all @code{y ∈ @var{Y}} where ## @code{atan2 (y, b) ∈ @var{C}} for any @code{b ∈ @var{B}}. ## ## Accuracy: The result is a valid enclosure. ## ## @example ## @group ## atan2rev1 (infsup (1, 2), infsup ("pi") / 4) ## @result{} ans ⊂ [0.99999, 2.0001] ## @end group ## @end example ## @seealso{@@infsup/atan2} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-19 function result = atan2rev1 (b, c, y) if (nargin < 2 || nargin > 3) print_usage (); return endif if (nargin < 3) y = infsup (-inf, inf); endif if (not (isa (b, "infsup"))) b = infsup (b); endif if (not (isa (c, "infsup"))) c = infsup (c); endif if (not (isa (y, "infsup"))) y = infsup (y); endif ## Resize, if scalar × matrix or vector × matrix or scalar × vector if (rows (b.inf) ~= rows (c.inf)) b.inf = ones (rows (c.inf), columns (b.inf)) .* b.inf; b.sup = ones (rows (c.inf), columns (b.inf)) .* b.sup; c.inf = ones (rows (b.inf), columns (c.inf)) .* c.inf; c.sup = ones (rows (b.inf), columns (c.inf)) .* c.sup; endif if (rows (b.inf) ~= rows (y.inf)) b.inf = ones (rows (y.inf), columns (b.inf)) .* b.inf; b.sup = ones (rows (y.inf), columns (b.inf)) .* b.sup; c.inf = ones (rows (y.inf), columns (c.inf)) .* c.inf; c.sup = ones (rows (y.inf), columns (c.inf)) .* c.sup; y.inf = ones (rows (b.inf), columns (y.inf)) .* y.inf; y.sup = ones (rows (b.inf), columns (y.inf)) .* y.sup; endif if (columns (b.inf) ~= columns (c.inf)) b.inf = ones (rows (b.inf), columns (c.inf)) .* b.inf; b.sup = ones (rows (b.inf), columns (c.inf)) .* b.sup; c.inf = ones (rows (c.inf), columns (b.inf)) .* c.inf; c.sup = ones (rows (c.inf), columns (b.inf)) .* c.sup; endif if (columns (b.inf) ~= columns (y.inf)) b.inf = ones (rows (b.inf), columns (y.inf)) .* b.inf; b.sup = ones (rows (b.inf), columns (y.inf)) .* b.sup; c.inf = ones (rows (c.inf), columns (y.inf)) .* c.inf; c.sup = ones (rows (c.inf), columns (y.inf)) .* c.sup; y.inf = ones (rows (y.inf), columns (b.inf)) .* y.inf; y.sup = ones (rows (y.inf), columns (b.inf)) .* y.sup; endif pi = infsup ("pi"); idx.type = '()'; emptyresult = isempty (y) | isempty (b) | isempty (c) | ... c.inf >= sup (pi) | c.sup <= inf (-pi); result = infsup (inf (size (y.inf)), -inf (size (y.inf))); ## c1 is the part of c where y >= 0 and x <= 0 c1 = intersect (c, infsup (inf (pi) / 2, sup (pi))); select = not (emptyresult | isempty (c1) | ... b.inf > 0 | y.sup < 0 | c1.sup == inf (pi) / 2 | ... (b.inf >= 0 & y.sup <= 0) | (b.inf >= 0 & c1.inf > inf (pi) / 2)); if (any (any (select))) ## The inverse function is y = b * tan (c) ## minimum is located at b.sup, c.sup ## maximum is located at b.inf, c.inf l = zeros (size (result.inf)); select_l = select & c1.sup < sup (pi) & b.sup < 0; l (select_l) = ... max (0, ... inf (b.sup (select_l) .* tan (infsup (c1.sup (select_l))))); u = inf (size (result.inf)); select_u = select & c1.inf > inf (pi) / 2 & b.inf > -inf; u (select_u) = ... sup (b.inf (select_u) .* tan (infsup (c1.inf (select_u)))); idx.subs = {select}; result = subsasgn (result, idx, ... intersect (subsref (y, idx), ... infsup (subsref (l, idx), subsref (u, idx)))); endif ## c2 is the part of c where y >= 0 and x >= 0 c2 = intersect (c, infsup (0, sup (pi) / 2)); select = not (emptyresult | isempty (c2) | b.sup < 0 | y.sup < 0 | ... c2.inf == sup (pi) / 2 | ... (b.sup <= 0 & y.sup <= 0) | (b.sup <= 0 & c2.sup < sup (pi) / 2)); if (any (any (select))) ## The inverse function is y = b * tan (c) ## minimum is located at b.inf, c.inf ## maximum is located at b.sup, c.sup l = zeros (size (result.inf)); select_l = select & c2.inf > 0 & b.inf > 0; l (select_l) = ... max (0, ... inf (b.inf (select_l) .* tan (infsup (c2.inf (select_l))))); u = inf (size (result.inf)); u (c2.sup == 0) = 0; select_u = select & c2.sup ~= 0 & c2.sup < sup (pi) / 2 & b.sup < inf; u (select_u) = ... sup (b.sup (select_u) .* tan (infsup (c2.sup (select_u)))); idx.subs = {select}; result = subsasgn (result, idx, ... union (subsref (result, idx), ... intersect (subsref (y, idx), ... infsup (subsref (l, idx), subsref (u, idx))))); endif ## c3 is the part of c where y <= 0 and x >= 0 c3 = intersect (c, infsup (inf (-pi) / 2, 0)); select = not (emptyresult | isempty (c3) | b.sup < 0 | y.inf > 0 | ... c3.sup == inf (-pi) / 2 | (b.sup <= 0 & y.inf >= 0) | ... (b.sup <= 0 & c2.inf > inf (-pi) / 2)); if (any (any (select))) ## The inverse function is y = b * tan (c) ## minimum is located at b.sup, c.inf ## maximum is located at b.inf, c.sup l = -inf (size (result.inf)); l (c3.inf == 0) = 0; select_l = select & c3.inf ~= 0 & c3.inf > inf (-pi) / 2 & b.sup < inf; l (select_l) = ... inf (b.sup (select_l) .* tan (infsup (c3.inf (select_l)))); u = zeros (size (result.inf)); select_u = select & c3.sup ~= 0 & b.inf > 0; u (select_u) = ... sup (b.inf (select_u) .* tan (infsup (c3.sup (select_u)))); idx.subs = {select}; result = subsasgn (result, idx, ... union (subsref (result, idx), ... intersect (subsref (y, idx), ... infsup (subsref (l, idx), subsref (u, idx))))); endif ## c4 is the part of c where y <= 0 and x <= 0 c4 = intersect (c, infsup (inf (-pi), sup (-pi) / 2)); select = not (emptyresult | isempty (c4) | b.inf > 0 | y.inf > 0 | ... c4.inf == sup (-pi) / 2 | (b.inf >= 0 & y.inf >= 0) | ... (b.inf >= 0 & c4.sup < sup (-pi) / 2)); if (any (any (select))) ## The inverse function is y = b * tan (c) ## minimum is located at b.inf, c.sup ## maximum is located at b.sup, c.inf l = -inf (size (result.inf)); select_l = select & c4.sup < sup (-pi) / 2 & b.inf > -inf; l (select_l) = ... inf (b.inf (select_l) .* tan (infsup (c4.sup (select_l)))); u = zeros (size (result.inf)); select_u = select & c4.inf > inf (-pi) & b.sup < 0; u (select_u) = ... min (0, ... sup (b.sup (select_u) .* tan (infsup (c4.sup (select_u))))); idx.subs = {select}; result = subsasgn (result, idx, ... union (subsref (result, idx), ... intersect (subsref (y, idx), ... infsup (subsref (l, idx), subsref (u, idx))))); endif endfunction %!test "from the documentation string"; %! assert (atan2rev1 (infsup (1, 2), infsup ("pi") / 4) == "[0x1.FFFFFFFFFFFFFp-1, 0x1.0000000000001p1]"); interval-1.4.1/inst/@infsup/atan2rev2.m0000644000000000000000000001700512657475772016063 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {@var{X} =} atan2rev2 (@var{A}, @var{C}, @var{X}) ## @deftypemethodx {@@infsup} {@var{X} =} atan2rev2 (@var{A}, @var{C}) ## ## Compute the reverse atan2 function for the second parameter. ## ## That is, an enclosure of all @code{x ∈ @var{X}} where ## @code{atan2 (a, x) ∈ @var{C}} for any @code{a ∈ @var{A}}. ## ## Accuracy: The result is a valid enclosure. ## ## @example ## @group ## atan2rev2 (infsup (1, 2), infsup ("pi") / 4) ## @result{} ans ⊂ [0.99999, 2.0001] ## @end group ## @end example ## @seealso{@@infsup/atan2} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-19 function result = atan2rev2 (a, c, x) if (nargin < 2 || nargin > 3) print_usage (); return endif if (nargin < 3) x = infsup (-inf, inf); endif if (not (isa (a, "infsup"))) a = infsup (a); endif if (not (isa (c, "infsup"))) c = infsup (c); endif if (not (isa (x, "infsup"))) x = infsup (x); endif ## Resize, if scalar × matrix or vector × matrix or scalar × vector if (rows (a.inf) ~= rows (c.inf)) a.inf = ones (rows (c.inf), columns (a.inf)) .* a.inf; a.sup = ones (rows (c.inf), columns (a.inf)) .* a.sup; c.inf = ones (rows (a.inf), columns (c.inf)) .* c.inf; c.sup = ones (rows (a.inf), columns (c.inf)) .* c.sup; endif if (rows (a.inf) ~= rows (x.inf)) a.inf = ones (rows (x.inf), columns (a.inf)) .* a.inf; a.sup = ones (rows (x.inf), columns (a.inf)) .* a.sup; c.inf = ones (rows (x.inf), columns (c.inf)) .* c.inf; c.sup = ones (rows (x.inf), columns (c.inf)) .* c.sup; x.inf = ones (rows (a.inf), columns (x.inf)) .* x.inf; x.sup = ones (rows (a.inf), columns (x.inf)) .* x.sup; endif if (columns (a.inf) ~= columns (c.inf)) a.inf = ones (rows (a.inf), columns (c.inf)) .* a.inf; a.sup = ones (rows (a.inf), columns (c.inf)) .* a.sup; c.inf = ones (rows (c.inf), columns (a.inf)) .* c.inf; c.sup = ones (rows (c.inf), columns (a.inf)) .* c.sup; endif if (columns (a.inf) ~= columns (x.inf)) a.inf = ones (rows (a.inf), columns (x.inf)) .* a.inf; a.sup = ones (rows (a.inf), columns (x.inf)) .* a.sup; c.inf = ones (rows (c.inf), columns (x.inf)) .* c.inf; c.sup = ones (rows (c.inf), columns (x.inf)) .* c.sup; x.inf = ones (rows (x.inf), columns (a.inf)) .* x.inf; x.sup = ones (rows (x.inf), columns (a.inf)) .* x.sup; endif pi = infsup ("pi"); idx.type = '()'; emptyresult = isempty (x) | isempty (a) | isempty (c) | ... c.inf >= sup (pi) | c.sup <= inf (-pi); result = infsup (inf (size (x.inf)), -inf (size (x.inf))); ## c1 is the part of c where y >= 0 and x <= 0 c1 = intersect (c, infsup (inf (pi) / 2, sup (pi))); select = not (emptyresult | isempty (c1) | x.inf > 0 | a.sup < 0 | ... c1.sup == inf (pi) / 2 | ... (x.inf >= 0 & a.sup <= 0) | (a.sup <= 0 & c1.inf > inf (pi) / 2)); if (any (any (select))) ## The inverse function is x = a / tan (c) ## minimum is located at a.sup, c.sup ## maximum is located at a.inf, c.inf l = -inf (size (result.inf)); select_l = select & c1.sup < sup (pi) & a.sup < inf; l (select_l) = ... inf (a.sup (select_l) ./ tan (infsup (c1.sup (select_l)))); u = zeros (size (result.inf)); select_u = select & c1.inf > inf (pi) / 2 & a.inf > 0; u (select_u) = ... sup (a.inf (select_u) ./ tan (infsup (c1.inf (select_u)))); idx.subs = {select}; result = subsasgn (result, idx, ... intersect (subsref (x, idx), ... infsup (subsref (l, idx), subsref (u, idx)))); endif ## c2 is the part of c where y >= 0 and x >= 0 c2 = intersect (c, infsup (0, sup (pi) / 2)); select = not (emptyresult | isempty (c2) | x.sup < 0 | a.sup < 0 | ... c2.inf == sup (pi) / 2 | ... (x.sup <= 0 & a.sup <= 0) | (c2.sup <= 0 & a.inf > 0) | ... (a.sup <= 0 & c2.inf > 0)); if (any (any (select))) ## The inverse function is x = a / tan (c) ## minimum is located at a.inf, c.sup ## maximum is located at a.sup, c.inf l = zeros (size (result.inf)); select_l = select & c2.sup ~= 0 & c2.sup < sup (pi) / 2; l (select_l) = ... max (0, ... inf (a.inf (select_l) ./ tan (infsup (c2.sup (select_l))))); u = inf (size (result.inf)); select_u = select & c2.inf ~= 0 & c2.sup ~= 0 & a.sup < inf; u (select_u) = ... sup (a.sup (select_u) ./ tan (infsup (c2.inf (select_u)))); idx.subs = {select}; result = subsasgn (result, idx, ... union (subsref (result, idx), ... intersect (subsref (x, idx), ... infsup (subsref (l, idx), subsref (u, idx))))); endif ## c3 is the part of c where y <= 0 and x >= 0 c3 = intersect (c, infsup (inf (-pi) / 2, 0)); select = not (emptyresult | isempty (c3) | x.sup < 0 | a.inf > 0 | ... c3.sup == inf (-pi) / 2 | (x.sup <= 0 & a.inf >= 0) | ... (c3.inf >= 0 & a.sup < 0) | (a.inf >= 0 & c3.sup < 0)); if (any (any (select))) ## The inverse function is x = a / tan (c) ## minimum is located at a.sup, c.inf ## maximum is located at a.inf, c.sup l = zeros (size (result.inf)); select_l = select & c3.inf > inf (-pi) / 2 & c3.inf ~= 0; l (select_l) = ... max (0, ... inf (a.sup (select_l) ./ tan (infsup (c3.inf (select_l))))); u = inf (size (result.inf)); select_u = select & c3.inf ~= 0 & c3.sup ~= 0 & a.inf < inf; u (select_u) = ... sup (a.inf (select_u) ./ tan (infsup (c3.sup (select_u)))); idx.subs = {select}; result = subsasgn (result, idx, ... union (subsref (result, idx), ... intersect (subsref (x, idx), ... infsup (subsref (l, idx), subsref (u, idx))))); endif ## c4 is the part of c where y <= 0 and x <= 0 c4 = intersect (c, infsup (inf (-pi), sup (-pi) / 2)); select = not (emptyresult | isempty (c4) | x.inf > 0 | a.inf > 0 | ... c4.inf == sup (-pi) / 2 | (x.inf >= 0 & a.inf >= 0) | ... (a.inf >= 0 & c4.inf > inf (-pi))); if (any (any (select))) ## The inverse function is x = a / tan (c) ## minimum is located at a.inf, c.inf ## maximum is located at a.sup, c.sup l = -inf (size (result.inf)); select_l = select & c4.inf > inf (-pi) & a.inf > -inf; l (select_l) = ... inf (a.inf (select_l) ./ tan (infsup (c4.inf (select_l)))); u = zeros (size (result.inf)); select_u = select & c4.sup < sup (-pi) / 2 & a.sup < 0; u (select_u) = ... sup (a.sup (select_u) ./ tan (infsup (c4.sup (select_u)))); idx.subs = {select}; result = subsasgn (result, idx, ... union (subsref (result, idx), ... intersect (subsref (x, idx), ... infsup (subsref (l, idx), subsref (u, idx))))); endif endfunction %!test "from the documentation string"; %! assert (atan2rev2 (infsup (1, 2), infsup ("pi") / 4) == "[0x1.FFFFFFFFFFFFEp-1, 0x1.0000000000001p1]"); interval-1.4.1/inst/@infsup/atanh.m0000644000000000000000000000316212657475772015351 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} atanh (@var{X}) ## ## Compute the inverse hyperbolic tangent. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## atanh (infsup (.5)) ## @result{} ans ⊂ [0.5493, 0.54931] ## @end group ## @end example ## @seealso{@@infsup/tanh} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-07 function result = atanh (x) if (nargin ~= 1) print_usage (); return endif x = intersect (x, infsup (-1, 1)); ## atanh is monotonically increasing between (-1, -inf) and (1, inf) l = mpfr_function_d ('atanh', -inf, x.inf); u = mpfr_function_d ('atanh', +inf, x.sup); emptyresult = isempty (x) | x.sup <= -1 | x.inf >= 1; l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (atanh (infsup (.5)) == "[0x1.193EA7AAD030Ap-1, 0x1.193EA7AAD030Bp-1]"); interval-1.4.1/inst/@infsup/bisect.m0000644000000000000000000000775412657475772015542 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {[@var{A}, @var{B}] =} bisect (@var{X}) ## ## Bisect an interval into two intervals, which contain half the amount of ## binary64 numbers each. ## ## Instead of bisecting the values of numbers in the interval at ## @code{mid (@var{X})}, this function bisects a function that counts them. In ## a bisect method this eliminates exactly half of the solutions and avoids ## slow convergence speeds in extreme cases. ## ## If all numbers in interval @var{X} are of equal sign, the pivot element used ## for bisection is @code{pow2 (mid (log2 (abs (@var{X}))))}. If @var{X} is no ## empty interval, the intervals @var{A} and @var{B} are non-empty and satisfy ## @code{@var{A}.sup == @var{B}.inf}. ## ## @example ## @group ## [a, b] = bisect (infsup (2, 32)) ## @result{} ## a = [2, 8] ## b = [8, 32] ## @end group ## @end example ## @seealso{@@infsup/mince, @@infsup/nextout} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-05-25 function [a, b] = bisect (x) if (nargin > 1) print_usage (); return endif m = zeros (size (x.inf)); idx.type = '()'; positive = x.inf >= 0 & x.sup > 0; if (any (any (positive))) idx.subs = {positive}; bounded = intersect (infsup (pow2 (-1074), realmax), subsref (x, idx)); m (positive) = min (realmax (), pow2 (mid (log2 (bounded)))); endif negative = x.inf < 0 & x.sup <= 0; if (any (any (negative))) idx.subs = {negative}; bounded = intersect (infsup (-realmax, -pow2 (-1074)), subsref (x, idx)); m (negative) = ... uminus (min (realmax (), pow2 (mid (log2 (uminus (bounded)))))); endif both_signs = x.inf < 0 & x.sup > 0; both_signs_p = both_signs & x.sup > -x.inf; if (any (any (both_signs_p))) idx.subs = {both_signs_p}; bounded_n = intersect (infsup (-realmax, -pow2 (-1074)), subsref (x, idx)); bounded_p = intersect (infsup (pow2 (-1074), realmax), subsref (x, idx)); m (both_signs_p) = min (realmax (), pow2 ( mid (log2 (bounded_p)) ... - mid (log2 (uminus (bounded_n))) ... - 1074)); endif both_signs_n = both_signs & x.sup < -x.inf; if (any (any (both_signs_n))) idx.subs = {both_signs_n}; bounded_n = intersect (infsup (-realmax, -pow2 (-1074)), subsref (x, idx)); bounded_p = intersect (infsup (pow2 (-1074), realmax), subsref (x, idx)); m (both_signs_n) = uminus (min (realmax (), pow2 ( mid (log2 (uminus (bounded_n))) ... - mid (log2 (bounded_p)) ... - 1074))); endif m (isempty (x)) = -inf; a = infsup (x.inf, min (m, x.sup)); m (isempty (x)) = inf; b = infsup (max (m, x.inf), x.sup); endfunction %!test "from the documentation string"; %! [a, b] = bisect (infsup (2, 32)); %! assert (a == infsup (2, 8)); %! assert (b == infsup (8, 32)); %!test %! [a, b] = bisect (infsup (-inf, inf)); %! assert (a == infsup (-inf, 0)); %! assert (b == infsup (0, inf)); %!test %! [a, b] = bisect (infsup (0)); %! assert (a == 0); %! assert (b == 0); %!test %! [a, b] = bisect (infsup ()); %! assert (isempty (a)); %! assert (isempty (b)); %!test %! [a, b] = bisect (infsup (0, inf)); %! assert (a == infsup (0, pow2 (-25))); %! assert (b == infsup (pow2 (-25), inf)); %!test %! [a, b] = bisect (infsup (-inf, 0)); %! assert (a == infsup (-inf, -pow2 (-25))); %! assert (b == infsup (-pow2 (-25), 0)); interval-1.4.1/inst/@infsup/bitunpack.m0000644000000000000000000000460712657475772016243 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} bitunpack (@var{X}) ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## ## Encode bare interval @var{X} in interchange format. ## ## The result is a raw bit pattern of length 128 that derive from two binary64 ## numbers. Bits are in increasing order. Byte order depends on the system's ## endianness. First 8 bytes come from the lower interval boundary, last ## 8 bytes come from the upper interval boundary. ## ## The result is a row vector if @var{X} is a row vector; otherwise, it is a ## column vector. ## ## For all scalar intervals the following equation holds: ## @code{@var{X} == interval_bitpack (bitunpack (@var{X}))}. ## ## @seealso{interval_bitpack} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-12-23 function result = bitunpack (x) if (nargin ~= 1) print_usage (); return endif ## The exchange representation of [Empty] is (+inf, -inf). The exchange ## representation of [0, 0] is (-0, +0). Both is guaranteed by the infsup ## constructor. l = bitunpack (x.inf); u = bitunpack (x.sup); ## Initialize result vector result = zeros (1, length (l) + length (u), 'logical'); if (not (isrow (l))) result = result'; endif ## Merge 64 bit blocks from l and u (alternating) together into result. target = reshape (1 : length (result), 64, numel (x.inf) + numel (x.sup)); target (:, 2 : 2 : size (target, 2)) = []; result (target) = l; result (target + 64) = u; endfunction %!test; %! littleendian = bitunpack (uint16 (1))(1); %! b = zeros (1, 128); %! if (littleendian) %! b([52, 63, 117, 127]) = 1; %! else %! b([7, 12, 71, 77]) = 1; %! endif %! assert (bitunpack (infsup (3, 4)), logical (b)); interval-1.4.1/inst/@infsup/cancelminus.m0000644000000000000000000000517212657475772016562 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {@var{Z} =} cancelminus (@var{X}, @var{Y}) ## ## Recover interval @var{Z} from intervals @var{X} and @var{Y}, given that one ## knows @var{X} was obtained as the sum @var{Y} + @var{Z}. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## cancelminus (infsup (2, 3), infsup (1, 1.5)) ## @result{} ans = [1, 1.5] ## @end group ## @end example ## @seealso{@@infsup/cancelplus} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-19 function result = cancelminus (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsup"))) x = infsup (x); endif if (not (isa (y, "infsup"))) y = infsup (y); endif l = mpfr_function_d ('minus', -inf, x.inf, y.inf); u = mpfr_function_d ('minus', +inf, x.sup, y.sup); wid_x1 = wid (intersect (x, infsup (-inf, 0))); wid_x2 = wid (intersect (x, infsup (0, inf))); wid_y1 = wid (intersect (y, infsup (-inf, 0))); wid_y2 = wid (intersect (y, infsup (0, inf))); [wid_x1, wid_x2] = deal (max (wid_x1, wid_x2), min (wid_x1, wid_x2)); [wid_y1, wid_y2] = deal (max (wid_y1, wid_y2), min (wid_y1, wid_y2)); entireresult = (isempty (y) & not (isempty (x))) | ... y.inf == -inf | y.sup == inf | ... x.inf == -inf | x.sup == inf | ... ## We have to check for wid (x) < wid (y), which is difficult ## for wid > realmax, because of overflow and ## for interior zero, because of rounding errors. (iscommoninterval (x) & iscommoninterval (y) & ... (wid_x1 - wid_y1) + (wid_x2 - wid_y2) < 0); l (entireresult) = -inf; u (entireresult) = inf; emptyresult = isempty (x) & not (entireresult); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (cancelminus (infsup (2, 3), infsup (1, 1.5)) == infsup (1, 1.5)); interval-1.4.1/inst/@infsup/cancelplus.m0000644000000000000000000000275612657475772016417 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {@var{Z} =} cancelplus (@var{X}, @var{Y}) ## ## Recover interval @var{Z} from intervals @var{X} and @var{Y}, given that one ## knows @var{X} was obtained as the difference @var{Z} - @var{Y}. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## cancelplus (infsup (2, 3), infsup (1, 1.5)) ## @result{} ans = [3.5, 4] ## @end group ## @end example ## @seealso{@@infsup/cancelminus} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-19 function result = cancelplus (x, y) if (nargin ~= 2) print_usage (); return endif result = cancelminus (x, -y); endfunction %!test "from the documentation string"; %! assert (cancelplus (infsup (2, 3), infsup (1, 1.5)) == infsup (3.5, 4)); interval-1.4.1/inst/@infsup/cat.m0000644000000000000000000000356012657475772015027 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} cat (@var{DIM}, @var{MATRIX1}, @var{MATRIX2}, @dots{}) ## ## Return the concatenation of interval matrices @var{MATRIX1}, @var{MATRIX2}, ## … along dimension @var{DIM}. ## ## Interval matrices support no more than 2 dimensions. ## ## @example ## @group ## cat (2, infsup (magic (3)), infsup (pascal (3))) ## @result{} 3×6 interval matrix ## ## [8] [1] [6] [1] [1] [1] ## [3] [5] [7] [1] [2] [3] ## [4] [9] [2] [1] [3] [6] ## @end group ## @end example ## @seealso{@@infsup/horzcat, @@infsup/vertcat} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-19 function result = cat (dim, varargin) switch dim case 1 result = vertcat (varargin {:}); case 2 result = horzcat (varargin {:}); otherwise error ("interval:InvalidOperand", ... "cat: no more than 2 dimensions are supported") endswitch endfunction %!assert (size (cat (1, infsup ([]), infsup ([]))), [0 0]); %!assert (cat (1, infsup (1), infsup (2)) == infsup (cat (1, 1, 2))); %!assert (cat (2, infsup (1), infsup (2)) == infsup (cat (2, 1, 2))); interval-1.4.1/inst/@infsup/cbrt.m0000644000000000000000000000262512657475772015213 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} cbrt (@var{X}) ## ## Compute the cube root. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## cbrt (infsup (-27, 27)) ## @result{} ans = [-3, +3] ## @end group ## @end example ## @seealso{@@infsup/realsqrt, @@infsup/nthroot} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-03-15 function result = cbrt (x) l = mpfr_function_d ('cbrt', -inf, x.inf); u = mpfr_function_d ('cbrt', +inf, x.sup); emptyresult = isempty (x); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (cbrt (infsup (-27, 27)) == infsup (-3, 3)); interval-1.4.1/inst/@infsup/ceil.m0000644000000000000000000000474212657475772015177 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} ceil (@var{X}) ## ## Round each number in interval @var{X} towards +Inf. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## ceil (infsup (2.5, 3.5)) ## @result{} ans = [3, 4] ## ceil (infsup (-0.5, 5)) ## @result{} ans = [0, 5] ## @end group ## @end example ## @seealso{@@infsup/floor, @@infsup/round, @@infsup/roundb, @@infsup/fix} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-04 function result = ceil (x) if (nargin ~= 1) print_usage (); return endif result = infsup (ceil (x.inf), ceil (x.sup)); endfunction %!test "Empty interval"; %! assert (ceil (infsup ()) == infsup ()); %!test "Singleton intervals"; %! assert (ceil (infsup (0)) == infsup (0)); %! assert (ceil (infsup (0.5)) == infsup (1)); %! assert (ceil (infsup (-0.5)) == infsup (0)); %!test "Bounded intervals"; %! assert (ceil (infsup (-0.5, 0)) == infsup (0)); %! assert (ceil (infsup (0, 0.5)) == infsup (0, 1)); %! assert (ceil (infsup (0.25, 0.5)) == infsup (1)); %! assert (ceil (infsup (-1, 0)) == infsup (-1, 0)); %! assert (ceil (infsup (-1, 1)) == infsup (-1, 1)); %! assert (ceil (infsup (-realmin, realmin)) == infsup (0, 1)); %! assert (ceil (infsup (-realmax, realmax)) == infsup (-realmax, realmax)); %!test "Unbounded intervals"; %! assert (ceil (infsup (-realmin, inf)) == infsup (0, inf)); %! assert (ceil (infsup (-realmax, inf)) == infsup (-realmax, inf)); %! assert (ceil (infsup (-inf, realmin)) == infsup (-inf, 1)); %! assert (ceil (infsup (-inf, realmax)) == infsup (-inf, realmax)); %! assert (ceil (infsup (-inf, inf)) == infsup (-inf, inf)); %!test "from the documentation string"; %! assert (ceil (infsup (2.5, 3.5)) == infsup (3, 4)); %! assert (ceil (infsup (-.5, 5)) == infsup (0, 5)); interval-1.4.1/inst/@infsup/columns.m0000644000000000000000000000222512657475772015735 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} columns (@var{A}) ## ## Return the number of columns of @var{A}. ## @seealso{@@infsup/numel, @@infsup/size, @@infsup/length, @@infsup/rows} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-29 function result = columns (a) if (nargin ~= 1) print_usage (); return endif result = columns (a.inf); endfunction %!test; %! assert (columns (infsup (zeros (3, 4))), 4); interval-1.4.1/inst/@infsup/cos.m0000644000000000000000000000623412657475772015045 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} cos (@var{X}) ## ## Compute the cosine in radians. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## cos (infsup (1)) ## @result{} ans ⊂ [0.5403, 0.54031] ## @end group ## @end example ## @seealso{@@infsup/acos, @@infsup/sec, @@infsup/cosh} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-05 function result = cos (x) if (nargin ~= 1) print_usage (); return endif l = u = sinsignl = sinsignu = zeros (size (x.inf)); ## Check, if wid (x) is certainly greater than 2*pi. This can save the ## computation if some cosine values. width = mpfr_function_d ('minus', -inf, x.sup, x.inf); pi.sup = 0x6487ED5 * pow2 (-25) + 0x442D190 * pow2 (-55); twopi.sup = 2 * pi.sup; certainlyfullperiod = width >= twopi.sup; l (certainlyfullperiod) = -1; u (certainlyfullperiod) = 1; possiblynotfullperiod = not (certainlyfullperiod); l (possiblynotfullperiod) = min (... mpfr_function_d ('cos', -inf, x.inf (possiblynotfullperiod)), ... mpfr_function_d ('cos', -inf, x.sup (possiblynotfullperiod))); u (possiblynotfullperiod) = max (... mpfr_function_d ('cos', inf, x.inf (possiblynotfullperiod)), ... mpfr_function_d ('cos', inf, x.sup (possiblynotfullperiod))); ## We use sign (-sin) to know the gradient at the boundaries. sinsignl (possiblynotfullperiod) = sign (... -mpfr_function_d ('sin', .5, x.inf (possiblynotfullperiod))); sinsignu (possiblynotfullperiod) = sign (... -mpfr_function_d ('sin', .5, x.sup (possiblynotfullperiod))); ## In case of sign (-sin) == 0, we conservatively use sign (-sin) of nextout. sinsignl (sinsignl == 0) = (-1) * sign (l (sinsignl == 0)); sinsignu (sinsignu == 0) = sign (u (sinsignu == 0)); containsinf = possiblynotfullperiod & ((sinsignl == -1 & sinsignu == 1) | ... (sinsignl == sinsignu & ... width >= pi.sup)) ... & ne (0, x); l (containsinf) = -1; containssup = possiblynotfullperiod & ((sinsignl == 1 & sinsignu == -1) | ... (sinsignl == sinsignu & ... width >= pi.sup)); u (containssup) = 1; emptyresult = isempty (x); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (cos (infsup (1)) == "[0x1.14A280FB5068Bp-1, 0x1.14A280FB5068Cp-1]"); interval-1.4.1/inst/@infsup/cosh.m0000644000000000000000000000311112657475772015204 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} cosh (@var{X}) ## ## Compute the hyperbolic cosine. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## cosh (infsup (1)) ## @result{} ans ⊂ [1.543, 1.5431] ## @end group ## @end example ## @seealso{@@infsup/acosh, @@infsup/sech, @@infsup/sinh, @@infsup/tanh} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-07 function result = cosh (x) if (nargin ~= 1) print_usage (); return endif ## cosh is symmetric and has its global minimum located at (0, 0). l = mpfr_function_d ('cosh', -inf, mig (x)); u = mpfr_function_d ('cosh', +inf, mag (x)); emptyresult = isempty (x); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (cosh (infsup (1)) == "[0x1.8B07551D9F55, 0x1.8B07551D9F551]"); interval-1.4.1/inst/@infsup/coshrev.m0000644000000000000000000000326312657475772015731 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {@var{X} =} coshrev (@var{C}, @var{X}) ## @deftypemethodx {@@infsup} {@var{X} =} coshrev (@var{C}) ## ## Compute the reverse hyperbolic cosine function. ## ## That is, an enclosure of all @code{x ∈ @var{X}} where ## @code{cosh (x) ∈ @var{C}}. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## coshrev (infsup (-2, 1)) ## @result{} ans = [0] ## @end group ## @end example ## @seealso{@@infsup/cosh} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = coshrev (c, x) if (nargin > 2) print_usage (); return endif if (nargin < 2) x = infsup (-inf, inf); endif if (not (isa (c, "infsup"))) c = infsup (c); endif if (not (isa (x, "infsup"))) x = infsup (x); endif p = acosh (c); n = - p; result = union (intersect (p, x), intersect (n, x)); endfunction %!test "from the documentation string"; %! assert (coshrev (infsup (-2, 1)) == 0); interval-1.4.1/inst/@infsup/cosrev.m0000644000000000000000000001222512657475772015557 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {@var{X} =} cosrev (@var{C}, @var{X}) ## @deftypemethodx {@@infsup} {@var{X} =} cosrev (@var{C}) ## ## Compute the reverse cosine function. ## ## That is, an enclosure of all @code{x ∈ @var{X}} where ## @code{cos (x) ∈ @var{C}}. ## ## Accuracy: The result is a valid enclosure. ## ## @example ## @group ## cosrev (infsup (0), infsup (6, 9)) ## @result{} ans ⊂ [7.8539, 7.854] ## @end group ## @end example ## @seealso{@@infsup/cos} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-19 function result = cosrev (c, x) if (nargin > 2) print_usage (); return endif if (nargin < 2) x = infsup (-inf, inf); endif if (not (isa (c, "infsup"))) c = infsup (c); endif if (not (isa (x, "infsup"))) x = infsup (x); endif arccosine = acos (c); result = x; ## Resize, if scalar × matrix if (isscalar (arccosine.inf) ~= isscalar (result.inf)) arccosine.inf = ones (size (result.inf)) .* arccosine.inf; arccosine.sup = ones (size (result.inf)) .* arccosine.sup; result.inf = ones (size (arccosine.inf)) .* result.inf; result.sup = ones (size (arccosine.inf)) .* result.sup; endif result.inf (isempty (arccosine)) = inf; result.sup (isempty (arccosine)) = -inf; idx.type = '()'; pi = infsup ("pi"); select = not (isempty (result)) ... & not (subset (infsup (0, pi.sup), arccosine)); if (any (any (select))) ## Find a smaller upper bound for x, if the restriction from c allows it u = inf (size (result.inf)); select_u = select & result.sup < inf; ## Find n, such that result.sup is within a distance of pi/2 ## around (n + 1/2) * pi. n = result.sup; n (select_u) = floor (sup (n (select_u) ./ pi)); arccosineshifted = arccosine; idx.subs = {(select_u & rem (n, 2) == 0)}; arccosineshifted = subsasgn (arccosineshifted, idx, ... subsref (arccosine, idx) + subsref (n, idx) .* pi); idx.subs = {(select_u & rem (n, 2) ~= 0)}; arccosineshifted = subsasgn (arccosineshifted, idx, ... (infsup (subsref (n, idx)) + 1) .* pi - subsref (arccosine, idx)); overlapping = not (isempty (intersect (result, arccosineshifted))); u (select_u & overlapping) = ... min (result.sup (select_u & overlapping), ... arccosineshifted.sup (select_u & overlapping)); m = n; m (select_u & ~overlapping) = ... mpfr_function_d ('minus', +inf, m (select_u & ~overlapping), 1); idx.subs = {(select_u & ~overlapping & rem (n, 2) == 0)}; u (idx.subs {1}) = ... sup (subsref (n, idx) .* pi - subsref (arccosine, idx)); idx.subs = {(select_u & ~overlapping & rem (n, 2) ~= 0)}; u (idx.subs {1}) = ... sup (subsref (arccosine, idx) + subsref (m, idx) .* pi); ## Find a larger lower bound for x, if the restriction from c allows it l = -inf (size (result.inf)); select_l = select & result.inf > -inf; ## Find n, such that result.inf is within a distance of pi/2 ## around (n + 1/2) * pi. n = result.inf; n (select_l) = floor (inf (n (select_l) ./ pi)); arccosineshifted = arccosine; idx.subs = {(select_l & rem (n, 2) == 0)}; arccosineshifted = subsasgn (arccosineshifted, idx, ... subsref (arccosine, idx) + subsref (n, idx) .* pi); idx.subs = {(select_l & rem (n, 2) ~= 0)}; arccosineshifted = subsasgn (arccosineshifted, idx, ... (infsup (subsref (n, idx)) + 1) .* pi - subsref (arccosine, idx)); overlapping = not (isempty (intersect (result, arccosineshifted))); l (select_l & overlapping) = ... max (result.inf (select_l & overlapping), ... arccosineshifted.inf (select_l & overlapping)); m = n; m (select_l & ~overlapping) = ... mpfr_function_d ('plus', -inf, m (select_l & ~overlapping), 1); idx.subs = {(select_l & ~overlapping & rem (n, 2) == 0)}; l (idx.subs {1}) = ... inf ((infsup (subsref (m, idx)) + 1) .* pi - subsref (arccosine, idx)); idx.subs = {(select_l & ~overlapping & rem (n, 2) ~= 0)}; l (idx.subs {1}) = ... inf (subsref (arccosine, idx) + subsref (m, idx) .* pi); result.inf (select) = max (l (select), result.inf (select)); result.sup (select) = min (u (select), result.sup (select)); result.inf (result.inf > result.sup) = inf; result.sup (result.inf > result.sup) = -inf; endif endfunction %!test "from the documentation string"; %! assert (cosrev (0, infsup (6, 9)) == "[0x1.F6A7A2955385Ep2, 0x1.F6A7A2955386p2]"); interval-1.4.1/inst/@infsup/cot.m0000644000000000000000000000441412657475772015044 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} cot (@var{X}) ## ## Compute the cotangent in radians, that is the reciprocal tangent. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## cot (infsup (1)) ## @result{} ans ⊂ [0.64209, 0.6421] ## @end group ## @end example ## @seealso{@@infsup/tan, @@infsup/csc, @@infsup/sec} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-03-15 function result = cot (x) if (nargin ~= 1) print_usage (); return endif l = u = zeros (size (x)); ## Check, if wid (x) is certainly greater than pi. This may save computation of ## some cotangent values. width = mpfr_function_d ('minus', -inf, x.sup, x.inf); pi.sup = 0x6487ED5 * pow2 (-25) + 0x442D190 * pow2 (-55); certainlyfullperiod = width >= pi.sup; possiblynotfullperiod = not (certainlyfullperiod); l (possiblynotfullperiod) = mpfr_function_d ('cot', -inf, x.sup (possiblynotfullperiod)); u (possiblynotfullperiod) = mpfr_function_d ('cot', inf, x.inf (possiblynotfullperiod)); l (x.sup == 0) = -inf; u (x.inf == 0) = +inf; singularity = certainlyfullperiod | ... l > u | (... width > 2 & (... sign (l) == sign (u) | ... max (abs (l), abs (u)) < 1)); l (singularity) = -inf; u (singularity) = inf; emptyresult = isempty (x) | (x.inf == 0 & x.sup == 0); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (cot (infsup (1)) == "[0x1.48C05D04E1CFDp-1, 0x1.48C05D04E1CFEp-1]"); interval-1.4.1/inst/@infsup/coth.m0000644000000000000000000000357212657475772015220 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} coth (@var{X}) ## ## Compute the hyperbolic cotangent, that is the reciprocal hyperbolic tangent. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## coth (infsup (1)) ## @result{} ans ⊂ [1.313, 1.3131] ## @end group ## @end example ## @seealso{@@infsup/tanh, @@infsup/csch, @@infsup/sech} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-03-15 function result = coth (x) if (nargin ~= 1) print_usage (); return endif l = u = zeros (size (x.inf)); select = x.inf >= 0 | x.sup <= 0; if (any (any (select))) l (select) = mpfr_function_d ('coth', -inf, x.sup (select)); l (select & x.sup == 0) = -inf; u (select) = mpfr_function_d ('coth', +inf, x.inf (select)); u (select & x.inf == 0) = inf; endif select = x.inf < 0 & x.sup > 0; if (any (any (select))) l (select) = -inf; u (select) = inf; endif emptyresult = isempty (x) | (x.inf == 0 & x.sup == 0); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (coth (infsup (1)) == "[0x1.50231499B6B1D, 0x1.50231499B6B1E]"); interval-1.4.1/inst/@infsup/csc.m0000644000000000000000000000560212657475772015027 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} csc (@var{X}) ## ## Compute the cosecant in radians, that is the reciprocal sine. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## csc (infsup (1)) ## @result{} ans ⊂ [1.1883, 1.1884] ## @end group ## @end example ## @seealso{@@infsup/sin, @@infsup/sec, @@infsup/cot} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-03-15 function result = csc (x) if (nargin ~= 1) print_usage (); return endif l = u = derivl = derivu = zeros (size (x.inf)); ## Check, if wid (x) is certainly greater than 2*pi. This can save the ## computation if some values. width = mpfr_function_d ('minus', -inf, x.sup, x.inf); pi.sup = 0x6487ED5 * pow2 (-25) + 0x442D190 * pow2 (-55); certainlysingularity = width >= pi.sup; ## We simply compute the cosecant for both endpoints. x.inf (x.inf == 0) = +0; x.sup (x.sup == 0) = -0; select = not (certainlysingularity); l (select) = min (... mpfr_function_d ('csc', -inf, x.inf (select)), ... mpfr_function_d ('csc', -inf, x.sup (select))); u (select) = max (... mpfr_function_d ('csc', inf, x.inf (select)), ... mpfr_function_d ('csc', inf, x.sup (select))); ## A change of sign is a sufficient singularity indicator certainlysingularity = certainlysingularity | (select & sign (l) ~= sign (u)); l (certainlysingularity) = -inf; u (certainlysingularity) = inf; ## Check, whether the interval contains a local extremum using the derivative select = not (certainlysingularity); derivl (select) = -mpfr_function_d ('csc', 0, x.inf (select)) .* ... mpfr_function_d ('cot', 0, x.inf (select)); derivu (select) = -mpfr_function_d ('csc', 0, x.sup (select)) .* ... mpfr_function_d ('cot', 0, x.sup (select)); hasextremum = select & ((derivl <= 0 & derivu >= 0) | ... (derivl >= 0 & derivu <= 0)); l (hasextremum & l > 0) = 1; u (hasextremum & u < 0) = -1; emptyresult = isempty (x) | (x.inf == 0 & x.sup == 0); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (csc (infsup (1)) == "[0x1.303AA9620B223, 0x1.303AA9620B224]"); interval-1.4.1/inst/@infsup/csch.m0000644000000000000000000000357612657475772015207 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} csch (@var{X}) ## ## Compute the hyperbolic cosecant, that is the reciprocal hyperbolic sine. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## csch (infsup (1)) ## @result{} ans ⊂ [0.85091, 0.85092] ## @end group ## @end example ## @seealso{@@infsup/sinh, @@infsup/sech, @@infsup/coth} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-03-15 function result = csch (x) if (nargin ~= 1) print_usage (); return endif l = u = zeros (size (x.inf)); select = x.inf >= 0 | x.sup <= 0; if (any (any (select))) l (select) = mpfr_function_d ('csch', -inf, x.sup (select)); l (select & x.sup == 0) = -inf; u (select) = mpfr_function_d ('csch', +inf, x.inf (select)); u (select & x.inf == 0) = inf; endif select = x.inf < 0 & x.sup > 0; if (any (any (select))) l (select) = -inf; u (select) = inf; endif emptyresult = isempty (x) | (x.inf == 0 & x.sup == 0); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (csch (infsup (1)) == "[0x1.B3AB8A78B90Cp-1, 0x1.B3AB8A78B90C1p-1]"); interval-1.4.1/inst/@infsup/ctranspose.m0000644000000000000000000000244612657475772016443 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} ctranspose (@var{X}) ## @defopx Operator {@@infsup} {@var{X}'} ## ## Return the complex conjugate transpose of @var{X}. ## ## Since intervals are only defined for real numbers, this function and ## @code{transpose} are equivalent. ## ## @seealso{@@infsup/transpose} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-29 function result = ctranspose (x) if (nargin ~= 1) print_usage (); return endif result = transpose (x); endfunction %!test %! assert (ctranspose (infsup (magic (3))) == infsup (magic (3)')); interval-1.4.1/inst/@infsup/det.m0000644000000000000000000000475612657475772015044 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} det (@var{A}) ## ## Compute the determinant of matrix @var{A}. ## ## The determinant for matrices of size 3×3 or greater is computed via L-U ## decomposition and may be affected by overestimation due to the dependency ## problem. ## ## Accuracy: The result is a valid enclosure. ## ## @example ## @group ## det (infsup (magic (3))) ## @result{} ans = [-360] ## @end group ## @end example ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-10-23 function result = det (x) if (nargin ~= 1) print_usage (); return endif if (not (issquare (x.inf))) error ("det: argument must be a square matrix"); endif if (any (any (isempty (x)))) result = infsup (); return endif switch (rows (x.inf)) case 0 result = infsup (1); return case 1 result = x; return case 2 ## det ([1, 3; 2, 4]) = 4*1 - 3*2 ## The result will be tightest. result = mtimes (infsup ([x.inf(4), -x.sup(3)], ... [x.sup(4), -x.inf(3)]), ... infsup (x.inf(:, 1), x.sup(:, 1))); return endswitch zero = x.inf == 0 & x.sup == 0; if (any (all (zero, 1)) || any (all (zero, 2))) ## One column or row being zero result = infsup (0); return endif ## P * x = L * U, with ## det (P) = ±1 and det (L) = 1 and det (U) = prod (diag (U)) ## ## => det (x) = det (P) * det (U) [~, U, P] = lu (x); result = times (det (P), prod (diag (U))); ## Integer matrix, determinant must be integral if (all (all (fix (x.inf) == x.inf & fix (x.sup) == x.sup))) result.inf = ceil (result.inf); result.sup = floor (result.sup); endif endfunction %!test "from the documentation string"; %! assert (det (infsup (magic (3))) == -360); interval-1.4.1/inst/@infsup/diag.m0000644000000000000000000000455212657475772015166 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {M =} diag (@var{V}) ## @deftypemethodx {@@infsup} {V =} diag (@var{M}) ## @deftypemethodx {@@infsup} {M =} diag (@var{V}, @var{K}) ## @deftypemethodx {@@infsup} {M =} diag (@var{V}, @var{M}, @var{N}) ## @deftypemethodx {@@infsup} {V =} diag (@var{M}, @var{K}) ## ## Create a diagonal matrix @var{M} with vector @var{V} on diagonal @var{K} or ## extract a vector @var{V} from the @var{K}-th diagonal of matrix @var{M}. ## ## With three arguments, create a matrix of size @var{M}×@var{N}. ## ## @example ## @group ## diag (infsup (1 : 3)) ## @result{} ans = 3×3 interval matrix ## ## [1] [0] [0] ## [0] [2] [0] ## [0] [0] [3] ## @end group ## @end example ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-10-23 function result = diag (x, m, n) if (nargin >= 2 && isa (m, 'infsup')) error ('diag: invalid second argument; it must not be an interval'); endif if (nargin >= 3 && isa (n, 'infsup')) error ('diag: invalid third argument; it must not be an interval'); endif switch (nargin) case 1 result = infsup (diag (x.inf), diag (x.sup)); case 2 result = infsup (diag (x.inf, m), diag (x.sup, m)); case 3 result = infsup (diag (x.inf, m, n), diag (x.sup, m, n)); otherwise print_usage (); endswitch endfunction %!assert (diag (infsup (-inf, inf)) == "[Entire]"); %!assert (diag (infsup ()) == "[Empty]"); %!assert (numel (diag (infsup ([]))), 0); %!xtest assert (isequal (diag (infsup (magic (3))), infsup ([8; 5; 2]))); %!xtest assert (isequal (diag (infsup ([8 5 3])), infsup ([8 0 0; 0 5 0; 0 0 3]))); interval-1.4.1/inst/@infsup/dilog.m0000644000000000000000000000443712657475772015362 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} dilog (@var{X}) ## ## Compute the real part of the dilogarithm function. ## ## @tex ## $$ ## {\rm dilog} (x) = -\Re \int_0^x {{\log (1-t)} \over t} dt ## $$ ## @end tex ## @ifnottex ## @group ## @verbatim ## x ## / log (1 - t) ## dilog (x) = - Re | ------------- dt ## / t ## 0 ## @end verbatim ## @end group ## @end ifnottex ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## dilog (infsup (1)) ## @result{} ans ⊂ [1.6449, 1.645] ## @end group ## @end example ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-29 function result = dilog (x) if (nargin ~= 1) print_usage (); return endif l = inf (size (x.inf)); u = -l; ## Monotonically increasing for x1 x1 = intersect (x, infsup (-inf, 2)); select = not (isempty (x1)); if (any (any (select))) l (select) = mpfr_function_d ('dilog', -inf, x1.inf (select)); u (select) = mpfr_function_d ('dilog', +inf, x1.sup (select)); endif ## Monotonically decreasing for x2 x2 = intersect (x, infsup (2, inf)); select = not (isempty (x2)); if (any (any (select))) l (select) = min (l (select), ... mpfr_function_d ('dilog', -inf, x2.sup (select))); u (select) = mpfr_function_d ('dilog', +inf, x2.inf (select)); endif result = infsup (l, u); endfunction %!assert (dilog (infsup (-inf, inf)) == "[-Inf, +0x1.3BD3CC9BE45DFp1]"); %!test "from the documentation string"; %! assert (dilog (infsup (1)) == "[0x1.A51A6625307D3, 0x1.A51A6625307D4]"); interval-1.4.1/inst/@infsup/disjoint.m0000644000000000000000000000315012657475772016076 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} disjoint (@var{A}, @var{B}) ## ## Evaluate disjoint comparison on intervals. ## ## True, if all numbers from @var{A} are not contained in @var{B} and vice ## versa. False, if @var{A} and @var{B} have at least one element in common. ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## @seealso{@@infsup/eq, @@infsup/subset, @@infsup/interior} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-30 function result = disjoint (a, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (a, "infsup"))) a = infsup (a); endif if (not (isa (b, "infsup"))) b = infsup (b); endif result = (a.sup < b.inf | b.sup < a.inf); result (isempty (a) | isempty (b)) = true (); endfunction %!assert (disjoint (infsup (3, 4), infsup (5, 6))); %!assert (not (disjoint (infsup (3, 4), infsup (4, 5)))); interval-1.4.1/inst/@infsup/disp.m0000644000000000000000000000776012657475772015225 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} disp (@var{X}) ## ## Display the value of interval @var{X}. ## ## Interval boundaries are approximated with faithful decimal numbers. ## ## Interval matrices with many rows are wrapped according to the terminal ## width. @code{disp} prints nothing when @var{X} is an interval matrix ## without elements. ## ## Note that the output from @code{disp} always ends with a newline. ## ## If an output value is requested, @code{disp} prints nothing and returns the ## formatted output in a string. ## ## @example ## @group ## format long ## disp (infsupdec ("pi")) ## @result{} [3.14159265358979, 3.1415926535898]_com ## format short ## disp (infsupdec ("pi")) ## @result{} [3.1415, 3.1416]_com ## disp (infsupdec (1 : 5)) ## @result{} [1]_com [2]_com [3]_com [4]_com [5]_com ## s = disp (infsupdec (0)) ## @result{} s = [0]_com ## @end group ## @end example ## @seealso{@@infsup/display, @@infsup/intervaltotext} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-30 function varargout = disp (x) if (nargin ~= 1) print_usage (); return endif ## With format="auto" the output precision can be set with the format command [s, isexact] = intervaltotext (x, "auto"); if (not (iscell (s))) ## Scalar interval if (nargout == 0) disp (s); else varargout {1} = cstrcat (s, "\n"); varargout {2} = isexact; endif return endif ## Interval matrix / vector columnwidth = max (cellfun ("length", s), [], 1); columnwidth += 3; # add 3 spaces between columns ## Print all columns buffer = ""; if (rows (x) > 0) ## FIXME: See display.m for how current_print_indent_level is used global current_print_indent_level; maxwidth = terminal_size () (2) - current_print_indent_level; cstart = uint32 (1); cend = cstart - 1; while (cstart <= columns (x)) ## Determine number of columns to print, print at least one column usedwidth = 0; submatrix = ""; do cend ++; submatrix = strcat (submatrix, ... prepad (strjust (char (s (:, cend))), columnwidth (cend), " ", 2)); usedwidth += columnwidth (cend); until (cend == columns (x) || ... (split_long_rows () && ... usedwidth + columnwidth (cend + 1) > maxwidth)) if (cstart > 1 || cend < columns (x)) if (cstart > 1) buffer = cstrcat (buffer, "\n"); endif if (cend > cstart) buffer = cstrcat (buffer, ... sprintf(" Columns %d through %d:\n\n", ... cstart, cend)); ... else buffer = cstrcat (buffer, ... sprintf(" Column %d:\n\n", cstart)); endif endif ## Convert string matrix into string with newlines buffer = cstrcat (buffer, strjoin (cellstr (submatrix), "\n"), "\n"); if (nargout == 0) printf (buffer); buffer = ""; endif cstart = cend + 1; endwhile endif if (nargout > 0) varargout {1} = buffer; varargout {2} = isexact; endif endfunction %!## Can't test the disp function. Would have to capture console output %!assert (1); interval-1.4.1/inst/@infsup/display.m0000644000000000000000000001002312657475772015715 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} display (@var{X}) ## ## Display the variable name and value of interval @var{X}. ## ## Interval boundaries are approximated with faithful decimal numbers. ## ## If @var{X} is a variable, the interval is display together with its variable ## name. The variable name is followed by an equality sign if all decimal ## boundaries exactly represent the actual boundaries. Otherwise a subset ## symbol is used instead (this feature is not available on Microsoft Windows). ## ## For non-scalar intervals the size and classification (interval vector or ## interval matrix) is displayed before the content. ## ## @example ## @group ## display (infsupdec (2)); ## @result{} [2]_com ## @end group ## @end example ## @example ## @group ## x = infsupdec (2); display (x); ## @result{} x = [2]_com ## @end group ## @end example ## @example ## @group ## y = infsupdec (eps); display (y); ## @result{} y ⊂ [2.2204e-16, 2.2205e-16]_com ## @end group ## @end example ## @example ## @group ## z = infsupdec (pascal (2)); display (z); ## @result{} z = 2×2 interval matrix ## [1]_com [1]_com ## [1]_com [2]_com ## @end group ## @end example ## @seealso{@@infsup/disp, @@infsup/intervaltotext} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-28 function display (x) if (nargin ~= 1) print_usage (); return endif global current_print_indent_level; save_current_print_indent_level = current_print_indent_level; unwind_protect label = inputname (1); if (isempty (label) && regexp(argn, '^\[\d+,\d+\]$')) ## During output of cell array contents label = argn; ## FIXME: Need access to octave_value::current_print_indent_level ## for correctly formatted nested cell array output current_print_indent_level = 2; else current_print_indent_level = 0; endif line_prefix = " " (ones (1, current_print_indent_level)); [s, isexact] = disp (x); printf (line_prefix); if (not (isempty (label))) printf (label); if (isexact || ispc ()) printf (" = "); else ## The Microsoft Windows console does not support this multibyte ## character. printf (" ⊂ "); endif endif if (isscalar (x)) ## Scalar interval printf (s); if (isempty (label)) printf ("\n"); endif return endif if (ispc ()) printf ("%dx%d interval ", size (x, 1), size (x, 2)); else ## The Microsoft Windows console does not support multibyte characters. printf ("%d×%d interval ", size (x, 1), size (x, 2)); endif if (isvector (x)) printf ("vector"); else printf ("matrix"); endif printf ("\n\n"); if (not (isempty (s))) printf (line_prefix); if (current_print_indent_level > 0) s = strrep (s, "\n", cstrcat ("\n", line_prefix)); s (end - current_print_indent_level + 1 : end) = ""; endif printf (s); printf ("\n"); endif unwind_protect_cleanup current_print_indent_level = save_current_print_indent_level; end_unwind_protect endfunction %!## Can't test the display function. Would have to capture console output %!assert (1); interval-1.4.1/inst/@infsup/dot.m0000644000000000000000000001220112657475772015036 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} dot (@var{X}, @var{Y}) ## @defmethodx {@@infsup} dot (@var{X}, @var{Y}, @var{DIM}) ## ## Compute the dot product of two interval vectors. ## ## If @var{X} and @var{Y} are matrices, calculate the dot products along the ## first non-singleton dimension. If the optional argument @var{DIM} is given, ## calculate the dot products along this dimension. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## dot ([infsup(1), 2, 3], [infsup(2), 3, 4]) ## @result{} ans = [20] ## @end group ## @group ## dot (infsup ([realmax; realmin; realmax]), [1; -1; -1], 1) ## @result{} ans ⊂ [-2.2251e-308, -2.225e-308] ## @end group ## @end example ## @seealso{@@infsup/plus, @@infsup/sum, @@infsup/times, @@infsup/sumabs, @@infsup/sumsq} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-26 function result = dot (x, y, dim) if (nargin < 2 || nargin > 3) print_usage (); return endif if (not (isa (x, "infsup"))) x = infsup (x); endif if (not (isa (y, "infsup"))) y = infsup (y); endif if (nargin < 3) if (isvector (x.inf) && isvector (y.inf)) ## Align vectors along common dimension dim = 1; x.inf = vec (x.inf, dim); x.sup = vec (x.sup, dim); y.inf = vec (y.inf, dim); y.sup = vec (y.sup, dim); else ## Try to find non-singleton dimension dim = find (any (size (x.inf), size (y.inf)) > 1, 1); if (isempty (dim)) dim = 1; endif endif endif ## null matrix input -> null matrix output if (isempty (x.inf) || isempty (y.inf)) result = infsup (zeros (min (size (x.inf), size (y.inf)))); return endif ## Only the sizes of non-singleton dimensions must agree. Singleton dimensions ## do broadcast (independent of parameter dim). if ((min (size (x.inf, 1), size (y.inf, 1)) > 1 && ... size (x.inf, 1) ~= size (y.inf, 1)) || ... (min (size (x.inf, 2), size (y.inf, 2)) > 1 && ... size (x.inf, 2) ~= size (y.inf, 2))) error ("interval:InvalidOperand", "dot: sizes of X and Y must match") endif resultsize = max (size (x.inf), size (y.inf)); resultsize (dim) = 1; l = u = zeros (resultsize); for n = 1 : numel (l) idx.type = "()"; idx.subs = cell (1, 2); idx.subs {dim} = ":"; idx.subs {3 - dim} = n; ## Select current vector in matrix or broadcast scalars and vectors. if (size (x.inf, 3 - dim) == 1) vector.x = x; else vector.x = subsref (x, idx); endif if (size (y.inf, 3 - dim) == 1) vector.y = y; else vector.y = subsref (y, idx); endif [l(n), u(n)] = vectordot (vector.x, vector.y); endfor result = infsup (l, u); endfunction ## Dot product of two interval vectors; or one vector and one scalar. ## Accuracy is tightest. function [l, u] = vectordot (x, y) if (isscalar (x.inf) && isscalar (y.inf)) ## Short-circuit: scalar × scalar z = x .* y; l = z.inf; u = z.sup; return endif [l, u] = mpfr_vector_dot_d (x.inf, y.inf, x.sup, y.sup); endfunction %!test "matrix × matrix"; %! assert (dot (infsup (magic (3)), magic (3)) == [89, 107, 89]); %! assert (dot (infsup (magic (3)), magic (3), 1) == [89, 107, 89]); %! assert (dot (infsup (magic (3)), magic (3), 2) == [101; 83; 101]); %!test "matrix × vector"; %! assert (dot (infsup (magic (3)), [1, 2, 3]) == [15, 30, 45]); %! assert (dot (infsup (magic (3)), [1, 2, 3], 1) == [15, 30, 45]); %! assert (dot (infsup (magic (3)), [1, 2, 3], 2) == [28; 34; 28]); %! assert (dot (infsup (magic (3)), [1; 2; 3]) == [26, 38, 26]); %! assert (dot (infsup (magic (3)), [1; 2; 3], 1) == [26, 38, 26]); %! assert (dot (infsup (magic (3)), [1; 2; 3], 2) == [15; 30; 45]); %!test "matrix × scalar"; %! assert (dot (infsup (magic (3)), 42) == [630, 630, 630]); %! assert (dot (infsup (magic (3)), 42, 1) == [630, 630, 630]); %! assert (dot (infsup (magic (3)), 42, 2) == [630; 630; 630]); %!test "vector × scalar"; %! assert (dot (infsup ([1, 2, 3]), 42) == 252); %! assert (dot (infsup ([1, 2, 3]), 42, 1) == [42, 84, 126]); %! assert (dot (infsup ([1, 2, 3]), 42, 2) == 252); %! assert (dot (infsup ([1; 2; 3]), 42) == 252); %! assert (dot (infsup ([1; 2; 3]), 42, 1) == 252); %! assert (dot (infsup ([1; 2; 3]), 42, 2) == [42; 84; 126]); %!test "from the documentation string"; %! assert (dot ([infsup(1), 2, 3], [infsup(2), 3, 4]) == 20); %! assert (dot (infsup ([realmax; realmin; realmax]), [1; -1; -1], 1) == -realmin); interval-1.4.1/inst/@infsup/ei.m0000644000000000000000000000366212657475772014660 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} ei (@var{X}) ## ## Compute the exponential integral for positive arguments. ## ## @tex ## $$ ## {\rm ei} (x) = \int_{-\infty}^x {{\exp t} \over t} dt ## $$ ## @end tex ## @ifnottex ## @group ## @verbatim ## x ## / exp (t) ## ei (x) = | --------- dt ## / t ## -∞ ## @end verbatim ## @end group ## @end ifnottex ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## ei (infsup (1)) ## @result{} ans ⊂ [1.8951, 1.8952] ## @end group ## @end example ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-29 function result = ei (x) if (nargin ~= 1) print_usage (); return endif l = inf (size (x.inf)); u = -l; ## ei is monotonically increasing and defined for x > 0 defined = x.sup > 0; l (defined) = mpfr_function_d ('ei', -inf, max (0, x.inf (defined))); u (defined) = mpfr_function_d ('ei', +inf, x.sup (defined)); result = infsup (l, u); endfunction %!assert (isempty (ei (infsup (0)))); %!assert (isempty (ei (infsup (-inf, -2)))); %!assert (isentire (ei (infsup (0, inf)))); %!test "from the documentation string"; %! assert (ei (infsup (1)) == "[0x1.E52670F350D08, 0x1.E52670F350D09]"); interval-1.4.1/inst/@infsup/eq.m0000644000000000000000000000524012657475772014662 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} eq (@var{A}, @var{B}) ## @defopx Operator {@@infsup} {@var{A} == @var{B}} ## ## Compare intervals @var{A} and @var{B} for equality. ## ## True, if all numbers from @var{A} are also contained in @var{B} and vice ## versa. False, if @var{A} contains a number which is not a member in @var{B} ## or vice versa. ## ## @example ## @group ## x = infsup (2, 3); ## y = infsup (1, 2); ## x == y ## @result{} ans = 0 ## @end group ## @end example ## @seealso{@@infsup/subset, @@infsup/interior, @@infsup/disjoint} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-30 function result = eq (a, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (a, "infsup"))) a = infsup (a); endif if (not (isa (b, "infsup"))) b = infsup (b); elseif (isa (b, "infsupdec")) ## Workaround for bug #42735 result = eq (a, b); return endif result = (a.inf == b.inf & a.sup == b.sup); endfunction %!test "Empty interval"; %! assert (eq (infsup (), infsup ()) == true); %! assert (eq (infsup (), infsup (1)) == false); %! assert (eq (infsup (0), infsup ()) == false); %! assert (eq (infsup (-inf, inf), infsup ()) == false); %!test "Singleton intervals"; %! assert (eq (infsup (0), infsup (1)) == false); %! assert (eq (infsup (0), infsup (0)) == true); %!test "Bounded intervals"; %! assert (eq (infsup (1, 2), infsup (3, 4)) == false); %! assert (eq (infsup (1, 2), infsup (2, 3)) == false); %! assert (eq (infsup (1, 2), infsup (1.5, 2.5)) == false); %! assert (eq (infsup (1, 2), infsup (1, 2)) == true); %!test "Unbounded intervals"; %! assert (eq (infsup (0, inf), infsup (-inf, 0)) == false); %! assert (eq (infsup (0, inf), infsup (0, inf)) == true); %! assert (eq (infsup (-inf, 0), infsup (-inf, 0)) == true); %! assert (eq (infsup (-inf, inf), infsup (42)) == false); %! assert (eq (infsup (-inf, 0), infsup (-inf, inf)) == false); %! assert (eq (infsup (-inf, inf), infsup (-inf, inf)) == true); interval-1.4.1/inst/@infsup/erf.m0000644000000000000000000000345012657475772015032 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} erf (@var{X}) ## ## Compute the error function. ## ## @tex ## $$ ## {\rm erf} (x) = {2 \over \sqrt{\pi}}\int_0^x \exp (-t^2) dt ## $$ ## @end tex ## @ifnottex ## @group ## @verbatim ## x ## 2 / ## erf (x) = ----- | exp (-t²) dt ## √π / ## 0 ## @end verbatim ## @end group ## @end ifnottex ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## erf (infsup (1)) ## @result{} ans ⊂ [0.8427, 0.84271] ## @end group ## @end example ## @seealso{@@infsup/erfc} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-28 function result = erf (x) if (nargin ~= 1) print_usage (); return endif ## erf is monotonically increasing l = mpfr_function_d ('erf', -inf, x.inf); u = mpfr_function_d ('erf', +inf, x.sup); emptyresult = isempty (x); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (erf (infsup (1)) == "[0x1.AF767A741088Ap-1, 0x1.AF767A741088Bp-1]"); interval-1.4.1/inst/@infsup/erfc.m0000644000000000000000000000351012657475772015172 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} erfc (@var{X}) ## ## Compute the complementary error function. ## ## @tex ## $$ ## {\rm erfc} (x) = {2 \over \sqrt{\pi}}\int_x^\infty \exp (-t^2) dt ## $$ ## @end tex ## @ifnottex ## @group ## @verbatim ## ∞ ## 2 / ## erfc (x) = ----- | exp (-t²) dt ## √π / ## x ## @end verbatim ## @end group ## @end ifnottex ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## erfc (infsup (1)) ## @result{} ans ⊂ [0.15729, 0.1573] ## @end group ## @end example ## @seealso{@@infsup/erf} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-28 function result = erfc (x) if (nargin ~= 1) print_usage (); return endif ## erf is monotonically decreasing l = mpfr_function_d ('erfc', -inf, x.sup); u = mpfr_function_d ('erfc', +inf, x.inf); emptyresult = isempty (x); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (erfc (infsup (1)) == "[0x1.4226162FBDDD4p-3, 0x1.4226162FBDDD5p-3]"); interval-1.4.1/inst/@infsup/exp.m0000644000000000000000000000301412657475772015046 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} exp (@var{X}) ## ## Compute the exponential function. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## exp (infsup (1)) ## @result{} ans ⊂ [2.7182, 2.7183] ## @end group ## @end example ## @seealso{@@infsup/log, @@infsup/pow} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-30 function result = exp (x) if (nargin ~= 1) print_usage (); return endif ## exp is monotonically increasing from (-inf, 0) to (inf, inf) l = mpfr_function_d ('exp', -inf, x.inf); # this also works for empty intervals u = mpfr_function_d ('exp', +inf, x.sup); # ... this does not u (isempty (x)) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (exp (infsup (1)) == infsup ("e")); interval-1.4.1/inst/@infsup/expm.m0000644000000000000000000000772512657475772015240 0ustar 00000000000000## Copyright 2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} expm (@var{A}) ## ## Compute the matrix exponential of square matrix @var{A}. ## ## The matrix exponential is defined as the infinite Taylor series ## ## @tex ## $$ ## {\rm expm} (A) = \sum_{k = 0}^{\infty} {A^k \over k!} ## $$ ## @end tex ## @ifnottex ## @group ## @verbatim ## A² A³ ## expm (A) = I + A + ---- + ---- + … ## 2! 3! ## @end verbatim ## @end group ## @end ifnottex ## ## The function implements the following algorithm: 1. The matrix is scaled, ## 2. an enclosure of the Taylor series is computed using the Horner scheme, ## 3. the matrix is squared. That is, the algorithm computes ## @code{expm (@var{A} ./ pow2 (@var{L})) ^ pow2 (@var{L})}. The scaling ## reduces the matrix norm below 1, which reduces errors during exponentiation. ## Exponentiation typically is done by Padé approximation, but that doesn't ## work for interval matrices, so we compute a Horner evaluation of the Taylor ## series. Finally, the exponentiation with @code{pow2 (@var{L})} is computed ## with @var{L} successive interval matrix square operations. Interval matrix ## square operations can be done without dependency errors (regarding each ## single step). ## ## The algorithm has been published by Alexandre Goldsztejn and Arnold ## Neumaier (2009), “On the Exponentiation of Interval Matrices.” ## ## Accuracy: The result is a valid enclosure. ## ## @example ## @group ## vec (expm (infsup(magic (3)))) ## @result{} ans ⊂ 9×1 interval vector ## ## [1.0897e+06, 1.0898e+06] ## [1.0896e+06, 1.0897e+06] ## [1.0896e+06, 1.0897e+06] ## [1.0895e+06, 1.0896e+06] ## [1.0897e+06, 1.0898e+06] ## [1.0897e+06, 1.0898e+06] ## [1.0896e+06, 1.0897e+06] ## [1.0896e+06, 1.0897e+06] ## [1.0896e+06, 1.0897e+06] ## ## @end group ## @end example ## @seealso{@@infsup/mpower, @@infsup/exp} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2016-01-26 function result = expm (A) if (nargin ~= 1) print_usage (); return endif if (isscalar (A)) ## Short-circuit for scalars result = exp (A); return endif if (not (issquare (A.inf))) error ("interval:InvalidOperand", ... "expm: must be square matrix"); endif ## Choose L such that ||A|| / 2^L < 0.1 and 10 <= L <= 100 L = min (max (inf (ceil (log2 (10 * norm (A, inf)))), 10), 100); ## Choose K such that K + 2 > ||A|| and 10 <= K <= 170 K = min (max (inf (ceil (norm (A, inf) - 2)), 10), 170); ## 1. Scale A = rdivide (A, pow2 (L)); ## 2. Compute Taylor series ## Compute Horner scheme: I + A*(I + A/2*(I + A/3*( ... (I + A/K) ... ))) result = I = eye (size (A.inf)); for k = K : -1 : 1 result = I + A ./ k * result; endfor ## Truncation error for the exponential series alpha = norm (A, inf); rho = pown (alpha, K + 1) ./ ... (factorial (infsup (K + 1)) * (1 - alpha ./ (K + 2))); warning ("off", "interval:ImplicitPromote", "local"); truncation_error = rho .* infsup (-1, 1); result = result + truncation_error; ## 3. Squaring result = mpower (result, pow2 (L)); endfunction %!test "from the paper"; %! A = infsup ([0 1; 0 -3], [0 1; 0 -2]); %! assert (all (all (subset (infsup ([1, 0.316738; 0, 0.0497871], [1, 0.432332; 0 0.135335]), expm (A)))));interval-1.4.1/inst/@infsup/expm1.m0000644000000000000000000000313512657475772015310 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} expm1 (@var{X}) ## ## Compute @code{exp (@var{X} - 1)} accurately in the neighborhood of zero. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## expm1 (infsup (eps)) ## @result{} ans ⊂ [2.2204e-16, 2.2205e-16] ## @end group ## @end example ## @seealso{@@infsup/exp, @@infsup/log1p} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-20 function result = expm1 (x) if (nargin ~= 1) print_usage (); return endif ## expm1 is monotonically increasing from (-inf, 0) to (inf, inf) l = mpfr_function_d ('expm1', -inf, x.inf); # this also works for [Empty] u = mpfr_function_d ('expm1', +inf, x.sup); # ... this does not u (isempty (x)) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (expm1 (infsup (eps)) == "[0x1p-52, 0x1.0000000000001p-52]"); interval-1.4.1/inst/@infsup/factorial.m0000644000000000000000000000450112657475772016220 0ustar 00000000000000## Copyright 2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} factorial (@var{N}) ## ## Compute the factorial of @var{N} where @var{N} is a real non-negative ## integer. ## ## If @var{N} is a scalar, this is equivalent to ## @display ## factorial (@var{N}) = 1 * 2 * @dots{} * @var{N}. ## @end display ## For vector or matrix arguments, return the factorial of each element in the ## array. ## ## For non-integers see the generalized factorial function @command{gamma}. ## Not that the factorial function grows large quite quickly, and the result ## cannot be represented exactly in binary64 for @var{N} ≥ 23 and will overflow ## for @var{N} ≥ 171. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## factorial (infsup (6)) ## @result{} ans = [720] ## @end group ## @end example ## @seealso{@@infsup/prod, @@infsup/gamma, @@infsup/gammaln} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2016-01-31 function result = factorial (x) if (nargin ~= 1) print_usage (); return endif l = max (0, ceil (x.inf)); u = floor (x.sup); emptyresult = l > u; l (emptyresult) = inf; u (emptyresult) = -inf; l (not (emptyresult)) = ... mpfr_function_d ("factorial", -inf, l (not (emptyresult))); u (not (emptyresult)) = ... mpfr_function_d ("factorial", +inf, u (not (emptyresult))); result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (factorial (infsup (6)) == 720); %!assert (factorial (infsup (0)) == 1); %!assert (factorial (infsup ("[0, 1.99]")) == 1); %!assert (factorial (infsup ("[0, 2]")) == "[1, 2]"); %!assert (factorial (infsup ("[1.4, 1.6]")) == "[Empty]"); interval-1.4.1/inst/@infsup/fix.m0000644000000000000000000000521512657475772015045 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} fix (@var{X}) ## ## Truncate fractional portion of each number in interval @var{X}. This is ## equivalent to rounding towards zero. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## fix (infsup (2.5, 3.5)) ## @result{} ans = [2, 3] ## fix (infsup (-0.5, 5)) ## @result{} ans = [0, 5] ## @end group ## @end example ## @seealso{@@infsup/floor, @@infsup/ceil, @@infsup/round, @@infsup/roundb} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-04 function result = fix (x) if (nargin ~= 1) print_usage (); return endif result = infsup (fix (x.inf), fix (x.sup)); endfunction %!test "Empty interval"; %! assert (fix (infsup ()) == infsup ()); %!test "Singleton intervals"; %! assert (fix (infsup (0)) == infsup (0)); %! assert (fix (infsup (1)) == infsup (1)); %! assert (fix (infsup (1+eps)) == infsup (1)); %! assert (fix (infsup (-1)) == infsup (-1)); %! assert (fix (infsup (0.5)) == infsup (0)); %! assert (fix (infsup (-0.5)) == infsup (0)); %!test "Bounded intervals"; %! assert (fix (infsup (-0.5, 0)) == infsup (0)); %! assert (fix (infsup (0, 0.5)) == infsup (0)); %! assert (fix (infsup (0.25, 0.5)) == infsup (0)); %! assert (fix (infsup (-1, 0)) == infsup (-1, 0)); %! assert (fix (infsup (-1, 1)) == infsup (-1, 1)); %! assert (fix (infsup (-realmin, realmin)) == infsup (0)); %! assert (fix (infsup (-realmax, realmax)) == infsup (-realmax, realmax)); %!test "Unbounded intervals"; %! assert (fix (infsup (-realmin, inf)) == infsup (0, inf)); %! assert (fix (infsup (-realmax, inf)) == infsup (-realmax, inf)); %! assert (fix (infsup (-inf, realmin)) == infsup (-inf, 0)); %! assert (fix (infsup (-inf, realmax)) == infsup (-inf, realmax)); %! assert (fix (infsup (-inf, inf)) == infsup (-inf, inf)); %!test "from the documentation string"; %! assert (fix (infsup (2.5, 3.5)) == infsup (2, 3)); %! assert (fix (infsup (-0.5, 5)) == infsup (0, 5)); interval-1.4.1/inst/@infsup/floor.m0000644000000000000000000000500112657475772015371 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} floor (@var{X}) ## ## Round each number in interval @var{X} towards -Inf. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## floor (infsup (2.5, 3.5)) ## @result{} ans = [2, 3] ## floor (infsup (-0.5, 5)) ## @result{} ans = [-1, +5] ## @end group ## @end example ## @seealso{@@infsup/ceil, @@infsup/round, @@infsup/roundb, @@infsup/fix} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-04 function result = floor (x) if (nargin ~= 1) print_usage (); return endif result = infsup (floor (x.inf), floor (x.sup)); endfunction %!test "Empty interval"; %! assert (floor (infsup ()) == infsup ()); %!test "Singleton intervals"; %! assert (floor (infsup (0)) == infsup (0)); %! assert (floor (infsup (0.5)) == infsup (0)); %! assert (floor (infsup (-0.5)) == infsup (-1)); %!test "Bounded intervals"; %! assert (floor (infsup (-0.5, 0)) == infsup (-1, 0)); %! assert (floor (infsup (0, 0.5)) == infsup (0)); %! assert (floor (infsup (0.25, 0.5)) == infsup (0)); %! assert (floor (infsup (-1, 0)) == infsup (-1, 0)); %! assert (floor (infsup (-1, 1)) == infsup (-1, 1)); %! assert (floor (infsup (-realmin, realmin)) == infsup (-1, 0)); %! assert (floor (infsup (-realmax, realmax)) == infsup (-realmax, realmax)); %!test "Unbounded intervals"; %! assert (floor (infsup (-realmin, inf)) == infsup (-1, inf)); %! assert (floor (infsup (-realmax, inf)) == infsup (-realmax, inf)); %! assert (floor (infsup (-inf, realmin)) == infsup (-inf, 0)); %! assert (floor (infsup (-inf, realmax)) == infsup (-inf, realmax)); %! assert (floor (infsup (-inf, inf)) == infsup (-inf, inf)); %!test "from the documentation string"; %! assert (floor (infsup (2.5, 3.5)) == infsup (2, 3)); %! assert (floor (infsup (-0.5, 5)) == infsup (-1, 5)); interval-1.4.1/inst/@infsup/fma.m0000644000000000000000000001037012657475772015020 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} fma (@var{X}, @var{Y}, @var{Z}) ## ## Fused multiply and add @code{@var{X} * @var{Y} + @var{Z}}. ## ## This function is semantically equivalent to evaluating multiplication and ## addition separately, but in addition guarantees a tight enclosure of the ## result. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## output_precision (16, 'local') ## fma (infsup (1+eps), infsup (7), infsup ("0.1")) ## @result{} ans ⊂ [7.100000000000001, 7.100000000000003] ## infsup (1+eps) * infsup (7) + infsup ("0.1") ## @result{} ans ⊂ [7.1, 7.100000000000003] ## @end group ## @end example ## @seealso{@@infsup/plus, @@infsup/times} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-03 function result = fma (x, y, z) if (nargin ~= 3) print_usage (); return endif if (not (isa (x, "infsup"))) x = infsup (x); endif if (not (isa (y, "infsup"))) y = infsup (y); endif if (not (isa (z, "infsup"))) z = infsup (z); endif ## Resize, if scalar × matrix if (isscalar (x.inf) ~= isscalar (y.inf)) x.inf = ones (size (y.inf)) .* x.inf; x.sup = ones (size (y.inf)) .* x.sup; y.inf = ones (size (x.inf)) .* y.inf; y.sup = ones (size (x.inf)) .* y.sup; endif if (isscalar (y.inf) ~= isscalar (z.inf)) y.inf = ones (size (z.inf)) .* y.inf; y.sup = ones (size (z.inf)) .* y.sup; z.inf = ones (size (y.inf)) .* z.inf; z.sup = ones (size (y.inf)) .* z.sup; endif if (isscalar (x.inf) ~= isscalar (z.inf)) x.inf = ones (size (z.inf)) .* x.inf; x.sup = ones (size (z.inf)) .* x.sup; z.inf = ones (size (x.inf)) .* z.inf; z.sup = ones (size (x.inf)) .* z.sup; endif ## [Empty] × anything = [Empty] ## [0] × anything = [0] × [0] ## [Entire] × anything but [0] = [Entire] × [Entire] ## This prevents the cases where 0 × inf would produce NaNs. entireproduct = isentire (x) | isentire (y); zeroproduct = (x.inf == 0 & x.sup == 0) | (y.inf == 0 & y.sup == 0); emptyresult = isempty (x) | isempty (y) | isempty (z); x.inf (entireproduct) = y.inf (entireproduct) = -inf; x.sup (entireproduct) = y.sup (entireproduct) = inf; x.inf (zeroproduct) = x.sup (zeroproduct) = ... y.inf (zeroproduct) = y.sup (zeroproduct) = 0; ## It is hard to determine, which boundaries of x and y take part in the ## multiplication of fma. Therefore, we simply compute the fma for each triple ## of boundaries where the min/max could be located. ## ## How to construct complicated cases: a = rand, b = rand, c = rand, ## d = a * b / c (with round towards -infinity for multiplication and towards ## +infinity for division). Then, it is not possible to decide in 50% of all ## cases whether a * b would be greater or less than c * d by computing the ## products in double-precision. l = min (min (min (... mpfr_function_d ('fma', -inf, x.inf, y.inf, z.inf), ... mpfr_function_d ('fma', -inf, x.inf, y.sup, z.inf)), ... mpfr_function_d ('fma', -inf, x.sup, y.inf, z.inf)), ... mpfr_function_d ('fma', -inf, x.sup, y.sup, z.inf)); u = max (max (max (... mpfr_function_d ('fma', +inf, x.inf, y.inf, z.sup), ... mpfr_function_d ('fma', +inf, x.inf, y.sup, z.sup)), ... mpfr_function_d ('fma', +inf, x.sup, y.inf, z.sup)), ... mpfr_function_d ('fma', +inf, x.sup, y.sup, z.sup)); l (emptyresult) = +inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (fma (infsup (1+eps), infsup (7), infsup ("0.1")) == "[0x1.C666666666668p2, 0x1.C666666666669p2]"); interval-1.4.1/inst/@infsup/fminsearch.m0000644000000000000000000002135112657475772016375 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding utf-8 ## @deftypemethod {@@infsup} {@var{X} =} fminsearch (@var{f}, @var{X0}) ## @deftypemethodx {@@infsup} {[@var{X}, @var{FVAL}] =} fminsearch (@var{f}, @var{X0}, @var{options}) ## ## Minimize the function @var{f} over the interval box @var{X0} and return ## rigorous bounds. ## ## The function @var{f} may be multivariate, that is, the interval box @var{X0} ## may be a vector or matrix of intervals. The output of the function must be ## scalar. ## ## The rigorous bounds on @var{FVAL} satisfy 0 ≤ min @{f (@var{x}) | ## @var{x} ∈ @var{X0}@} - inf (@var{FVAL}) ≤ 1e-4 by default. Different ## accuracy requirements may be defined using @var{options}.TolFun. ## ## @example ## @group ## [x, fval] = fminsearch (@@cos, infsup ("[0, 4]")) ## @result{} ## x ⊂ [3.114, 3.1858] ## fval ⊂ [-1, -0.99996] ## @end group ## @end example ## ## During each iteration the interval is bisected at its widest coordinate ## until the desired accuracy has been reached. ## ## @example ## @group ## f = @@(x) x(1) .^ 2 - x(2) .^ 2; ## [x, fval] = fminsearch (f, infsup ("[-1, 1] [-1, 1]")) ## @result{} ## x ⊂ 1×2 interval vector ## ## [7.8828e-11, 8.8786e-06] [0.99991, 1] ## ## fval ⊂ [-1, -0.99991] ## @end group ## @end example ## ## Note that the algorithm tries to minimize @var{FVAL} and the returned ## value for @var{X} need not contain the minimum value of the function over ## @var{X0}; the value @var{X} is just “close” to one of possibly several ## places where the minimum occurs, that is, hull (f (@var{X})) overlaps ## [@var{M}-ε, @var{M}+ε], where @var{M} is the actual minimum of the ## function f over @var{X0} and ε equals @var{options}.TolFun. Also, it holds ## @var{M} ∈ @var{FVAL}, but in general it does @emph{not} hold ## f (@var{X}) ⊆ @var{FVAL}. ## ## It is possible to use the following optimization @var{options}: ## @option{Display}, @option{MaxFunEvals}, @option{MaxIter}, ## @option{OutputFcn}, @option{TolFun}, @option{TolX}. ## ## @example ## @group ## f = @@(x) -sin (hypot (x(1), x(2))) / hypot (x(1), x(2)); ## [x, fval] = fminsearch (f, infsup ("[-1, 1] [-1, 1]"), ... ## optimset ('MaxIter', 20)) ## @result{} ## x ⊂ 1×2 interval vector ## ## [0, 1.9763e-323] [0, 1.9763e-323] ## ## fval ⊂ [-Inf, -0.99999] ## @end group ## @end example ## ## The function utilizes the Skelboe-Moore algorithm and has been implemented ## after Algorithm 6.1 in R. E. Moore, R. B. Kearfott, and M. J. Cloud. 2009. ## Introduction to Interval Analysis. Society for Industrial and Applied ## Mathematics. ## ## @seealso{optimset} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-09-18 function [X, FVAL, iter] = fminsearch (f, X, options) if (nargin < 2) print_usage (); return endif if (not (is_function_handle (f)) && not (ischar (f))) error ("interval:InvalidOperand", ... "fminsearch: Parameter f is no function handle") elseif (not (isa (X, "infsup"))) error ("interval:InvalidOperand", ... "fminsearch: Parameter X0 is no interval") endif defaultoptions = optimset (optimset, 'TolFun', 1e-4); if (nargin < 3) options = defaultoptions; else options = optimset (defaultoptions, options); endif displayiter = strcmp (options.Display, "iter"); ## 1 Rigorous upper bound on the minimum of f over X fmX = feval (f, infsup (mid (X))); if (not (isa (fmX, "infsup")) || not (isscalar (fmX))) error ("interval:InvalidOperand", ... "fminsearch: Function f does not return scalar intervals") endif if (isempty (fmX)) f_ub = inf; else f_ub = sup (fmX); endif ## 3 Initialize queues ## C: Completed boxes where accuracy has been reached (it suffices to store a ## single element, because this function doesn't return all candidates) ## L: Boxes where accuracy has not been reached yet L.X = C.X = {}; L.fX = C.fX = infsup ([]); iter = 0; feval_count = 1; cancel_algorithm = false (); idx.type = "()"; while (true) iter ++; if (displayiter) display (X); endif ## 4 Bisect X at the coordinate i with the widest interval X1 = X2 = X; [~, i] = max (vec (wid (X))); idx.subs = {i}; [pt1, pt2] = bisect (subsref (X, idx)); X1 = subsasgn (X1, idx, pt1); X2 = subsasgn (X2, idx, pt2); if (not (isempty (options.OutputFcn))) feval (options.OutputFcn, X1); feval (options.OutputFcn, X2); endif ## 5 Improve upper bound fmX1 = feval (f, infsup (mid (X1))); if (not (isempty (fmX1))) f_ub = min (f_ub, sup (fmX1)); endif fmX2 = feval (f, infsup (mid (X2))); if (not (isempty (fmX2))) f_ub = min (f_ub, sup (fmX2)); endif ## 6 Quit current X box if accuracy has been reached f1 = feval (f, X1); f2 = feval (f, X2); feval_count += 4; cancel_algorithm = feval_count >= options.MaxFunEvals || ... iter >= options.MaxIter || ... f_ub <= -realmax (); if (min (f_ub, max (sup (f1), sup (f2))) ... - min (inf (f1), inf (f2)) < options.TolFun ... || max (max (wid (X1))) < options.TolX ... || cancel_algorithm) ## Accuracy has been reached for X1 and X2 C = merge_candidates (C, X1, f1); C = merge_candidates (C, X2, f2); else ## Put intervals into work queue if (inf (f1) < f_ub) L = insert_ordered_list (L, X1, f1); endif if (inf (f2) < f_ub) L = insert_ordered_list (L, X2, f2); endif endif ## More refinement to do on other boxes? if (isempty (L.X) || cancel_algorithm) break endif ## (i) Use next item from L [L, X, fX] = pop_ordered_list (L); ## (ii) Check whether improvement is still possible if (inf (fX) > f_ub) break endif endwhile assert (not (isempty (C.X))); [C, X, FVAL] = pop_ordered_list (C); if (isfinite (f_ub)) FVAL = intersect (FVAL, infsup (-inf, f_ub)); endif if (any (strcmp (options.Display, {"iter", "final"})) || ... (cancel_algorithm && strcmp (options.Display, "notify"))) printf ('\nTarget accuracy has%s been reached after %d step(s)\n', ... ' not'(1:end * cancel_algorithm), ... iter); display (X); display (FVAL); endif endfunction function candidate = merge_candidates (candidate, X, fX) if (isempty (candidate.X) || inf (fX) < inf (candidate.fX)) candidate.X = {X}; candidate.fX = fX; endif endfunction function list = insert_ordered_list (list, X, fX) position = find (inf (list.fX) >= inf (fX), 1); if (isempty (position)) list.fX = vertcat (list.fX, fX); list.X = vertcat (list.X, {X}); elseif (position == 1) list.fX = vertcat (fX, list.fX); list.X = vertcat ({X}, list.X); else idx1.type = idx2.type = "()"; idx1.subs = {1:(position - 1)}; idx2.subs = {position:numel(list.X)}; list.fX = vertcat (subsref (list.fX, idx1), ... fX, ... subsref (list.fX, idx2)); idx.type = "{}"; list.X = vertcat (subsref (list.X, idx1), ... {X}, ... subsref (list.X, idx2)); endif endfunction function [list, X, fX] = pop_ordered_list (list) X = list.X {1}; idx.type = "()"; if (nargout >= 3) idx.subs = {1}; fX = subsref (list.fX, idx); endif if (numel (list.X) == 1) list.fX = infsup ([]); list.X = {}; else idx.subs = {2:numel(list.X)}; list.fX = subsref (list.fX, idx); list.X = subsref (list.X, idx); endif endfunction %!test %! sqr = @(x) x .^ 2; %! [x, y] = fminsearch (sqr, infsup (-inf, inf)); %! assert (y == 0); %!demo %! clf %! hold on %! draw = @(x) plot (x(1), x(2), [238 232 213]/255, [88 110 117]/255); %! f = @(x) (x(1) - 2) .^ 2 - x(2) .^ 2; %! fminsearch (f, infsup ("[1, 3] [0, 1]"), ... %! optimset ('OutputFcn', draw)); %! hold off interval-1.4.1/inst/@infsup/fsolve.m0000644000000000000000000005136512657475772015564 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {@var{X} =} fsolve (@var{F}) ## @deftypemethodx {@@infsup} {@var{X} =} fsolve (@var{F}, @var{X0}) ## @deftypemethodx {@@infsup} {@var{X} =} fsolve (@var{F}, @var{X0}, @var{Y}) ## @deftypemethodx {@@infsup} {@var{X} =} fsolve (@dots{}, @var{OPTIONS}) ## @deftypemethodx {@@infsup} {[@var{X}, @var{X_PAVING}, @var{X_INNER_IDX}] =} fsolve (@dots{}) ## ## Compute the preimage of the set @var{Y} under function @var{F}. ## ## Parameter @var{Y} is optional and without it solve ## @code{@var{F}(@var{x}) = 0} for @var{x} ∈ @var{X0}. Without a starting box ## @var{X0} the function is assumed to be univariate and the solution is ## searched among all real numbers. ## ## The function must be an interval arithmetic function and may be ## multivariate, that is, @var{X0} and @var{Y} may be vectors or matrices of ## intervals. The computational complexity largely depends on the dimension of ## @var{X0}. ## ## Return value @var{X} is an interval enclosure of ## @code{@{@var{x} ∈ @var{X0} | @var{F}(@var{x}) ∈ @var{Y}@}}. The optional ## return value @var{X_PAVING} is a matrix of non-overlapping interval values ## for @var{x} in each column, which form a more detailed enclosure for the ## preimage of @var{Y}. An index vector @var{X_INNER_IDX} indicates the ## columns of @var{X_PAVING}, which are guaranteed to be subsets of the ## preimage of @var{Y}. ## ## This function uses the set inversion via interval arithmetic (SIVIA) ## algorithm. That is, @var{X} is bisected until @var{F}(@var{X}) is either ## a subset of @var{Y} or until they are disjoint. ## ## @example ## @group ## fsolve (@@cos, infsup(0, "pi")) ## @result{} ans ⊂ [1.5646, 1.5708] ## @end group ## @end example ## ## It is possible to use the following optimization @var{options}: ## @option{MaxFunEvals}, @option{MaxIter}, @option{TolFun}, @option{TolX}, ## @option{Vectorize}, @option{Contract}. ## ## If @option{Vectorize} is @code{true}, the function @var{F} will be called ## with input arguments @code{@var{x}(1)}, @code{@var{x}(2)}, @dots{}, ## @code{@var{x}(numel (@var{X0}))} and each input argument will carry a vector ## of different values which shall be computed simultaneously. If @var{Y} is a ## scalar or vector, @option{Vectorize} defaults to @code{true}. If ## @option{Vectorize} is @code{false}, the function @var{F} will receive only ## one input argument @var{x} at a time, which has the size of @var{X0}. ## ## @example ## @group ## # Solve x1 ^ 2 + x2 ^ 2 = 1 for -3 ≤ x1, x2 ≤ 3, ## # the exact solution is a unit circle ## x = fsolve (@@hypot, infsup ([-3; -3], [3; 3]), 1) ## @result{} x ⊂ 2×1 interval vector ## ## [-1.002, +1.002] ## [-1.0079, +1.0079] ## ## @end group ## @end example ## ## If @option{Contract} is @code{true}, the function @var{F} will be called ## with @var{Y} as an additional leading input argument and, in addition to the ## function value, must return a @dfn{contraction} of its input argument(s). ## A contraction for input argument @var{x} is a subset of @var{x} which ## contains all possible solutions for the equation ## @code{@var{F} (@var{x}) = @var{Y}}. Contractions can be computed using ## interval reverse operations, for example with @code{@@infsup/absrev} which ## contracts the input argument for the absolute value function. ## ## @example ## @group ## # Solve x1 ^ 2 + x2 ^ 2 = 1 for -3 ≤ x1, x2 ≤ 3 again, ## # but now contractions speed up the algorithm. ## function [fval, cx1, cx2] = f (y, x1, x2) ## # Forward evaluation ## x1_sqr = x1 .^ 2; ## x2_sqr = x2 .^ 2; ## fval = hypot (x1, x2); ## ## # Reverse evaluation and contraction ## y = intersect (y, fval); ## # Contract the squares ## x1_sqr = intersect (x1_sqr, y - x2_sqr); ## x2_sqr = intersect (x2_sqr, y - x1_sqr); ## # Contract the parameters ## cx1 = sqrrev (x1_sqr, x1); ## cx2 = sqrrev (x2_sqr, x2); ## endfunction ## ## x = fsolve (@@f, infsup ([-3; -3], [3; 3]), 1, ... ## struct ('Contract', true)) ## @result{} x = 2×1 interval vector ## ## [-1, +1] ## [-1, +1] ## ## @end group ## @end example ## ## It is possible to combine options @option{Vectorize} and @option{Contract}. ## Depending on the combination, function @var{F} should have one of the ## following signatures. ## ## @table @code ## @item function fval = f (x) ## @option{Vectorize} = @code{false} and @option{Contract} = @code{false}. ## @item function fval = f (x1, x2, @dots{}, xN) ## @option{Vectorize} = @code{true} and @option{Contract} = @code{false}. ## @item function [fval, cx] = f (y, x) ## @option{Vectorize} = @code{false} and @option{Contract} = @code{true}. ## @code{cx} is a contraction of @code{x}. ## @item function [fval, cx1, cx2, @dots{}, cxN] = f (y, x1, x2, @dots{}, xN) ## @option{Vectorize} = @code{true} and @option{Contract} = @code{true}. ## @code{cx1} is a contraction of @code{x1}, @code{cx2} is a contraction of ## @code{x2}, and so on. ## @end table ## ## Note on performance: The bisection method is a brute-force approach to ## exhaust the function's domain and requires a lot of function evaluations. ## It is highly recommended to use a function @var{F} which allows ## vectorization. For higher dimensions of @var{X0} it is also necessary to ## use a contraction function. ## ## Accuracy: The result is a valid enclosure. ## ## @seealso{@@infsup/fzero, ctc_union, ctc_intersect, optimset} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-11-28 function [x, x_paving, x_inner_idx] = fsolve (f, x0, y, options) ## Set default parameters warning ("off", "", "local") # disable optimset warning defaultoptions = optimset (optimset, ... 'MaxIter', 20, ... 'MaxFunEval', 3000, ... 'TolX', 1e-2, ... 'TolFun', 1e-2, ... 'Vectorize', [], ... 'Contract', false); switch (nargin) case 1 x0 = infsup (-inf, inf); y = infsup (0); options = defaultoptions; case 2 y = infsup (0); if (isstruct (x0)) options = optimset (defaultoptions, x0); x0 = infsup (-inf, inf); else options = defaultoptions; endif case 3 if (isstruct (y)) options = optimset (defaultoptions, y); y = infsup (0); else options = defaultoptions; endif case 4 options = optimset (defaultoptions, options); otherwise print_usage (); return endswitch ## Convert x0 and y to intervals if (not (isa (x0, "infsup"))) if (isa (y, "infsupdec")) x0 = infsupdec (x0); else x0 = infsup (x0); endif endif if (not (isa (y, "infsup"))) if (isa (x0, "infsupdec")) y = infsupdec (y); else y = infsup (y); endif endif ## Check parameters if (isempty (x0) || isempty (y) || numel (x0) == 0 || numel (y) == 0) error ("interval:InvalidOperand", ... "fsolve: Initial interval is empty, nothing to do") elseif (not (is_function_handle (f)) && not (ischar (f))) error ("interval:InvalidOperand", ... "fsolve: Parameter F is no function handle") endif ## Strip decoration part if (isa (x0, "infsupdec")) if (isnai (x0)) x = x0; x_paving = {x0}; x_inner_idx = false; return endif x0 = intervalpart (x0); endif if (isa (y, "infsupdec")) if (isnai (y)) x = y; x_paving = {y}; x_inner_idx = false; return endif y = intervalpart (y); endif ## Try to vectorize function evaluation if (isempty (options.Vectorize) && isvector (y)) try f_argn = nargin (f); if (options.Contract) options.Vectorize = (f_argn > 2 || f_argn < 0 || numel (x0) == 1); else options.Vectorize = (f_argn > 1 || f_argn < 0 || numel (x0) == 1); endif catch ## nargin doesn't work for built-in functions, which happen to agree ## with infsup methods. Try to vectorize these. options.Vectorize = true; end_try_catch endif if (options.Vectorize) if (nargout >= 2) [x, x_paving, x_inner_idx] = vectorized (f, x0, y, options); else x = vectorized (f, x0, y, options); endif return endif warning ("off", "interval:ImplicitPromote", "local"); x = empty (size (x0)); x_paving = {}; x_inner_idx = false (0); queue = {x0}; x_scalar = isscalar (x0); ## Test functions verify_subset = @(fval) all (all (subset (fval, y))); verify_disjoint = @(fval) any (any (disjoint (fval, y))); check_contradiction = @(x) any (any (isempty (x))); max_wid = @(interval) max (max (wid (interval))); ## Utility functions for bisection if (x_scalar) bisect_coord = {1}; exchange_coordinate = @(interval, coord, l, u) infsup (l, u); else largest_coordinate = @(interval, max_wid) ... find (wid (interval) == max_wid, 1); exchange_coordinate = @replace_coordinate; endif while (not (isempty (queue))) ## Evaluate f(x) options.MaxFunEvals -= numel (queue); options.MaxIter --; if (options.Contract) [fval, contractions] = cellfun (f, {y}, queue, ... "UniformOutput", false); ## Sanitize the contractions returned by the function queue = cellfun (@intersect, queue, contractions, ... "UniformOutput", false); ## Utilize contradictions to discard candidates contradiction = cellfun (check_contradiction, queue); queue = queue(not (contradiction)); if (isempty (queue)) break endif fval = fval(not (contradiction)); else fval = cellfun (f, queue, "UniformOutput", false); endif ## Check whether x is outside of the preimage of y ## or x is inside the preimage of y is_outside = cellfun (verify_disjoint, fval); is_inside = cellfun (verify_subset, fval) & not (is_outside); ## Store the verified subsets of the preimage of y and continue only on ## elements that are not verified x = hull (x, queue(is_inside){:}); x_paving = vertcat (x_paving, queue(is_inside)); x_inner_idx = vertcat (x_inner_idx, true (sum (is_inside), 1)); queue = queue(not (is_inside | is_outside)); ## Stop after MaxIter or MaxFunEvals if (options.MaxIter <= 0 || options.MaxFunEvals <= 0) x = hull (x, queue{:}); x_paving = vertcat (x_paving, queue); x_inner_idx = vertcat (x_inner_idx, false (numel (queue), 1)); break endif ## Stop iteration for small intervals if (not (isempty (options.TolFun))) fval = fval(not (is_inside | is_outside)); widths = cellfun (max_wid, fval); is_small = widths < options.TolFun; else is_small = false (size (queue)); endif widths = cellfun (max_wid, queue); is_small = is_small | (widths < options.TolX); x = hull (x, queue(is_small){:}); x_paving = vertcat (x_paving, queue(is_small)); x_inner_idx = vertcat (x_inner_idx, false (sum (is_small), 1)); queue = queue(not (is_small)); widths = widths(not (is_small)); ## Bisect remaining intervals at the largest coordinate. ## ## Since the bisect function is the most costly, we want to call it only ## once. Thus, we extract the largest coordinate from each interval matrix ## inside queue and combine them into an interval vector [l_coord, u_coord] ## with the length of queue. We call the bisect function on this vector, ## which bisects each interval component and produces vectors ## [l_coord, m_coord] and [m_coord, u_coord]. These are used to replace the ## largest coordinate from each original interval matrix. if (x_scalar) [l_coord, u_coord] = ... cellfun (@(interval) ... deal (interval.inf, interval.sup), ... queue); else bisect_coord = cellfun (largest_coordinate, ... queue, num2cell (widths), ... "UniformOutput", false); [l_coord, u_coord] = ... cellfun (@(interval, coord) ... deal (interval.inf(coord), interval.sup(coord)), ... queue, bisect_coord); endif m_coord = mid (infsup (l_coord, u_coord)); l_coord = num2cell (l_coord); m_coord = num2cell (m_coord); u_coord = num2cell (u_coord); queue = vertcat (... cellfun (exchange_coordinate, ... queue, bisect_coord, l_coord, m_coord, ... "UniformOutput", false), ... cellfun (exchange_coordinate, ... queue, bisect_coord, m_coord, u_coord, ... "UniformOutput", false)); ## Short-circuit if no paving must be computed and remaining intervals ## are subsets of the already computed interval enclosure. if (isempty (queue)) break endif if (nargout < 2) x_bare = intervalpart (x); queue = queue(not (cellfun (@(q) all (all (subset (q, x_bare))), ... queue))); endif endwhile x = intervalpart (x); if (nargout >= 2) x_paving = cellfun (@vec, x_paving, "UniformOutput", false); x_paving = horzcat (x_paving{:}); endif endfunction function interval = replace_coordinate (interval, coord, l, u) interval.inf(coord) = l; interval.sup(coord) = u; endfunction ## Variant of above algorithm, which utilized vectorized evaluation of f function [x, x_paving, x_inner_idx] = vectorized (f, x0, y, options) warning ("off", "Octave:broadcast", "local"); ## Make vectorization dimension cat_dim orthogonal to the dimension of the data ## in y to allow simple function definitions. if (iscolumn (y)) x0 = vec (x0); data_dim = 1; cat_dim = 2; else assert (isrow (y)); x0 = transpose (vec (x0)); data_dim = 2; cat_dim = 1; endif x = intervalpart (empty (size (x0))); s = size (x0); s(cat_dim) = 0; x_paving = infsup (zeros (s)); x_inner_idx = false (0); queue = x0; x_scalar = isscalar (x0); ## Test functions verify_subset = @(fval) all (subset (fval, y), data_dim); verify_disjoint = @(fval) any (disjoint (fval, y), data_dim); ## Utility functions for indexing the queue idx.type = '()'; idx.subs = {:, :}; while (not (isempty (queue.inf))) ## Evaluate f(x) l_args = num2cell (queue.inf, cat_dim); u_args = num2cell (queue.sup, cat_dim); f_args = cellfun (@(l, u) infsup (l, u), ... l_args, u_args, ... "UniformOutput", false); options.MaxFunEvals --; options.MaxIter --; if (options.Contract) fval_and_contractions = nthargout (1 : (1 + length (x0)), ... @feval, f, y, f_args{:}); fval = fval_and_contractions{1}; contractions = cat (data_dim, fval_and_contractions{2 : end}); ## Sanitize the contractions returned by the function queue = intersect (queue, contractions); ## Utilize contradictions to discard candidates contradiction = any (isempty (queue), data_dim); idx.subs{cat_dim} = not (contradiction); queue = subsref (queue, idx); if (isempty (queue.inf)) break endif fval = subsref (fval, idx); else fval = feval (f, f_args{:}); endif ## Check whether x is outside of the preimage of y ## or x is inside the preimage of y is_outside = verify_disjoint (fval); is_inside = verify_subset (fval) & not (is_outside); ## Store the verified subsets of the preimage of y and continue only on ## elements that are not verified idx.subs{cat_dim} = is_inside; queue_inside = subsref (queue, idx); x = union (cat (cat_dim, x, queue_inside), [], cat_dim); x_paving = cat (cat_dim, x_paving, queue_inside); x_inner_idx = cat (cat_dim, x_inner_idx, is_inside(is_inside)); idx.subs{cat_dim} = not (is_inside | is_outside); queue = subsref (queue, idx); ## Stop after MaxIter or MaxFunEvals if (options.MaxIter <= 0 || options.MaxFunEvals <= 0) x = union (cat (cat_dim, x, queue), [], cat_dim); x_paving = cat (cat_dim, x_paving, queue); s = size (queue); s(data_dim) = 1; x_inner_idx = cat (cat_dim, x_inner_idx, false (s)); break endif ## Stop iteration for small intervals if (not (isempty (options.TolFun))) idx.subs{cat_dim} = not (is_inside | is_outside); fval = subsref (fval, idx); widths = max (wid (fval), [], data_dim); is_small = widths < options.TolFun; else s = size (queue); s(data_dim) = 1; is_small = false (s); endif [widths, bisect_coord] = max (wid (queue), [], data_dim); is_small = is_small | (widths < options.TolX); idx.subs{cat_dim} = is_small; queue_is_small = subsref (queue, idx); x = union (cat (cat_dim, x, queue_is_small), [], cat_dim); x_paving = cat (cat_dim, x_paving, queue_is_small); x_inner_idx = cat (cat_dim, x_inner_idx, not (is_small(is_small))); idx.subs{cat_dim} = not (is_small); queue = subsref (queue, idx); widths = widths(not (is_small)); bisect_coord = bisect_coord(not (is_small)); ## Bisect remaining intervals at the largest coordinate. x1 = x2 = queue; if (x_scalar) coord = queue; else coord_idx.type = "()"; if (data_dim == 1) coord_idx.subs = {bisect_coord - 1 + ... (1 : rows (queue.inf) : numel (queue.inf))}; else coord_idx.subs = {bisect_coord - 1 + ... (1 : columns (queue.inf) : numel (queue.inf)).'}; endif coord = subsref (queue, coord_idx); endif m_coord = mid (coord); if (x_scalar) x1.sup = x2.inf = m_coord; else x1.sup = subsasgn (x1.sup, coord_idx, m_coord); x2.inf = subsasgn (x2.inf, coord_idx, m_coord); endif queue = cat (cat_dim, x1, x2); if (isempty (queue.inf)) break endif ## Short-circuit if no paving must be computed and remaining intervals ## are subsets of the already computed interval enclosure. if (nargout < 2) idx.subs{cat_dim} = not (all (subset (queue, x), data_dim)); queue = subsref (queue, idx); endif endwhile if (nargout >= 2 && data_dim != 1) x_paving = transpose (x_paving); endif endfunction %!test %! sqr = @(x) x .^ 2; %! assert (subset (sqrt (infsup (2)), fsolve (sqr, infsup (0, 3), 2))); %!test %! sqr = @(x) x .^ 2; %! assert (subset (sqrt (infsup (2)), fsolve (sqr, infsup (0, 3), 2, struct ("Vectorize", false)))); %!function [fval, x] = contractor (y, x) %! fval = x .^ 2; %! y = intersect (y, fval); %! x = sqrrev (y, x); %!endfunction %!assert (subset (sqrt (infsup (2)), fsolve (@contractor, infsup (0, 3), 2, struct ("Contract", true)))); %!assert (subset (sqrt (infsup (2)), fsolve (@contractor, infsup (0, 3), 2, struct ("Contract", true, "Vectorize", false)))); %!demo %! clf %! hold on %! grid on %! axis equal %! shade = [238 232 213] / 255; %! blue = [38 139 210] / 255; %! cyan = [42 161 152] / 255; %! red = [220 50 47] / 255; %! # 2D ring %! f = @(x, y) hypot (x, y); %! [outer, paving, inner] = fsolve (f, infsup ([-3; -3], [3; 3]), ... %! infsup (0.5, 2), ... %! optimset ('TolX', 0.1)); %! # Plot the outer interval enclosure %! plot (outer(1), outer(2), shade) %! # Plot the guaranteed inner interval enclosures of the preimage %! plot (paving(1, inner), paving(2, inner), blue, cyan); %! # Plot the boundary of the preimage %! plot (paving(1, not (inner)), paving(2, not (inner)), red); %!demo %! clf %! hold on %! grid on %! shade = [238 232 213] / 255; %! blue = [38 139 210] / 255; %! # This 3D ring is difficult to approximate with interval boxes %! f = @(x, y, z) hypot (hypot (x, y) - 2, z); %! [~, paving, inner] = fsolve (f, infsup ([-4; -4; -2], [4; 4; 2]), ... %! infsup (0, 0.5), ... %! optimset ('TolX', 0.2)); %! plot3 (paving(1, not (inner)), ... %! paving(2, not (inner)), ... %! paving(3, not (inner)), shade, blue); %! view (50, 60) interval-1.4.1/inst/@infsup/fzero.m0000644000000000000000000001661012657475772015405 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {@var{X} =} fzero (@var{F}, @var{X0}) ## @deftypemethodx {@@infsup} {@var{X} =} fzero (@var{F}, @var{X0}, @var{DF}) ## @deftypemethodx {@@infsup} {@var{X} =} fzero (@var{F}, @var{X0}, @var{OPTIONS}) ## @deftypemethodx {@@infsup} {@var{X} =} fzero (@var{F}, @var{X0}, @var{DF}, @var{OPTIONS}) ## ## Compute the enclosure of all roots of function @var{F} in interval @var{X0}. ## ## Parameters @var{F} and (possibly) @var{DF} may either be a function handle, ## inline function, or string containing the name of the function to evaluate. ## ## The function must be an interval arithmetic function. ## ## Optional parameters are the function's derivative @var{DF} and the maximum ## recursion steps @var{OPTIONS}.MaxIter (default: 200) to use. If @var{DF} is ## given, the algorithm tries to apply the interval newton method for finding ## the roots; otherwise pure bisection is used (which is slower). ## ## The result is a column vector with one element for each root enclosure that ## has been be found. Each root enclosure may contain more than one root and ## each root enclosure must not contain any root. However, all numbers in ## @var{X0} that are not covered by the result are guaranteed to be no roots of ## the function. ## ## Best results can be achieved when (a) the function @var{F} does not suffer ## from the dependency problem of interval arithmetic, (b) the derivative ## @var{DF} is given, (c) the derivative is non-zero at the function's roots, ## and (d) the derivative is continuous. ## ## It is possible to use the following optimization @var{options}: ## @option{Display}, @option{MaxFunEvals}, @option{MaxIter}, ## @option{OutputFcn}, @option{TolFun}, @option{TolX}. ## ## Accuracy: The result is a valid enclosure. ## ## @example ## @group ## f = @@(x) cos (x); ## df = @@(x) -sin (x); ## fzero (f, infsup ("[-10, 10]"), df) ## @result{} ans ⊂ 6×1 interval vector ## ## [-7.854, -7.8539] ## [-4.7124, -4.7123] ## [-1.5708, -1.5707] ## [1.5707, 1.5708] ## [4.7123, 4.7124] ## [7.8539, 7.854] ## sqr = @@(x) x .^ 2; ## fzero (sqr, infsup ("[Entire]")) ## @result{} ans ⊂ [-3.2968e-161, +3.2968e-161] ## @end group ## @end example ## ## @seealso{@@infsup/fsolve, optimset} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-01 function result = fzero (f, x0, df, options) if (nargin > 4 || nargin < 2) print_usage (); return endif ## Set default parameters defaultoptions = optimset (optimset, 'MaxIter', 200); if (nargin == 2) df = []; options = defaultoptions; elseif (nargin == 3) if (isstruct (df)) options = optimset (defaultoptions, options); df = []; else options = defaultoptions; endif else options = optimset (defaultoptions, options); endif ## Check parameters if (not (isa (x0, "infsup"))) error ("interval:InvalidOperand", "fzero: Parameter X0 is no interval") elseif (not (isscalar (x0))) error ("interval:InvalidOperand", ... "fzero: Parameter X0 must be a scalar / F must be univariate") elseif (isempty (x0)) error ("interval:InvalidOperand", ... "fzero: Initial interval is empty, nothing to do") elseif (not (is_function_handle (f)) && not (ischar (f))) error ("interval:InvalidOperand", ... "fzero: Parameter F is no function handle") elseif (not (isempty (df)) && ... not (is_function_handle (df)) && ... not (ischar (df))) error ("interval:InvalidOperand", ... "fzero: Parameter DF is not function handle") endif ## Does not work on decorated intervals, strip decoration part if (isa (x0, "infsupdec")) if (isnai (x0)) result = x0; return endif x0 = intervalpart (x0); endif [l, u] = findroots (f, df, x0, 0, options); result = infsup (l, u); endfunction ## This function will perform the recursive newton / bisection steps function [l, u] = findroots (f, df, x0, stepcount, options) l = u = zeros (0, 1); ## Try the newton step, if derivative is known if (not (isempty (df))) m = infsup (mid (x0)); [a, b] = mulrev (feval (df, x0), feval (f, m)); if (isempty (a) && isempty (b)) ## Function evaluated outside of its domain a = x0; else a = intersect (x0, m - a); b = intersect (x0, m - b); if (isempty (a)) [a, b] = deal (b, a); endif endif else a = x0; b = infsup (); endif ## Switch to bisection if the newton step did not produce two intervals if ((eq (x0, a) || isempty (b)) && not (issingleton (a)) && not (isempty (a))) ## When the interval is very large, bisection at the midpoint would ## take “forever” to converge, because floating point numbers are not ## distributed evenly on the real number lane. ## ## We enumerate all floating point numbers within a with ## 1, 2, ... 2n and split the interval at n. ## ## When the interval is small, this algorithm will choose ## approximately mid (a). [a, b] = bisect (a); elseif (b < a) ## Sort the roots in ascending order [a, b] = deal (b, a); endif for x1 = {a, b} x1 = x1 {1}; if (strcmp (options.Display, "iter")) display (x1); endif f_x1 = feval (f, x1); if (not (ismember (0, f_x1))) ## The interval evaluation of f over x1 proves that there are no roots ## or x1 is empty continue endif if (isentire (f_x1) || ... wid (f_x1) / max (realmin (), wid (x1)) < pow2 (-20)) ## Slow convergence detected, cancel iteration soon options.MaxIter = options.MaxIter / 1.5; endif if (eq (x1, x0) || stepcount >= options.MaxIter || wid (x1) <= options.TolX || wid (f_x1) <= options.TolFun) ## Stop recursion if result is accurate enough or if no improvement [newl, newu] = deal (x1.inf, x1.sup); else [newl, newu] = findroots (f, df, x1, stepcount + 1, options); endif if (not (isempty (newl))) if (isempty (l)) l = newl; u = newu; elseif (u (end) == newl (1)) ## Merge intersecting intervals u (end) = newu (1); l = [l; newl(2 : end, 1)]; u = [u; newu(2 : end, 1)]; else l = [l; newl]; u = [u; newu]; endif endif endfor endfunction %!test "from the documentation string"; %! f = @(x) cos (x); %! df = @(x) -sin (x); %! zeros = fzero (f, infsup ("[-10, 10]"), df); %! assert (all (subset (pi * (-2.5:1:2.5)', zeros))); %! assert (max (rad (zeros)) < 8 * eps); %! sqr = @(x) x .^ 2; %! zeros = fzero (sqr, infsup ("[Entire]")); %! assert (all (subset (0, zeros))); %! assert (max (rad (zeros)) < eps); interval-1.4.1/inst/@infsup/gamma.m0000644000000000000000000001547512657475772015352 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} gamma (@var{X}) ## ## Compute the gamma function. ## ## @tex ## $$ ## {\rm gamma} (x) = \int_0^\infty t^(x-1) \exp (-t) dt ## $$ ## @end tex ## @ifnottex ## @group ## @verbatim ## ∞ ## / ## gamma (x) = | t^(x - 1) * exp (-t) dt ## / ## 0 ## @end verbatim ## @end group ## @end ifnottex ## ## Accuracy: The result is a valid enclosure. The result is tightest for ## @var{X} >= -10. ## ## @example ## @group ## gamma (infsup (1.5)) ## @result{} ans ⊂ [0.88622, 0.88623] ## @end group ## @end example ## @seealso{@@infsup/psi, @@infsup/gammaln, @@infsup/factorial} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-03-01 function result = gamma (x) if (nargin ~= 1) print_usage (); return endif u = inf (size (x.inf)); l = -u; ## Positive x ================================================================= ## https://oeis.org/A030169 persistent x_min_inf = 1.4616321449683623; persistent x_min_sup = 1.4616321449683624; ## Both gamma (infsup (x_min_inf)) and gamma (infsup (x_min_sup)) contain ## the exact minimum value of gamma. Thus we can simply split the function's ## domain in half and assume that each is strictly monotonic. l = inf (size (x.inf)); u = -l; ## Monotonically decreasing for x1 x1 = intersect (x, infsup (0, x_min_sup)); select = not (isempty (x1)) & x1.sup > 0; if (any (any (select))) x1.inf (x1.inf == 0) = 0; # fix negative zero l (select) = mpfr_function_d ('gamma', -inf, x1.sup (select)); u (select) = mpfr_function_d ('gamma', +inf, x1.inf (select)); endif ## Monotonically increasing for x2 x2 = intersect (x, infsup (x_min_inf, inf)); select = not (isempty (x2)); if (any (any (select))) l (select) = mpfr_function_d ('gamma', -inf, x2.inf (select)); u (select) = max (u (select), ... mpfr_function_d ('gamma', +inf, x2.sup (select))); endif pos = infsup (l, u); ## Negative x ================================================================= x = intersect (x, infsup (-inf, 0)); u = inf (size (x.inf)); l = -u; nosingularity = floor (x.inf) + 1 == ceil (x.sup); if (any (any (nosingularity))) negative_value = nosingularity & mod (ceil (x.sup), 2) == 0; positive_value = nosingularity & not (negative_value); x.sup (x.sup == 0) = -0; # fix negative zero psil = psiu = zeros (size (x.inf)); psil (nosingularity) = mpfr_function_d ('psi', 0, x.inf (nosingularity)); psil (isnan (psil)) = -inf; psiu (nosingularity) = mpfr_function_d ('psi', 0, x.sup (nosingularity)); psiu (isnan (psiu)) = inf; encloses_extremum = false (size (x.inf)); encloses_extremum (nosingularity) = ... psil (nosingularity) <= 0 & psiu (nosingularity) >= 0; encloses_extremum (x.sup == x.inf + 1) = true (); select = encloses_extremum & negative_value & ... fix (x.inf) ~= x.inf & fix (x.sup) ~= x.sup; if (any (any (select))) l (select) = min (mpfr_function_d ('gamma', -inf, x.inf (select)), ... mpfr_function_d ('gamma', -inf, x.sup (select))); endif select = encloses_extremum & positive_value & ... fix (x.inf) ~= x.inf & fix (x.sup) ~= x.sup; if (any (any (select))) u (select) = max (mpfr_function_d ('gamma', +inf, x.inf (select)), ... mpfr_function_d ('gamma', +inf, x.sup (select))); endif select = not (encloses_extremum) & negative_value; u (select) = -inf; select = not (encloses_extremum) & positive_value; l (select) = inf; select = nosingularity & not (encloses_extremum); if (any (any (select))) l (select) = min (l (select), ... min (mpfr_function_d ('gamma', -inf, x.inf (select)), ... mpfr_function_d ('gamma', -inf, x.sup (select)))); u (select) = max (u (select), ... max (mpfr_function_d ('gamma', +inf, x.inf (select)), ... mpfr_function_d ('gamma', +inf, x.sup (select)))); endif select = encloses_extremum & negative_value; if (any (any (select))) u (select) = find_extremum (x.inf (select), x.sup (select)); endif select = encloses_extremum & positive_value; if (any (any (select))) l (select) = find_extremum (x.inf (select), x.sup (select)); endif endif emptyresult = (x.inf == x.sup & fix (x.inf) == x.inf & x.inf <= 0) | x.inf > 0; l (emptyresult) = inf; u (emptyresult) = -inf; neg = infsup (l, u); ## ============================================================================ result = union (pos, neg); endfunction function y = find_extremum (l, u) ## Compute the extremum's value of gamma between l and u. l and u are negative ## and lie between two subsequent integral numbers. y = zeros (size (l)); # inaccurate, but already correct ## Tightest values for l >= -10 n = floor (l); y (n == -1) = -3.544643611155005; y (n == -2) = 2.3024072583396799; y (n == -3) = -.8881363584012418; y (n == -4) = .24512753983436624; y (n == -5) = -.052779639587319397; y (n == -6) = .009324594482614849; y (n == -7) = -.001397396608949767; y (n == -8) = 1.8187844490940416e-4; y (n == -9) = -2.0925290446526666e-5; y (n == -10) = 2.1574161045228504e-6; ## From Euler's reflection formula it follows: ## gamma (-x) = pi / ( sin (pi * (x + 1)) * gamma (x + 1) ) ## ## The extremum is located at -x = n + epsilon, ## where epsilon < 0.3 for n <= -10. Thus, we can estimate ## abs (pi / sin (pi * (x + 1))) >= 3.88 for n <= -10. ## Also it holds gamma (x + 1) = gamma (-n - epsilon + 1) <= gamma (-n + 1). ## ## Now, altogether we can estimate: abs (gamma (-x)) >= 3.88 / gamma (-n + 1) ## for n <= -10 remaining_estimates = n < -10; if (any (any (remaining_estimates))) y (remaining_estimates) = ... (-1) .^ (rem (n (remaining_estimates), 2) == -1) * ... mpfr_function_d ('rdivide', -inf, 3.88, ... mpfr_function_d ('gamma', +inf, -n (remaining_estimates) + 1)); endif endfunction %!test "from the documentation string"; %! assert (gamma (infsup (1.5)) == "[0x1.C5BF891B4EF6Ap-1, 0x1.C5BF891B4EF6Bp-1]"); interval-1.4.1/inst/@infsup/gammaln.m0000644000000000000000000000574512657475772015703 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} gammaln (@var{X}) ## ## Compute the logarithm of the gamma function for positive arguments. ## ## @tex ## $$ ## {\rm gammaln} (x) = \log \int_0^\infty t^{x-1} \exp (-t) dt ## $$ ## @end tex ## @ifnottex ## @group ## @verbatim ## ∞ ## / ## gammaln (x) = log | t^(x-1) exp (-t) dt ## / ## 0 ## @end verbatim ## @end group ## @end ifnottex ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## gammaln (infsup (1.5)) ## @result{} ans ⊂ [-0.12079, -0.12078] ## @end group ## @end example ## @seealso{@@infsup/psi, @@infsup/gamma, @@infsup/factorial} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-28 function result = gammaln (x) if (nargin ~= 1) print_usage (); return endif ## The gamma function is also defined for negative, non-integral arguments and ## its logarithm would be defined for −2n <= x <= −2n+1. ## However, we only compute the function for x > 0. ## https://oeis.org/A030169 persistent x_min_inf = 1.4616321449683623; persistent x_min_sup = 1.4616321449683624; ## Both gammaln (infsup (x_min_inf)) and gammaln (infsup (x_min_sup)) contain ## the exact minimum value of gammaln. Thus we can simply split the function's ## domain in half and assume that each is strictly monotonic. l = inf (size (x.inf)); u = -l; ## Monotonically decreasing for x1 x1 = intersect (x, infsup (0, x_min_sup)); select = not (isempty (x1)) & x1.sup > 0; if (any (any (select))) x1.inf (x1.inf == 0) = 0; # fix negative zero l (select) = mpfr_function_d ('gammaln', -inf, x1.sup (select)); u (select) = mpfr_function_d ('gammaln', +inf, x1.inf (select)); endif ## Monotonically increasing for x2 x2 = intersect (x, infsup (x_min_inf, inf)); select = not (isempty (x2)); if (any (any (select))) l (select) = mpfr_function_d ('gammaln', -inf, x2.inf (select)); u (select) = max (u (select), ... mpfr_function_d ('gammaln', +inf, x2.sup (select))); endif result = infsup (l, u); endfunction %!assert (gammaln (infsup (-inf, inf)) == "[-0x1.F19B9BCC38A42p-4, +Inf]"); %!test "from the documentation string"; %! assert (gammaln (infsup (1.5)) == "[-0x1.EEB95B094C192p-4, -0x1.EEB95B094C191p-4]"); interval-1.4.1/inst/@infsup/gauss.m0000644000000000000000000001621112657475772015377 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {@var{x} =} gauss (@var{A}, @var{b}) ## ## Solve a linear interval system @var{A} * @var{x} = @var{b} using Gaussian ## elimination. ## ## The found enclosure is improved with the help of the Gauß-Seidel-method. ## ## Note: This algorithm is very inaccurate and slow for matrices of a dimension ## greater than 3. A better solver is provided by @code{mldivide}. The ## inaccuracy mainly comes from the dependency problem of interval arithmetic ## during back-substitution of the solution's enclosure. ## ## Accuracy: The result is a valid enclosure. ## ## @example ## @group ## gauss (infsup ([1, 0; 0, 2]), [2, 0; 0, 4]) ## @result{} ans = 2×2 interval matrix ## [2] [0] ## [0] [2] ## @end group ## @end example ## @seealso{@@infsup/mldivide} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-31 function result = gauss (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsup"))) x = infsup (x); endif if (not (isa (y, "infsup"))) y = infsup (y); endif if (isscalar (x) || isscalar (y)) result = rdivide (y, x); return endif ## x must be square assert (size (x.inf, 1) == size (x.inf, 2), ... "gauss: nonconformant arguments, X is not square"); ## vertical sizes of x and y must equal assert (rows (x.inf) == rows (y.inf), ... "gauss: nonconformant arguments, first dimension mismatch"); n = length (x.inf); m = columns (y.inf); ## We have to compute z = inv (x) * y. ## This can be done by Gaußian elimination by solving the following equation ## for the variable z: x * z = y ## Step 1: Perform LUP decomposition of x into triangular matrices L, U and ## permutation matrix P ## P * x = L * U [L, U, P] = lu (x); ## Step 2: Forward substitution ## Solve L * s = inv (P) * y s = permute (inv (P), y); curelement.type = prevvars.type = Lrowidx.type = "()"; for i = 1 : m ## Special case: k == 1 ## s (k, i) already is correct for k = 2 : n curelement.subs = {k, i}; prevvars.subs = {1 : k, i}; Lrowidx.subs = {k, 1 : k}; varcol = subsref (s, prevvars); Lrow = subsref (L, Lrowidx); ## We have to subtract varcol (1 : (k - 1)) * Lrow (1 : (k - 1)) from ## s (k, i). Since varcol (k) == s (k, i), we can simply set ## Lrow (k) = -1 and the dot product will compute the difference for us ## with high accurracy. Lrow.inf (k) = Lrow.sup (k) = -1; ## Then, we only have to flip the sign afterwards. s = subsasgn (s, curelement, -dot (Lrow, varcol)); endfor endfor ## Step 3: Backward substitution ## Solve U * z = s z = s; Urowstart.type = Urowrest.type = "()"; for i = 1 : m ## Special case: k == n curelement.subs = {n, i}; Urowstart.subs = {n, n}; z = subsasgn (z, curelement, ... mulrev (subsref (U, Urowstart), subsref (z, curelement))); for k = (n - 1) : -1 : 1 curelement.subs = {k, i}; Urowstart.subs = {k, k}; prevvars.subs = {k : n, i}; Urowrest.subs = {k, k : n}; varcol = subsref (z, prevvars); Urow = subsref (U, Urowrest); ## Use the same trick like above during forward substitution. Urow.inf (1) = Urow.sup (1) = -1; ## Additionally we must divide the element by the current diagonal ## element of U. z = subsasgn (z, curelement, ... mulrev (subsref (U, Urowstart), -dot (Urow, varcol))); endfor endfor ## Now we have solved inv (P) * L * U * z = y for z. ## ## The current result for z is only a rough estimation in general, because ## inv (P) * L * U is only an enclosure of the original linear interval ## system x * z = y and the Gaußian elimination above introduces several ## inaccuracies because of aggregated intermediate results and accumulated ## rounding errors. ## ## We can further try to improve the boundaries of the result with the original ## linear system. This is an iterative method using the mulrev operation. It ## is quite accurate in each step, because it only depends on one (tightest) ## dot operation and one (tightest) mulrev operation. However, the convergence ## speed is slow and each cycle is costly, so we have to cancel after one ## iteration. ## ## The method used here is similar to the Gauß-Seidel-method. Instead of ## diagonal elements of the matrix we use an arbitrary element that does not ## contain zero as an inner element. xrowidx.type = yidx.type = zcolidx.type = "()"; migx = mig (x); migx (isnan (migx)) = 0; for k = 1 : m zcolidx.subs = {1 : n, k}; zcol = subsref (z, zcolidx); for j = n : -1 : 1 z_jk = infsup (zcol.inf (j), zcol.sup (j)); if (isempty (z_jk) || issingleton (z_jk)) ## No improvement can be achieved. continue endif i = find (migx (:, j) == max (migx (:, j)), 1); xrowidx.subs = {i, 1 : n}; xrow = subsref (x, xrowidx); if (xrow.inf (j) < 0 && xrow.sup (j) > 0) ## No improvement can be achieved. continue endif x_ij = infsup (xrow.inf (j), xrow.sup (j)); yidx.subs = {i, k}; yelement = subsref (y, yidx); ## x (i, 1 : n) * z (1 : n, k) shall equal y (i, k). ## 1. Solve this equation for x (i, j) * z (j, k). ## 2. Compute a (possibly better) enclosure for z (j, k). xrow.inf (j) = yelement.inf; xrow.sup (j) = yelement.sup; zcol.inf (j) = zcol.sup (j) = -1; z_jk = mulrev (x_ij, -dot (xrow, zcol), z_jk); zcol.inf (j) = z.inf (j, k) = z_jk.inf; zcol.sup (j) = z.sup (j, k) = z_jk.sup; endfor endfor result = z; endfunction ## Apply permutation matrix P to an interval matrix: B = P * A. ## This is much faster than a matrix product, because the matrix product would ## use a lot of dot products. function B = permute (P, A) ## Note: [B.inf, B.sup] = deal (P * A.inf, P * A.sup) is not possible, ## because empty or unbound intervals would create NaNs during ## multiplication with P. B = A; for i = 1 : rows (P) targetrow = find (P (i, :) == 1, 1); B.inf (targetrow, :) = A.inf (i, :); B.sup (targetrow, :) = A.sup (i, :); endfor endfunction %!test "from the documentation string"; %! assert (gauss (infsup ([1, 0; 0, 2]), [2, 0; 0, 4]) == [2, 0; 0, 2]); interval-1.4.1/inst/@infsup/ge.m0000644000000000000000000000240512657475772014650 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} ge (@var{A}, @var{B}) ## @defopx Operator {@@infsup} {@var{A} >= @var{B}} ## ## Compare intervals @var{A} and @var{B} for weakly greater. ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## @seealso{@@infsup/eq, @@infsup/le, @@infsup/gt} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-07 function result = ge (a, b) if (nargin ~= 2) print_usage (); return endif result = le (b, a); endfunction %!assert (ge (infsup (2, 3), infsup (1, 3))); interval-1.4.1/inst/@infsup/gt.m0000644000000000000000000000247212657475772014673 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} gt (@var{A}, @var{B}) ## @defopx Operator {@@infsup} {@var{A} > @var{B}} ## ## Compare intervals @var{A} and @var{B} for strict greater. ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## @seealso{@@infsup/eq, @@infsup/lt, @@infsup/ge} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-07 function result = gt (a, b) if (nargin ~= 2) print_usage (); return endif result = lt (b, a); endfunction %!assert (not (gt (infsup (2, 3), infsup (1, 3)))); %!assert (gt (infsup (2, 3.1), infsup (1, 3))); interval-1.4.1/inst/@infsup/hdist.m0000644000000000000000000000524312657475772015373 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} hdist (@var{X}, @var{Y}) ## ## Compute the Hausdorff distance between two intervals as sets. ## ## The Hausdorff distance for closed real intervals is the maximum distance ## between both pairs of interval boundaries. ## ## If any interval is empty, the result is NaN. For interval matrices the ## result is computed entry-wise. ## ## Accuracy: The result is correctly-rounded (towards infinity). ## ## @example ## @group ## hdist (infsup (1, 6), infsup (2, 8)) ## @result{} ans = 2 ## @end group ## @end example ## @seealso{@@infsup/sdist, @@infsup/idist} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-06-11 function result = hdist (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsup"))) x = infsup (x); endif if (not (isa (y, "infsup"))) y = infsup (y); endif ## Resize, if scalar × matrix if (isscalar (x.inf) ~= isscalar (y.inf)) x.inf = ones (size (y.inf)) .* x.inf; x.sup = ones (size (y.inf)) .* x.sup; y.inf = ones (size (x.inf)) .* y.inf; y.sup = ones (size (x.inf)) .* y.sup; endif result = zeros (size (x.inf)); select = x.inf < y.inf; if (any (any (select))) result (select) = ... mpfr_function_d ('minus', +inf, y.inf (select), x.inf (select)); endif select = x.inf > y.inf; if (any (any (select))) result (select) = max (result (select), ... mpfr_function_d ('minus', +inf, x.inf (select), y.inf (select))); endif select = x.sup < y.sup; if (any (any (select))) result (select) = max (result (select), ... mpfr_function_d ('minus', +inf, y.sup (select), x.sup (select))); endif select = x.sup > y.sup; if (any (any (select))) result (select) = max (result (select), ... mpfr_function_d ('minus', +inf, x.sup (select), y.sup (select))); endif result (isempty (x) | isempty (y)) = nan (); endfunction %!test "from the documentation string"; %! assert (hdist (infsup (1, 6), infsup (2, 8)), 2); interval-1.4.1/inst/@infsup/horzcat.m0000644000000000000000000000357312657475772015736 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} horzcat (@var{ARRAY1}, @var{ARRAY2}, @dots{}) ## @defopx Operator {@@infsup} {[@var{ARRAY1}, @var{ARRAY2}, @dots{}]} ## ## Return the horizontal concatenation of interval array objects along ## dimension 2. ## ## @example ## @group ## a = infsup (2, 5); ## [a, a, a] ## @result{} ans = 1×3 interval vector ## [2, 5] [2, 5] [2, 5] ## @end group ## @end example ## @seealso{@@infsup/vertcat} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-29 function result = horzcat (varargin) ## Conversion to interval intervals = cellfun ("isclass", varargin, "infsup"); to_convert = not (intervals); varargin (to_convert) = cellfun (@infsup, varargin (to_convert), ... "UniformOutput", false ()); l = cell2mat (cellfun (@(x) x.inf, varargin, "UniformOutput", false ())); u = cell2mat (cellfun (@(x) x.sup, varargin, "UniformOutput", false ())); result = infsup (l, u); endfunction %!assert (horzcat (infsup (1), infsup (2)) == infsup (horzcat (1, 2))); %!test "from the documentation string"; %! a = infsup (2, 5); %! assert (horzcat (a, a, a) == infsup ([2, 2, 2], [5, 5, 5])); interval-1.4.1/inst/@infsup/hypot.m0000644000000000000000000000333412657475772015422 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} hypot (@var{X}, @var{Y}) ## ## Compute the euclidean norm. ## ## @code{hypot (@var{x}, @var{y}) = sqrt (@var{x}^2 + @var{y}^2)} ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## x = infsup (2, 3); ## y = infsup (1, 2); ## hypot (x, y) ## @result{} ans ⊂ [2.236, 3.6056] ## @end group ## @end example ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-20 function result = hypot (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsup"))) x = infsup (x); endif if (not (isa (y, "infsup"))) y = infsup (y); endif l = mpfr_function_d ('hypot', -inf, mig (x), mig (y)); u = mpfr_function_d ('hypot', +inf, mag (x), mag (y)); emptyresult = isempty (x) | isempty (y); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (hypot (infsup (2, 3), infsup (1, 2)) == "[0x1.1E3779B97F4A7p1, 0x1.CD82B446159F4p1]"); interval-1.4.1/inst/@infsup/idist.m0000644000000000000000000000476012657475772015377 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} idist (@var{X}, @var{Y}) ## ## Compute the inner distance between two intervals as sets. ## ## The inner distance for closed real intervals is the minimum distance ## between each pair of numbers. That is, the inner distance equals zero if ## a number can be found in both intervals. Otherwise the inner distance is ## the size of the gap between both intervals on the real number lane. ## ## If any interval is empty, the result is NaN. For interval matrices the ## result is computed entry-wise. ## ## Accuracy: The result is correctly-rounded (towards infinity). ## ## @example ## @group ## idist (infsup (0, 6), infsup (7, 20)) ## @result{} ans = 1 ## @end group ## @end example ## @seealso{@@infsup/sdist, @@infsup/hdist} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-06-11 function result = idist (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsup"))) x = infsup (x); endif if (not (isa (y, "infsup"))) y = infsup (y); endif ## Resize, if scalar × matrix if (isscalar (x.inf) ~= isscalar (y.inf)) x.inf = ones (size (y.inf)) .* x.inf; x.sup = ones (size (y.inf)) .* x.sup; y.inf = ones (size (x.inf)) .* y.inf; y.sup = ones (size (x.inf)) .* y.sup; endif result = zeros (size (x.inf)); select = x.sup < y.inf; if (any (any (select))) result (select) = ... mpfr_function_d ('minus', +inf, y.inf (select), x.sup (select)); endif select = x.inf > y.sup; if (any (any (select))) result (select) = max (result (select), ... mpfr_function_d ('minus', +inf, x.inf (select), y.sup (select))); endif result (isempty (x) | isempty (y)) = nan (); endfunction %!test "from the documentation string"; %! assert (idist (infsup (0, 6), infsup (7, 20)), 1); interval-1.4.1/inst/@infsup/inf.m0000644000000000000000000000311512657475772015030 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} inf (@var{X}) ## ## Get the (greatest) lower boundary for all numbers of interval @var{X}. ## ## If @var{X} is empty, @code{inf (@var{X})} is positive infinity. ## ## Accuracy: The result is exact. ## ## @example ## @group ## inf (infsup (2.5, 3.5)) ## @result{} ans = 2.5000 ## @end group ## @end example ## @seealso{@@infsup/sup, @@infsup/mid} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-27 function result = inf (x) if (nargin ~= 1) print_usage (); return endif if (isa (x, "infsupdec")) ## We cannot override this function in infsupdec, because that would create ## an infinite loop. if (isnai (x)) error ("interval:NaI", "NaI has no infimum") endif endif result = x.inf; endfunction %!test "from the documentation string"; %! assert (inf (infsup (2.5, 3.5)), 2.5); interval-1.4.1/inst/@infsup/infsup.m0000644000000000000000000006450412657475772015571 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypeop Constructor {@@infsup} {[@var{X}, @var{ISEXACT}] =} infsup () ## @deftypeopx Constructor {@@infsup} {[@var{X}, @var{ISEXACT}] =} infsup (@var{M}) ## @deftypeopx Constructor {@@infsup} {[@var{X}, @var{ISEXACT}] =} infsup (@var{S}) ## @deftypeopx Constructor {@@infsup} {[@var{X}, @var{ISEXACT}] =} infsup (@var{L}, @var{U}) ## ## Create an interval (from boundaries). Convert boundaries to double ## precision. ## ## The syntax without parameters creates an (exact) empty interval. The syntax ## with a single parameter @code{infsup (@var{M})} equals ## @code{infsup (@var{M}, @var{M})}. The syntax @code{infsup (@var{S})} parses ## an interval literal in inf-sup form or as a special value, where ## @code{infsup ("[S1, S2]")} is equivalent to @code{infsup ("S1", "S2")}. A ## second, logical output @var{ISEXACT} indicates if @var{X}'s boundaries both ## have been converted without precision loss. ## ## Each boundary can be provided in the following formats: literal constants ## [+-]inf[inity], e, pi; scalar real numeric data types, i. e., double, ## single, [u]int[8,16,32,64]; or decimal numbers as strings of the form ## [+-]d[,.]d[[eE][+-]d]; or hexadecimal numbers as string of the form ## [+-]0xh[,.]h[[pP][+-]d]; or decimal numbers in rational form ## [+-]d/d. ## ## Also it is possible, to construct intervals from the uncertain form in the ## form @code{m?ruE}, where @code{m} is a decimal mantissa, ## @code{r} is empty (= half ULP) or a decimal integer ULP count or a ## second @code{?} character for unbounded intervals, @code{u} is ## empty or a direction character (u: up, d: down), and @code{E} is an ## exponential field. ## ## If decimal or hexadecimal numbers are no binary64 floating point numbers, a ## tight enclosure will be computed. int64 and uint64 numbers of high ## magnitude (> 2^53) can also be affected from precision loss. ## ## For the creation of interval matrices, arguments may be provided as (1) cell ## arrays with arbitrary/mixed types, (2) numeric matrices, or (3) strings. ## Scalar values do broadcast. ## ## Non-standard behavior: This class constructor is not described by IEEE Std ## 1788-2015, IEEE standard for interval arithmetic, however it implements both ## standard functions numsToInterval and textToInterval. ## ## @example ## @group ## infsup () ## @result{} ans = [Empty] ## infsup ("[1]") ## @result{} ans = [1] ## infsup (2, 3) ## @result{} ans = [2, 3] ## infsup ("0.1") ## @result{} ans ⊂ [0.099999, 0.10001] ## infsup ("0.1", "0.2") ## @result{} ans ⊂ [0.099999, 0.20001] ## infsup ("0xff", "0x1.ffp14") ## @result{} ans = [255, 32704] ## infsup ("1/3") ## @result{} ans ⊂ [0.33333, 0.33334] ## infsup ("[1/9, 47/11]") ## @result{} ans ⊂ [0.11111, 4.2728] ## infsup ("7.3?9u") ## @result{} ans ⊂ [7.2999, 8.2001] ## infsup ("0??") ## @result{} ans = [Entire] ## infsup ("911??de-2") ## @result{} ans ⊂ [-Inf, +9.1101] ## infsup ("10?") ## @result{} ans = [9.5, 10.5] ## @end group ## @end example ## @seealso{exacttointerval} ## @end deftypeop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-27 function [x, isexact, overflow] = infsup (l, u) if (nargin == 0) ## representation of the empty interval is always [inf,-inf] l = inf; u = -inf; endif if (nargin == 1) if (isa (l, "infsup")) ## Nothing to be done x = l; isexact = true (); return endif if (ischar (l)) l = __split_interval_literals__ (l); endif if (iscell (l)) ## Parse interval literals c = lower (l); u = cell (size (c)); for i = 1 : numel (l) if (ischar (l {i}) && not (isempty (c {i})) && ... c {i} ([1, end]) == "[]") ## Strip square brackets and whitespace nobrackets = strtrim (c {i} (2 : (end-1))); switch nobrackets case "entire" l {i} = -inf; u {i} = inf; case {"empty", ""} l {i} = inf; u {i} = -inf; case "nai" error ("interval:NaI", ... "Interval literal [NaI] occured") otherwise boundaries = strtrim (strsplit (nobrackets, ",")); switch (numel (boundaries)) case 1 l {i} = u {i} = boundaries {1}; case 2 l {i} = boundaries {1}; u {i} = boundaries {2}; otherwise error ("interval:InvalidOperand", ... "interval literal is not in inf-sup form") endswitch endswitch elseif (ischar (l {i}) && strfind (c {i}, "?")) ## Uncertain form: At this point we only split lower and upper ## boundary and remove the ??. ULP arithmetic is performed ## below when parsing the decimal number. if (strfind (c {i}, "u")) # up ## The uncertainty only affects the upper boundary l {i} = strcat (... c {i} (1 : (find (c {i} == "?", 1) - 1)), ... c {i} ((find (c {i} == "u", 1) + 1) : end)); u {i} = strrep (c {i} (1 : end), "u", ""); elseif (strfind (c {i}, "d")) # down ## The uncertainty only affects the lower boundary l {i} = strrep (c {i} (1 : end), "d", ""); u {i} = strcat (... c {i} (1 : (find (c {i} == "?", 1) - 1)), ... c {i} ((find (c {i} == "d", 1) + 1) : end)); else ## The uncertainty affects both boundaries l {i} = u {i} = c {i}; endif if (strfind (l {i}, "??")) l {i} = -inf; endif if (strfind (u {i}, "??")) u {i} = inf; endif else ## syntax infsup (x) has to be equivalent with infsup (x, x) u {i} = l {i}; endif endfor else # not cell or char ## syntax infsup (x) has to be equivalent with infsup (x, x) u = l; endif endif if (ischar (l)) l = __split_interval_literals__ (lower (l)); endif if (ischar (u)) u = __split_interval_literals__ (lower (u)); endif if (not (size_equal (l, u))) if (isscalar (l)) ## Broadcast l l = l (ones (size (u))); elseif (isscalar (u)) ## Broadcast u u = u (ones (size (l))); else error ("interval:InvalidOperand", ... "infsup: size of upper and lower bounds must match") endif endif ## check parameters and conversion to double precision isexact = true (); possiblyundefined = false (size (l)); overflow = true (size (l)); x.inf = zeros (size (l)); x.sup = zeros (size (u)); input.inf = l; input.sup = u; for [boundaries, key] = input if (isfloat (boundaries)) ## Simple case: the boundaries already are a binary floating point ## number in single or double precision. x.(key) = double (boundaries); possiblyundefined (:) = false (); continue endif for i = 1 : numel (boundaries) if (iscell (boundaries)) boundary = boundaries {i}; if (ischar (boundary)) boundary = lower (boundary); endif else boundary = boundaries (i); endif if (isempty (boundary)) switch key case "inf" x.inf (i) = -inf; case "sup" x.sup (i) = inf; possiblyundefined (i) = false (); endswitch elseif (isnumeric (boundary)) if (not (isreal (boundary))) error ("interval:InvalidOperand", ... ["illegal " key " boundary: must not be complex"]); endif if (isfloat (boundary)) ## Simple case: the boundary already is a binary floating point ## number in single or double precision. x.(key) (i) = double (boundary); possiblyundefined (i) = false (); continue endif ## Integer or logical, try to approximate in double precision x.(key) (i) = double (boundary); isdouble = x.(key) (i) == boundary; if (not (isdouble)) isexact = false; if (key == "inf") possiblyundefined (i) = true (); endif else possiblyundefined (i) = false (); end ## Check rounding direction of the approximation ## Mixed mode comparison works as intended if (isdouble || ... # exact conversion (x.(key) (i) < boundary && key == "inf") || ... # lower bound (x.(key) (i) > boundary && key == "sup")) # upper bound ## Conversion to double has used desired rounding direction else ## Approximation is not exact and not rounded as needed. ## However, because of faithful rounding the approximation ## is right next to the desired number. switch key case "inf" x.inf (i) = mpfr_function_d ('minus', +inf, ... x.inf (i), pow2 (-1074)); case "sup" x.sup (i) = mpfr_function_d ('plus', -inf, ... x.sup (i), pow2 (-1074)); endswitch endif elseif (not (ischar (boundary))) error ("interval:InvalidOperand", ... ["illegal " key " boundary: must be numeric or string"]); elseif (strfind (boundary, "0x")) ## Hexadecimal floating point number switch key case "inf" direction = -inf; case "sup" direction = inf; endswitch [x.(key)(i), isdouble] = hex2double (boundary, direction); if (not (isdouble)) isexact = false; if (key == "inf") possiblyundefined (i) = true (); endif else possiblyundefined (i) = false (); end else ## parse string if (key == "sup" && possiblyundefined (i) && iscell (l)) inf_boundary = l {i}; ## infsup ("x", "x") or infsup ("x") is not possibly undefined if (strcmp (boundary, inf_boundary)) possiblyundefined (i) = false; endif endif switch (boundary) case {"-inf", "-infinity"} x.(key) (i) = -inf; possiblyundefined (i) = false (); overflow (i) = false; case {"inf", "+inf", "infinity", "+infinity"} x.(key) (i) = inf; possiblyundefined (i) = false (); overflow (i) = false; case "e" isexact = false (); switch key case "inf" x.inf (i) = 0x56FC2A2 * pow2 (-25) ... + 0x628AED2 * pow2 (-52); possiblyundefined (i) = true (); case "sup" x.sup (i) = 0x56FC2A2 * pow2 (-25) ... + 0x628AED4 * pow2 (-52); endswitch case "pi" isexact = false (); switch key case "inf" x.inf (i) = 0x6487ED5 * pow2 (-25) ... + 0x442D180 * pow2 (-55); possiblyundefined (i) = true (); case "sup" x.sup (i) = 0x6487ED5 * pow2 (-25) ... + 0x442D190 * pow2 (-55); endswitch otherwise ## We have to parse a decimal string boundary and round the ## result up or down depending on the boundary ## (inf = down, sup = up). ## str2double will produce the correct answer in 50 % of ## all cases, because it uses rounding mode “to nearest”. ## The input and a double format approximation can be ## compared in a decimal floating point format without ## precision loss. if (strfind (boundary, "?")) ## Special case: uncertain-form [boundary, uncertain] = uncertainsplit (boundary); else uncertain = []; endif if (strfind (boundary, "/")) ## Special case: rational form boundary = strsplit (boundary, "/"); if (length (boundary) ~= 2) error ("interval:InvalidOperand", ... ["illegal " key " boundary: ", ... "rational form must have single slash"]); endif [decimal, remainder] = decimaldivide (... str2decimal (boundary {1}), ... str2decimal (boundary {2}), 18); if (not (isempty (remainder.m))) ## This will guarantee the enclosure of the exact ## value decimal.m (19, 1) = 1; isexact = false (); if (key == "inf") possiblyundefined (i) = true (); endif endif ## Write result back into boundary for conversion to ## double boundary = ["0.", num2str(decimal.m)', ... "e", num2str(decimal.e)]; if (decimal.s) boundary = ["-", boundary]; endif else decimal = str2decimal (boundary); endif ## Parse and add uncertainty if (not (isempty (uncertain))) uncertain = str2decimal (uncertain); if ((key == "inf") == decimal.s) uncertain.s = decimal.s; else uncertain.s = not (decimal.s); endif decimal = decimaladd (decimal, uncertain); ## Write result back into boundary for conversion to ## double boundary = ["0.", num2str(decimal.m)', ... "e", num2str(decimal.e)]; if (decimal.s) boundary = ["-", boundary]; endif endif clear uncertain; ## Check if number is outside of range ## Realmax == 1.7...e308 == 0.17...e309 if (decimal.e > 309 || ... (decimal.e == 309 && ... decimal.s && ... decimalcompare (double2decimal (-realmax ()), ... decimal) > 0) || ... (decimal.e == 309 && ... not (decimal.s) && ... decimalcompare (double2decimal (realmax ()), ... decimal) < 0)) switch key case "inf" if (decimal.s) # -inf ... -realmax x.inf (i) = -inf; else # realmax ... inf x.inf (i) = realmax (); endif possiblyundefined (i) = true (); case "sup" if (decimal.s) # -inf ... -realmax x.sup (i) = -realmax (); else # realmax ... inf x.sup (i) = inf; endif endswitch isexact = false (); continue endif ## Compute approximation, this only works between ± realmax binary = str2double (strrep (boundary, ",", ".")); ## Check approximation value comparison = decimalcompare (double2decimal (binary), ... decimal); if (comparison ~= 0) isexact = false (); if (key == "inf") possiblyundefined (i) = true (); endif else possiblyundefined (i) = false (); endif if (comparison == 0 || ... # approximation is exact (comparison < 0 && key == "inf") || ... # lower bound (comparison > 0 && key == "sup")) # upper bound x.(key) (i) = binary; else ## Approximation is not exact and not rounded as needed ## However, because of faithful rounding the ## approximation is right next to the desired number. switch key case "inf" x.inf (i) = mpfr_function_d ('minus', -inf, ... binary, pow2 (-1074)); case "sup" x.sup (i) = mpfr_function_d ('plus', +inf, ... binary, pow2 (-1074)); endswitch endif endswitch endif endfor endfor ## NaNs produce empty intervals nanvalue = isnan (x.inf) | isnan (x.sup); x.inf (nanvalue) = inf; x.sup (nanvalue) = -inf; possiblyundefined (nanvalue) = false; ## normalize boundaries: ## representation of the set containing only zero is always [-0,+0] x.inf (x.inf == 0) = -0; x.sup (x.sup == 0) = +0; ## check for illegal boundaries [inf,inf] and [-inf,-inf] if (any (any (not (isfinite (x.inf (x.inf == x.sup))), 1))) error ("interval:InvalidOperand", ... "illegal interval boundaries: infimum = supremum = +/- infinity"); endif if (nargout >= 3) overflow (x.inf > -inf & x.sup < inf) = false; endif ## check boundary order if (any (any (isfinite (x.inf (x.inf > x.sup)))) || ... any (any (isfinite (x.sup (x.inf > x.sup))))) error ("interval:InvalidOperand", ... "illegal interval boundaries: infimum greater than supremum"); endif ## check for possibly wrong boundary order if (any (any (possiblyundefined)) && any (any (max (-realmax, ... mpfr_function_d ('plus',... +inf, ... x.inf (possiblyundefined), ... pow2 (-1074))) == x.sup (possiblyundefined)))) warning ("interval:PossiblyUndefined", ... "infimum may be greater than supremum"); endif x = class (x, "infsup"); endfunction %!test "double boundaries"; %! assert (inf (infsup (0)), 0); %! assert (sup (infsup (0)), 0); %! assert (inf (infsup (2, 3)), 2); %! assert (sup (infsup (2, 3)), 3); %! assert (inf (infsup (nan)), +inf); %! assert (sup (infsup (nan)), -inf); %! assert (inf (infsup (nan, 2)), +inf); %! assert (sup (infsup (nan, 2)), -inf); %! assert (inf (infsup (3, nan)), +inf); %! assert (sup (infsup (3, nan)), -inf); %!test "double matrix"; %! assert (inf (infsup (magic (4))), magic (4)); %! assert (sup (infsup (magic (4))), magic (4)); %! assert (inf (infsup (magic (3), magic (3) + 1)), magic (3)); %! assert (sup (infsup (magic (3), magic (3) + 1)), magic (3) + 1); %! assert (inf (infsup (nan (3))), +inf (3)); %! assert (sup (infsup (nan (3))), -inf (3)); %!test "decimal boundaries"; %! assert (inf (infsup ("0.1")), 0.1 - eps / 16); %! assert (sup (infsup ("0.1")), 0.1); %! assert (inf (infsup ("0.1e1")), 1); %! assert (sup (infsup ("0.1e1")), 1); %!test "hexadecimal boundaries"; %! assert (inf (infsup ("0xff")), 255); %! assert (sup (infsup ("0xff")), 255); %! assert (inf (infsup ("0xff.1")), 255.0625); %! assert (sup (infsup ("0xff.1")), 255.0625); %! assert (inf (infsup ("0xff.1p-1")), 127.53125); %! assert (sup (infsup ("0xff.1p-1")), 127.53125); %!test "named constants"; %! assert (inf (infsup ("pi")), pi); %! assert (sup (infsup ("pi")), pi + 2 * eps); %! assert (inf (infsup ("e")), e); %! assert (sup (infsup ("e")), e + eps); %!test "uncertain form"; %! assert (inf (infsup ("32?")), 31.5); %! assert (sup (infsup ("32?")), 32.5); %! assert (inf (infsup ("32?8")), 24); %! assert (sup (infsup ("32?8")), 40); %! assert (inf (infsup ("32?u")), 32); %! assert (sup (infsup ("32?u")), 32.5); %! assert (inf (infsup ("32?d")), 31.5); %! assert (sup (infsup ("32?d")), 32); %! assert (inf (infsup ("32??")), -inf); %! assert (sup (infsup ("32??")), +inf); %! assert (inf (infsup ("32??d")), -inf); %! assert (sup (infsup ("32??d")), 32); %! assert (inf (infsup ("32??u")), 32); %! assert (sup (infsup ("32??u")), +inf); %! assert (inf (infsup ("32?e5")), 3150000); %! assert (sup (infsup ("32?e5")), 3250000); %!test "rational form"; %! assert (inf (infsup ("6/9")), 2 / 3); %! assert (sup (infsup ("6/9")), 2 / 3 + eps / 2); %! assert (inf (infsup ("6e1/9")), 20 / 3 - eps * 2); %! assert (sup (infsup ("6e1/9")), 20 / 3); %! assert (inf (infsup ("6/9e1")), 2 / 30); %! assert (sup (infsup ("6/9e1")), 2 / 30 + eps / 16); %! assert (inf (infsup ("-6/9")), -(2 / 3 + eps / 2)); %! assert (sup (infsup ("-6/9")), -2 / 3); %! assert (inf (infsup ("6/-9")), -(2 / 3 + eps / 2)); %! assert (sup (infsup ("6/-9")), -2 / 3); %! assert (inf (infsup ("-6/-9")), 2 / 3); %! assert (sup (infsup ("-6/-9")), 2 / 3 + eps / 2); %! assert (inf (infsup ("6.6/9.9")), 2 / 3); %! assert (sup (infsup ("6.6/9.9")), 2 / 3 + eps / 2); %!test "interval literal"; %! assert (inf (infsup ("[Entire]")), -inf); %! assert (sup (infsup ("[Entire]")), +inf); %! assert (inf (infsup ("[Empty]")), +inf); %! assert (sup (infsup ("[Empty]")), -inf); %! assert (inf (infsup ("[2, 3]")), 2); %! assert (sup (infsup ("[2, 3]")), 3); %! assert (inf (infsup ("[0.1]")), 0.1 - eps / 16); %! assert (sup (infsup ("[0.1]")), 0.1); %! assert (inf (infsup ("[0xff, 0xff.1]")), 255); %! assert (sup (infsup ("[0xff, 0xff.1]")), 255.0625); %! assert (inf (infsup ("[e, pi]")), e); %! assert (sup (infsup ("[e, pi]")), pi + 2 * eps); %! assert (inf (infsup ("[6/9, 6e1/9]")), 2 / 3); %! assert (sup (infsup ("[6/9, 6e1/9]")), 20 / 3); %!test "corner cases"; %! assert (inf (infsup (",")), -inf); %! assert (sup (infsup (",")), +inf); %! assert (inf (infsup ("[,]")), -inf); %! assert (sup (infsup ("[,]")), +inf); %! assert (inf (infsup ("[, 3]")), -inf); %! assert (sup (infsup ("[, 3]")), 3); %! assert (inf (infsup ("", "3")), -inf); %! assert (sup (infsup ("", "3")), 3); %! assert (inf (infsup ("[2, ]")), 2); %! assert (sup (infsup ("[2, ]")), inf); %! assert (inf (infsup ("2", "")), 2); %! assert (sup (infsup ("2", "")), inf); %!test "decimal vector"; %! assert (inf (infsup (["0.1"; "0.2"; "0.3"])), [0.1 - eps / 16; 0.2 - eps / 8; 0.3]); %! assert (sup (infsup (["0.1"; "0.2"; "0.3"])), [0.1; 0.2; 0.3 + eps / 8]); %! assert (inf (infsup ("0.1; 0.2; 0.3")), [0.1 - eps / 16; 0.2 - eps / 8; 0.3]); %! assert (sup (infsup ("0.1; 0.2; 0.3")), [0.1; 0.2; 0.3 + eps / 8]); %! assert (inf (infsup ("0.1\n0.2\n0.3")), [0.1 - eps / 16; 0.2 - eps / 8; 0.3]); %! assert (sup (infsup ("0.1\n0.2\n0.3")), [0.1; 0.2; 0.3 + eps / 8]); %!test "cell array with mixed boundaries"; %! assert (inf (infsup ({"0.1", 42; "e", "3.2/8"}, {"0xffp2", "42e1"; "pi", 2})), [0.1 - eps / 16, 42; e, 0.4 - eps / 4]); %! assert (sup (infsup ({"0.1", 42; "e", "3.2/8"}, {"0xffp2", "42e1"; "pi", 2})), [1020, 420; pi + 2 * eps, 2]); %! assert (inf (infsup ({"[2, 3]", "3/4", "[Entire]", "42?3", 1, "0xf"})), [2, 0.75, -inf, 39, 1, 15]); %! assert (sup (infsup ({"[2, 3]", "3/4", "[Entire]", "42?3", 1, "0xf"})), [3, 0.75, +inf, 45, 1, 15]); %!test "broadcasting"; %! assert (inf (infsup (magic (3), 10)), magic (3)); %! assert (sup (infsup (magic (3), 10)), 10 * ones (3)); %! assert (inf (infsup (1, magic (3))), ones (3)); %! assert (sup (infsup (1, magic (3))), magic (3)); %!error infsup ("[nai]"); %!error infsup ({42, "[nai]"}); %!error infsup (3, 2); %!error infsup ("Ausgeschnitzel"); %!warning infsup ("1.000000000000000000002", "1.000000000000000000001"); interval-1.4.1/inst/@infsup/interior.m0000644000000000000000000000327612657475772016117 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} interior (@var{A}, @var{B}) ## ## Evaluate interior comparison on intervals. ## ## True, if all numbers from @var{A} are also contained in @var{B}, but are no ## boundaries of @var{B}. False, if @var{A} contains a number which is not a ## member in @var{B} or which is a boundary of @var{B}. ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## @seealso{@@infsup/eq, @@infsup/subset, @@infsup/disjoint} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-30 function result = interior (a, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (a, "infsup"))) a = infsup (a); endif if (not (isa (b, "infsup"))) b = infsup (b); endif result = ((b.inf < a.inf | (b.inf == -inf & a.inf == -inf)) & ... (a.sup < b.sup | (a.sup == inf & b.sup == inf))); result (isempty (a) & isempty (b)) = true (); endfunction %!assert (interior (infsup (1, 2), infsup (0, 3))); interval-1.4.1/inst/@infsup/intersect.m0000644000000000000000000000711512657475772016260 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} intersect (@var{A}) ## @defmethodx {@@infsup} intersect (@var{A}, @var{B}) ## @defmethodx {@@infsup} intersect (@var{A}, [], @var{DIM}) ## ## Intersect intervals. ## ## With two arguments the intersection is built pair-wise. Otherwise the ## intersection is computed for all interval members along dimension @var{DIM}, ## which defaults to the first non-singleton dimension. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## x = infsup (1, 3); ## y = infsup (2, 4); ## intersect (x, y) ## @result{} ans = [2, 3] ## @end group ## @end example ## @seealso{@@infsup/union, @@infsup/setdiff, @@infsup/setxor} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-02 function result = intersect (a, b, dim) if (not (isa (a, "infsup"))) a = infsup (a); endif switch (nargin) case 1 l = max (a.inf); u = min (a.sup); case 2 if (not (isa (b, "infsup"))) b = infsup (b); endif l = max (a.inf, b.inf); u = min (a.sup, b.sup); case 3 if (not (builtin ("isempty", b))) warning ("intersect: second argument is ignored"); endif l = max (a.inf, [], dim); u = min (a.sup, [], dim); otherwise print_usage (); return endswitch ## If the intervals do not intersect, the result must be empty. emptyresult = l > u; l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "Empty interval"; %! assert (intersect (infsup (), infsup ()) == infsup ()); %! assert (intersect (infsup (), infsup (1)) == infsup ()); %! assert (intersect (infsup (0), infsup ()) == infsup ()); %! assert (intersect (infsup (-inf, inf), infsup ()) == infsup ()); %!test "Singleton intervals"; %! assert (intersect (infsup (0), infsup (1)) == infsup ()); %! assert (intersect (infsup (0), infsup (0)) == infsup (0)); %!test "Bounded intervals"; %! assert (intersect (infsup (1, 2), infsup (3, 4)) == infsup ()); %! assert (intersect (infsup (1, 2), infsup (2, 3)) == infsup (2)); %! assert (intersect (infsup (1, 2), infsup (1.5, 2.5)) == infsup (1.5, 2)); %! assert (intersect (infsup (1, 2), infsup (1, 2)) == infsup (1, 2)); %!test "Unbounded intervals"; %! assert (intersect (infsup (0, inf), infsup (-inf, 0)) == infsup (0)); %! assert (intersect (infsup (1, inf), infsup (-inf, -1)) == infsup ()); %! assert (intersect (infsup (-1, inf), infsup (-inf, 1)) == infsup (-1, 1)); %! assert (intersect (infsup (-inf, inf), infsup (42)) == infsup (42)); %! assert (intersect (infsup (42), infsup (-inf, inf)) == infsup (42)); %! assert (intersect (infsup (-inf, 0), infsup (-inf, inf)) == infsup (-inf, 0)); %! assert (intersect (infsup (-inf, inf), infsup (-inf, inf)) == infsup (-inf, inf)); %!test "from the documentation string"; %! assert (intersect (infsup (1, 3), infsup (2, 4)) == infsup (2, 3)); interval-1.4.1/inst/@infsup/intervaltoexact.m0000644000000000000000000000300512657475772017466 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {@var{S} =} intervaltoexact (@var{X}) ## ## Build an exact representation of the interval @var{X} in ## hexadecimal-significand form. ## ## The interval boundaries are stored in binary floating point format and can ## be converted to hexadecimal format without precision loss. ## ## The equation @code{@var{X} == exacttointerval (intervaltoexact (@var{X}))} ## holds for all intervals @var{X}. ## ## Accuracy: The output is exact. ## @seealso{exacttointerval} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-01 function s = intervaltoexact (x) if (nargin ~= 1) print_usage (); return endif s = intervaltotext (x, "exact hexadecimal"); endfunction %!assert (intervaltoexact (infsup (1 + eps)), "[0X1.0000000000001P+0]"); interval-1.4.1/inst/@infsup/intervaltotext.m0000644000000000000000000001047012657475772017352 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {@var{S} =} intervaltotext (@var{X}) ## @deftypemethodx {@@infsup} {@var{S} =} intervaltotext (@var{X}, @var{FORMAT}) ## ## Build an approximate representation of the interval @var{X}. ## ## Output @var{S} is a simple string for scalar intervals, and a cell array of ## strings for interval matrices. ## ## The interval boundaries are stored in binary floating point format and are ## converted to decimal or hexadecimal format with possible precision loss. If ## output is not exact, the boundaries are rounded accordingly (e. g. the upper ## boundary is rounded towards infinite for output representation). ## ## The exact decimal format may produce a lot of digits. ## ## Possible values for @var{FORMAT} are: @code{decimal} (default), ## @code{exact decimal}, @code{exact hexadecimal}, @code{auto} ## ## Accuracy: For all intervals @var{X} is an accurate subset of ## @code{infsup (intervaltotext (@var{X}))}. ## @example ## @group ## x = infsup (1 + eps); ## intervaltotext (x) ## @result{} [1.0000000000000002, 1.000000000000001] ## @end group ## @end example ## @example ## @group ## y = nextout (x); ## intervaltotext (y) ## @result{} [1, 1.0000000000000005] ## @end group ## @end example ## @example ## @group ## z = infsup (1); ## intervaltotext (z) ## @result{} [1] ## @end group ## @end example ## @seealso{@@infsup/intervaltoexact} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-30 function [s, isexact] = intervaltotext (x, format) if (nargin > 2) print_usage (); return endif isexact = true (); if (nargin < 2) format = "decimal"; endif s = l = u = cell (size (x.inf)); s (isempty (x)) = "[Empty]"; s (isentire (x)) = "[Entire]"; select = not (isempty (x) | isentire (x)); if (any (any (select))) x.inf (x.inf == 0) = 0; # no sign for zero [l(select), lexact] = mpfr_to_string_d (-inf, format, x.inf (select)); [u(select), uexact] = mpfr_to_string_d (+inf, format, x.sup (select)); isexact = lexact && uexact; ## Normalize case of +-Inf l (select & x.inf == -inf) = "-Inf"; u (select & x.sup == inf) = "Inf"; ## If l is negative, then u shall also carry a sign (not zero) change_of_sign = select & x.inf < 0 & x.sup > 0; u (change_of_sign) = strcat ("+", u (change_of_sign)); singleton_string = strcmp (l, u); s (select & singleton_string) = strcat ("[", ... l (select & singleton_string), ... "]"); s (select & not (singleton_string)) = strcat (... "[", ... l (select & not (singleton_string)), ... {", "}, ... u (select & not (singleton_string)), ... "]"); endif if (isscalar (s)) s = s {1}; endif endfunction %!assert (intervaltotext (infsup (1 + eps), "exact decimal"), "[1.0000000000000002220446049250313080847263336181640625]"); %!assert (intervaltotext (infsup (1 + eps), "exact hexadecimal"), "[0X1.0000000000001P+0]"); %!test %! output_precision (3, 'local'); %! assert (intervaltotext (infsup (pi), "auto"), "[3.14, 3.15]"); %! output_precision (4, 'local'); %! assert (intervaltotext (infsup (pi), "auto"), "[3.141, 3.142]"); %!test "from the documentation string"; %! assert (intervaltotext (infsup (1 + eps)), "[1.0000000000000002, 1.000000000000001]"); %! assert (intervaltotext (nextout (infsup (1 + eps))), "[1, 1.0000000000000005]"); %! assert (intervaltotext (infsup (1)), "[1]"); interval-1.4.1/inst/@infsup/inv.m0000644000000000000000000000405612657475772015055 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} inv (@var{A}) ## ## Compute the inverse of the square matrix @var{A}. ## ## Accuracy: The result is a valid enclosure. ## ## @example ## @group ## inv (infsup ([2, 1, 1; 0, 1, 0; 1, 0, 0])) ## @result{} ans = 3×3 interval matrix ## [0] [0] [1] ## [0] [1] [0] ## [1] [-1] [-2] ## inv (infsup ([1, 2, 3; 4, 0, 6; 0, 0, 1])) ## @result{} ans = 3×3 interval matrix ## [0] [0.25] [-1.5] ## [0.5] [-0.125] [-0.75] ## [0] [0] [1] ## @end group ## @end example ## @seealso{@@infsup/mrdivide} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-31 function result = inv (x) if (nargin ~= 1) print_usage (); return endif n = length (x); if (n <= 1) result = rdivide (1, x); return endif result = mldivide (x, eye (n)); endfunction %!test "from the wiki"; %! A = infsup ([1, 2, 3; 4, 0, 0; 0, 0, 1]); %! A (2, 3) = "[0, 6]"; %! B = inv (A); %! assert (inf (B) == [0, .25, -1.5; .5, -.125, -1.5; 0, 0, 1]); %! assert (sup (B) == [0, .25, 0; .5, -.125, -.75; 0, 0, 1]); %!test "from the documentation string"; %! assert (inv (infsup ([2, 1, 1; 0, 1, 0; 1, 0, 0])) == [0, 0, 1; 0, 1, 0; 1, -1, -2]); %! assert (inv (infsup ([1, 2, 3; 4, 0, 6; 0, 0, 1])) == [0, .25, -1.5; .5, -.125, -.75; 0, 0, 1]); interval-1.4.1/inst/@infsup/iscolumn.m0000644000000000000000000000257512657475772016116 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} iscolumn (@var{A}) ## ## Return true if @var{A} is an interval column vector. ## ## @seealso{@@infsup/isvector, @@infsup/isrow} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-18 ## FIXME This function is only required, because of a regression in octave 4.0 function result = iscolumn (A) if (nargin ~= 1) print_usage (); return endif result = iscolumn (A.inf); endfunction %!assert (not (iscolumn (infsup ([])))); %!assert (iscolumn (infsup (0))); %!assert (not (iscolumn (infsup (zeros (1, 2))))); %!assert (iscolumn (infsup (zeros (2, 1)))); %!assert (not (iscolumn (infsup (zeros (5))))); interval-1.4.1/inst/@infsup/iscommoninterval.m0000644000000000000000000000365712657475772017660 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} iscommoninterval (@var{X}) ## ## Check if the interval is a common interval, that is a nonemty, closed ## bounded real interval. ## ## Common intervals are used in class Moore interval arithmetic and are ## flavor-independent in IEEE Std 1788-2015 interval arithmetic. ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## @seealso{@@infsup/eq, @@infsup/isentire, @@infsup/isempty, @@infsup/issingleton} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-23 function result = iscommoninterval (x) if (nargin ~= 1) print_usage (); return endif result = isfinite (x.inf) & isfinite (x.sup); return %!assert (iscommoninterval (infsup (2, 3))); %!assert (not (iscommoninterval (infsup (2, inf)))); %!assert (not (iscommoninterval (infsup ()))); %!assert (not (iscommoninterval (infsup (-inf, inf)))); %!assert (iscommoninterval (infsupdec (2, 3, "com"))); %!assert (iscommoninterval (infsupdec (2, 3, "trv"))); %!assert (not (iscommoninterval (infsupdec (2, inf, "trv")))); %!assert (not (iscommoninterval (empty ()))); %!assert (not (iscommoninterval (entire ()))); %!warning assert (not (iscommoninterval (infsupdec (2, 1)))); interval-1.4.1/inst/@infsup/isempty.m0000644000000000000000000000255312657475772015753 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} isempty (@var{X}) ## ## Check if the interval represents the empty set. ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## Warning: This function is not compatible with the builtin @code{isempty} ## function. ## ## @seealso{@@infsup/eq, @@infsup/isentire, @@infsup/issingleton} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-27 function result = isempty (interval) if (nargin ~= 1) print_usage (); return endif result = (interval.inf > interval.sup); return %!assert (isempty (infsup (inf, -inf))); %!assert (not (isempty (infsup (1, 2)))); interval-1.4.1/inst/@infsup/isentire.m0000644000000000000000000000271612657475772016104 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} isentire (@var{X}) ## ## Check if the interval represents the entire set of real numbers. ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## @seealso{entire, @@infsup/eq, @@infsup/isempty, @@infsup/issingleton} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-27 function result = isentire (interval) if (nargin ~= 1) print_usage (); return endif result = (interval.inf == -inf & interval.sup == inf); endfunction %!assert (isentire (entire ())); %!assert (isentire (intervalpart (entire ()))); %!assert (not (isentire (empty ()))); %!assert (not (isentire (intervalpart (empty ())))); %!warning assert (not (isentire (infsupdec (2, 1)))); interval-1.4.1/inst/@infsup/ismatrix.m0000644000000000000000000000310312657475772016111 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} ismatrix (@var{A}) ## ## Return true if @var{A} is an interval matrix. ## ## Scalars (1x1 matrices) and vectors (1xN or Nx1 matrices) are subsets of the ## more general N-dimensional matrix and @code{ismatrix} will return true for ## these objects as well. ## @seealso{@@infsup/isscalar, @@infsup/isvector} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-29 ## FIXME: One happy day this function can be removed, because bug #42422 has ## been solved with GNU Octave 4.0. function result = ismatrix (A) if (nargin ~= 1) print_usage (); return endif result = ismatrix (A.inf); endfunction %!assert (ismatrix (infsup ([]))); %!assert (ismatrix (infsup (0))); %!assert (ismatrix (infsup (zeros (3, 1)))); %!assert (ismatrix (infsup (zeros (1, 4)))); %!assert (ismatrix (infsup (zeros (3, 4)))); interval-1.4.1/inst/@infsup/ismember.m0000644000000000000000000000372612657475772016067 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} ismember (@var{M}, @var{X}) ## ## Check if the interval @var{X} contains the number @var{M}. ## ## The number can be a numerical data type or a string representation of a ## decimal number. ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## @seealso{@@infsup/eq, @@infsup/isentire, @@infsup/issingleton, @@infsup/isempty} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = ismember (real, interval) if (nargin ~= 2) print_usage (); return endif if (not (isa (interval, "infsup"))) interval = infsup (interval); endif if (isreal (real) && isfloat (real)) ## Simple checking is only possible with floating point numbers result = isfinite (real) & interval.inf <= real & real <= interval.sup; else ## Mixed mode comparison between integers and floats can be problematic ## as well as comparison with decimal numbers result = subset (infsup (real), interval); endif endfunction %!assert (ismember (0, entire ())); %!assert (ismember (0, intervalpart (entire ()))); %!assert (not (ismember (0, empty ()))); %!assert (not (ismember (0, intervalpart (empty ())))); %!warning assert (not (ismember (0, infsupdec (2, 1)))); interval-1.4.1/inst/@infsup/isrow.m0000644000000000000000000000254512657475772015425 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} isrow (@var{A}) ## ## Return true if @var{A} is an interval row vector. ## ## @seealso{@@infsup/isvector, @@infsup/iscolumn} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-18 ## FIXME This function is only required, because of a regression in octave 4.0 function result = isrow (A) if (nargin ~= 1) print_usage (); return endif result = isrow (A.inf); endfunction %!assert (not (isrow (infsup ([])))); %!assert (isrow (infsup (0))); %!assert (isrow (infsup (zeros (1, 2)))); %!assert (not (isrow (infsup (zeros (2, 1))))); %!assert (not (isrow (infsup (zeros (5))))); interval-1.4.1/inst/@infsup/isscalar.m0000644000000000000000000000302412657475772016054 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} isscalar (@var{A}) ## ## Return true if @var{A} is an interval scalar. ## ## Scalars (1x1 matrices) are subsets of the more general vector or matrix and ## @code{isvector} and @code{ismatrix} will return true for these objects as ## well. ## @seealso{@@infsup/isvector, @@infsup/ismatrix} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-02 ## FIXME This function is only required, because of bug #43925 function result = isscalar (A) if (nargin ~= 1) print_usage (); return endif result = isscalar (A.inf); endfunction %!assert (not (isscalar (infsup ([])))); %!assert (isscalar (infsup (0))); %!assert (not (isscalar (infsup (zeros (1, 2))))); %!assert (not (isscalar (infsup (zeros (2, 1))))); %!assert (not (isscalar (infsup (zeros (5))))); interval-1.4.1/inst/@infsup/issingleton.m0000644000000000000000000000312312657475772016611 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} issingleton (@var{X}) ## ## Check if the interval represents a set that contains a single real only. ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## @seealso{@@infsup/eq, @@infsup/isentire, @@infsup/isempty} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-07 function result = issingleton (x) if (nargin ~= 1) print_usage (); return endif ## This check also works for empty intervals (-inf ~= +inf) result = (x.inf == x.sup); endfunction %!assert (issingleton (infsup (0))); %!assert (issingleton (infsupdec (0))); %!assert (not (issingleton (entire ()))); %!assert (not (issingleton (intervalpart (entire ())))); %!assert (not (issingleton (empty ()))); %!assert (not (issingleton (intervalpart (empty ())))); %!warning assert (not (issingleton (infsupdec (2, 1)))); interval-1.4.1/inst/@infsup/issquare.m0000644000000000000000000000261412657475772016113 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} issquare (@var{A}) ## ## Return true if @var{A} is a square interval matrix. ## ## @seealso{@@infsup/isvector, @@infsup/ismatrix, @@infsup/isscalar} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-18 ## FIXME This function is only required, because of a regression in octave 4.0 function result = issquare (A) if (nargin ~= 1) print_usage (); return endif result = issquare (A.inf); endfunction %!assert (issquare (infsup ([]))); %!assert (issquare (infsup (0))); %!assert (not (issquare (infsup (zeros (1, 2))))); %!assert (not (issquare (infsup (zeros (2, 1))))); %!assert (issquare (infsup (zeros (5)))); interval-1.4.1/inst/@infsup/isvector.m0000644000000000000000000000275512657475772016123 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} isvector (@var{A}) ## ## Return true if @var{A} is an interval vector. ## ## Scalars (1x1 vectors) are subsets of the more general vector and ## @code{isvector} will return true for these objects as well. ## @seealso{@@infsup/isscalar, @@infsup/ismatrix} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-02 ## FIXME This function is only required, because of regression #44498 function result = isvector (A) if (nargin ~= 1) print_usage (); return endif result = isvector (A.inf); endfunction %!assert (not (isvector (infsup ([])))); %!assert (isvector (infsup (0))); %!assert (isvector (infsup (zeros (1, 2)))); %!assert (isvector (infsup (zeros (2, 1)))); %!assert (not (isvector (infsup (zeros (5))))); interval-1.4.1/inst/@infsup/ldivide.m0000644000000000000000000000266212657475772015702 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} ldivide (@var{X}, @var{Y}) ## @defopx Operator {@@infsup} {@var{X} .\ @var{Y}} ## ## Divide all numbers of interval @var{Y} by all numbers of @var{X}. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## x = infsup (2, 3); ## y = infsup (1, 2); ## x .\ y ## @result{} ans ⊂ [0.33333, 1] ## @end group ## @end example ## @seealso{@@infsup/times} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-30 function result = ldivide (x, y) if (nargin ~= 2) print_usage (); return endif result = rdivide (y, x); endfunction %!test "from the documentation string"; %! assert (ldivide (infsup (2, 3), infsup (1, 2)) == "[1/3, 1]"); interval-1.4.1/inst/@infsup/le.m0000644000000000000000000000332412657475772014656 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} le (@var{A}, @var{B}) ## @defopx Operator {@@infsup} {@var{A} <= @var{B}} ## ## Compare intervals @var{A} and @var{B} for weakly less. ## ## True, if all numbers from @var{A} are weakly less than any number in ## @var{B}. False, if @var{A} contains a number which is strictly greater than ## all numbers in @var{B}. ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## @seealso{@@infsup/eq, @@infsup/lt, @@infsup/ge, @@infsup/subset, @@infsup/interior, @@infsup/disjoint} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-07 function result = le (a, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (a, "infsup"))) a = infsup (a); endif if (not (isa (b, "infsup"))) b = infsup (b); elseif (isa (b, "infsupdec")) ## Workaround for bug #42735 result = le (a, b); return endif result = (a.inf <= b.inf & a.sup <= b.sup); endfunction %!assert (le (infsup (1, 3), infsup (3))); interval-1.4.1/inst/@infsup/length.m0000644000000000000000000000267012657475772015542 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} length (@var{A}) ## ## Return the length of interval object @var{A}. ## ## The length is 0 for empty objects, 1 for scalars, and the number of elements ## for vectors. For matrix objects, the length is the number of rows or ## columns, whichever is greater. ## @seealso{@@infsup/numel, @@infsup/size, @@infsup/rows, @@infsup/columns} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-29 function result = length (a) result = length (a.inf); endfunction %!assert (length (infsup ([])), 0); %!assert (length (infsup (0)), 1); %!assert (length (infsup (zeros (3, 1))), 3); %!assert (length (infsup (zeros (1, 4))), 4); %!assert (length (infsup (zeros (3, 4))), 4); interval-1.4.1/inst/@infsup/linspace.m0000644000000000000000000000425412657475772016057 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} linspace (@var{BASE}, @var{LIMIT}) ## @defmethodx {@@infsup} linspace (@var{BASE}, @var{LIMIT}, @var{N}) ## ## Return a row vector of @var{N} linearly spaced members between @var{BASE} ## and @var{LIMIT}. ## ## If @var{BASE} is greater than @var{LIMIT}, members are returned in ## decreasing order. The default value for @var{N} is 100. ## ## If either @var{BASE} or @var{LIMIT} is not a scalar, the result is a matrix. ## ## Accuracy: The result is an accurate enclosure. ## ## @example ## @group ## transpose (linspace (infsup (0), infsup (10), 4)) ## @result{} ans ⊂ 4×1 interval vector ## ## [0] ## [3.3333, 3.3334] ## [6.6666, 6.6667] ## [10] ## @end group ## @end example ## @seealso{linspace} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-07-19 function result = linspace (base, limit, n) if (nargin < 2 || nargin > 3) print_usage (); return endif if (not (isa (base, "infsup"))) base = infsup (base); endif if (not (isa (limit, "infsup"))) limit = infsup (limit); endif if (nargin < 3) n = 100; endif l = mpfr_linspace_d (-inf, base.inf, limit.inf, n); u = mpfr_linspace_d (+inf, base.sup, limit.sup, n); empty = vec (isempty (base) | isempty (limit)); l(empty, :) = inf; u(empty, :) = -inf; result = infsup (l, u); endfunction %!xtest assert (isequal (linspace (infsup (0), infsup (10), 9), infsup (linspace (0, 10, 9)))); interval-1.4.1/inst/@infsup/log.m0000644000000000000000000000327612657475772015045 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} log (@var{X}) ## ## Compute the natural logarithm. ## ## The function is only defined where @var{X} is positive. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## log (infsup (2)) ## @result{} ans ⊂ [0.69314, 0.69315] ## @end group ## @end example ## @seealso{@@infsup/exp, @@infsup/log2, @@infsup/log10} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-04 function result = log (x) if (nargin ~= 1) print_usage (); return endif x = intersect (x, infsup (0, inf)); ## log is monotonically increasing from (0, -inf) to (inf, inf) l = mpfr_function_d ('log', -inf, x.inf); # this works for empty intervals u = mpfr_function_d ('log', +inf, x.sup); # ... this does not l (x.sup == 0) = inf; u (isempty (x) | x.sup == 0) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (log (infsup (2)) == "[0x1.62E42FEFA39EFp-1, 0x1.62E42FEFA39Fp-1]"); interval-1.4.1/inst/@infsup/log10.m0000644000000000000000000000332712657475772015203 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} log10 (@var{X}) ## ## Compute the decimal (base-10) logarithm. ## ## The function is only defined where @var{X} is positive. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## log10 (infsup (2)) ## @result{} ans ⊂ [0.30102, 0.30103] ## @end group ## @end example ## @seealso{@@infsup/pow10, @@infsup/log, @@infsup/log2} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-04 function result = log10 (x) if (nargin ~= 1) print_usage (); return endif x = intersect (x, infsup (0, inf)); ## log10 is monotonically increasing from (0, -inf) to (inf, inf) l = mpfr_function_d ('log10', -inf, x.inf); # this works for empty intervals u = mpfr_function_d ('log10', +inf, x.sup); # ... this does not l (x.sup == 0) = inf; u (isempty (x) | x.sup == 0) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (log10 (infsup (2)) == "[0x1.34413509F79FEp-2, 0x1.34413509F79FFp-2]"); interval-1.4.1/inst/@infsup/log1p.m0000644000000000000000000000335512657475772015304 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} log1p (@var{X}) ## ## Compute @code{log (1 + @var{X})} accurately in the neighborhood of zero. ## ## The function is only defined where @var{X} is greater than -1. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## log1p (infsup (eps)) ## @result{} ans ⊂ [2.2204e-16, 2.2205e-16] ## @end group ## @end example ## @seealso{@@infsup/exp, @@infsup/log} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-20 function result = log1p (x) if (nargin ~= 1) print_usage (); return endif x = intersect (x, infsup (-1, inf)); ## log is monotonically increasing from (-1, -inf) to (inf, inf) l = mpfr_function_d ('log1p', -inf, x.inf); # this works for empty intervals u = mpfr_function_d ('log1p', +inf, x.sup); # ... this does not l (x.sup == -1) = inf; u (isempty (x) | x.sup == -1) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (log1p (infsup (eps)) == "[0x1.FFFFFFFFFFFFFp-53, 0x1p-52]"); interval-1.4.1/inst/@infsup/log2.m0000644000000000000000000000322012657475772015114 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} log2 (@var{X}) ## ## Compute the binary (base-2) logarithm. ## ## The function is only defined where @var{X} is positive. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## log2 (infsup (2)) ## @result{} ans = [1] ## @end group ## @end example ## @seealso{@@infsup/pow2, @@infsup/log, @@infsup/log10} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-04 function result = log2 (x) if (nargin ~= 1) print_usage (); return endif x = intersect (x, infsup (0, inf)); ## log2 is monotonically increasing from (0, -inf) to (inf, inf) l = mpfr_function_d ('log2', -inf, x.inf); # this works for empty intervals u = mpfr_function_d ('log2', +inf, x.sup); # ... this does not l (x.sup == 0) = inf; u (isempty (x) | x.sup == 0) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (log2 (infsup (2)) == 1); interval-1.4.1/inst/@infsup/lt.m0000644000000000000000000000366712657475772014707 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} lt (@var{A}, @var{B}) ## @defopx Operator {@@infsup} {@var{A} < @var{B}} ## ## Compare intervals @var{A} and @var{B} for strictly less. ## ## True, if all numbers from @var{A} are strict less than at least one number ## in @var{B}. False, if @var{A} contains a number which is greater than all ## numbers in @var{B} or is equal to the greatest number of @var{B}. ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## @seealso{@@infsup/eq, @@infsup/le, @@infsup/gt, @@infsup/subset, @@infsup/interior, @@infsup/disjoint} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-07 function result = lt (a, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (a, "infsup"))) a = infsup (a); endif if (not (isa (b, "infsup"))) b = infsup (b); elseif (isa (b, "infsupdec")) ## Workaround for bug #42735 result = lt (a, b); return endif result = ((a.inf < b.inf | (a.inf == -inf & b.inf == -inf)) & ... (a.sup < b.sup | (a.sup == inf & b.sup == inf))); result (isempty (a) & isempty (b)) = true (); endfunction %!assert (not (lt (infsup (1, 3), infsup (3)))); %!assert (lt (infsup (1, 3), infsup (3.1))); interval-1.4.1/inst/@infsup/lu.m0000644000000000000000000001430712657475772014701 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {[@var{L}, @var{U}] = } lu (@var{A}) ## @deftypemethodx {@@infsup} {[@var{L}, @var{U}, @var{P}] = } lu (@var{A}) ## ## Compute the LU decomposition of @var{A}. ## ## @var{A} will be a subset of @var{L} * @var{U}. ## ## The result is returned in a permuted form, according to the optional return ## value @var{P}. ## ## Accuracy: The result is a valid enclosure. ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-31 function [L, U, P] = lu (x) if (nargin ~= 1) print_usage (); return endif if (not (isa (x, "infsup"))) x = infsup (x); endif if (isscalar (x)) L = P = eye (size (x)); U = x; return endif ## x must be square assert (size (x.inf, 1) == size (x.inf, 2), ... "operator \: nonconformant arguments, X is not square"); n = rows (x.inf); if (nargout < 3) P = eye (n); else ## Compute P such that the computation of L below will not fail because of ## division by zero. P * x should not have zeros in its main diagonal. ## The computation of P is a greedy heuristic algorithm, which I developed ## for the implementation of this function. P = zeros (n); migU = mig (x); magU = mag (x); ## Empty intervals are as bad as intervals containing only zero. migU (isnan (migU)) = 0; magU (isnan (magU)) = 0; for i = 1 : n ## Choose next pivot in one of the columns with the fewest mig (U) > 0. columnrating = sum (migU > 0, 1); ## Don't choose used columns columnrating (max (migU, [], 1) == inf) = inf; ## Use first possible column possiblecolumns = columnrating == min (columnrating); column = find (possiblecolumns, 1); if (columnrating (column) >= 1) ## Greedy: Use only intervals that do not contain zero. possiblerows = migU (:, column) > 0; else ## Only intervals left which contain zero. Try to use an interval ## that additionally contains other numbers. possiblerows = migU (:, column) >= 0 & magU (:, column) > 0; if (not (max (possiblerows))) ## All possible intervals contain only zero. possiblerows = migU (:, column) >= 0; endif endif if (sum (possiblerows) == 1) ## Short-ciruit: Take the only remaining useful row row = find (possiblerows, 1); else ## There are several good choices, take the one that will hopefully ## not hinder the choice of further pivot elements. ## That is, the row with the least mig (U) > 0. rowrating = sum (migU > 0, 2); ## We weight the rating in the columns with few mig (U) > 0 in ## order to prevent problems during the choice of pivots in the ## near future. rowrating += 0.5 * sum (migU (:, possiblecolumns) > 0, 2); rowrating (not (possiblerows)) = inf; row = find (rowrating == min (rowrating), 1); endif # assert (0 <= migU (row, column) && migU (row, column) < inf); P (row, column) = 1; ## In mig (U), for the choice of further pivots: ## - mark used columns with inf ## - mark used rows in unused columns with -inf migU (row, :) -= inf; migU (isnan (migU)) = inf; migU (:, column) = inf; endfor endif ## Initialize L and U L = infsup (eye (n)); U = permute (P, x); ## Compute L and U varidx.type = rowstart.type = Urefrow.type = Urow.type = "()"; for i = 1 : (n - 1) varidx.subs = {i, i}; Urefrow.subs = {i, i : n}; ## Go through rows of the remaining matrix for k = (i + 1) : n rowstart.subs = {k, i}; ## Compute L Lcurrentelement = mulrev (subsref (U, varidx), subsref (U, rowstart)); L = subsasgn (L, rowstart, Lcurrentelement); ## Go through columns of the remaining matrix Urow.subs = {k, i : n}; ## Compute U minuend = subsref (U, Urow); subtrahend = Lcurrentelement .* subsref (U, Urefrow); U = subsasgn (U, Urow, minuend - subtrahend); endfor endfor ## Cleanup U U.inf = triu (U.inf); U.sup = triu (U.sup); endfunction ## Apply permutation matrix P to an interval matrix: B = P * A. ## This is much faster than a matrix product, because the matrix product would ## use a lot of dot products. function B = permute (P, A) ## Note: [B.inf, B.sup] = deal (P * A.inf, P * A.sup) is not possible, ## because empty or unbound intervals would create NaNs during ## multiplication with P. B = A; for i = 1 : rows (P) targetrow = find (P (i, :) == 1, 1); B.inf (targetrow, :) = A.inf (i, :); B.sup (targetrow, :) = A.sup (i, :); endfor endfunction %!test %! [l, u] = lu (infsup (magic (3))); %! assert (l == infsup ({1, 0, 0; .375, 1, 0; .5, "68/37", 1}));, ... %! assert (subset (u, infsup ({8, 1, 6; 0, 4.625, 4.75; 0, 0, "-0x1.3759F2298375Bp3"}, ... %! {8, 1, 6; 0, 4.625, 4.75; 0, 0, "-0x1.3759F22983759p3"}))); %! A = magic (3); %! A ([1, 5, 9]) = 0; %! [l, u, p] = lu (infsup (A)); %! assert (p, [0, 0, 1; 1, 0, 0; 0, 1, 0]); %! assert (l == infsup ({1, 0, 0; "4/3", 1, 0; 0, "1/9", 1})); %! assert (subset (u, infsup ({3, 0, 7; 0, 9, "-0x1.2AAAAAAAAAAACp3"; 0, 0, "0x1.C25ED097B425Ep2"}, ... %! {3, 0, 7; 0, 9, "-0x1.2AAAAAAAAAAAAp3"; 0, 0, "0x1.C25ED097B426p2"}))); interval-1.4.1/inst/@infsup/mag.m0000644000000000000000000000271612657475772015026 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} mag (@var{X}) ## ## Get the magnitude of numbers in interval @var{X}, that is the maximum of ## absolute values for each element. ## ## If @var{X} is empty, @code{mag (@var{X})} is NaN. ## ## Accuracy: The result is exact. ## ## @example ## @group ## mag (infsup (-3, 2)) ## @result{} ans = 3 ## @end group ## @end example ## @seealso{@@infsup/mig, @@infsup/smig, @@infsup/inf, @@infsup/sup} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-30 function result = mag (x) if (nargin ~= 1) print_usage (); return endif result = max (abs (x.inf), abs (x.sup)); result (isempty (x)) = nan (); endfunction %!assert (mag (infsup (-3, 4)), 4); %!assert (mag (infsup (-4, 3)), 4); interval-1.4.1/inst/@infsup/max.m0000644000000000000000000000474112657475772015047 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} max (@var{X}) ## @defmethodx {@@infsup} max (@var{X}, @var{Y}) ## @defmethodx {@@infsup} max (@var{X}, [], @var{DIM}) ## ## Compute the maximum value chosen from intervals. ## ## This function does not return the greatest element of the interval (see ## @code{sup}), but returns an interval enclosure of the function: ## @display ## max (@var{x}, @var{y}) = ( (x + y) + abs (x - y) ) / 2 ## @end display ## ## With two arguments the function is applied element-wise. Otherwise the ## maximum is computed for all interval members along dimension @var{DIM}, ## which defaults to the first non-singleton dimension. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## x = infsup (2, 3); ## y = infsup (1, 2); ## max (x, y) ## @result{} ans = [2, 3] ## @end group ## @end example ## @seealso{@@infsup/min} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-04 function result = max (x, y, dim) if (not (isa (x, "infsup"))) x = infsup (x); endif switch (nargin) case 1 l = max (x.inf); u = max (x.sup); u (any (isempty (x))) = -inf; case 2 if (not (isa (y, "infsup"))) y = infsup (y); endif l = max (x.inf, y.inf); u = max (x.sup, y.sup); u (isempty (x) | isempty (y)) = -inf; case 3 if (not (builtin ("isempty", y))) warning ("max: second argument is ignored"); endif l = max (x.inf, [], dim); u = max (x.sup, [], dim); u (any (isempty (x), dim)) = -inf; otherwise print_usage (); return endswitch result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (max (infsup (2, 3), infsup (1, 2)) == infsup (2, 3)); interval-1.4.1/inst/@infsup/meshgrid.m0000644000000000000000000000652312657475772016064 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {[@var{XX}, @var{YY}] =} meshgrid (@var{X}, @var{Y}) ## @deftypemethodx {@@infsup} {[@var{XX}, @var{YY}, @var{ZZ}] =} meshgrid (@var{X}, @var{Y}, @var{Z}) ## @deftypemethodx {@@infsup} {[@var{XX}, @var{YY}] =} meshgrid (@var{X}) ## @deftypemethodx {@@infsup} {[@var{XX}, @var{YY}, @var{ZZ}] =} meshgrid (@var{X}) ## ## Given vectors of @var{X} and @var{Y} coordinates, return matrices @var{XX} ## and @var{YY} corresponding to a full 2-D grid. ## ## If the optional @var{Z} input is given, or @var{ZZ} is requested, then the ## output will be a full 3-D grid. ## ## Please note that this function does not produce multidimensional arrays in ## the case of 3-D grids like the built-in @code{meshgrid} function. This is ## because interval matrices currently only support two dimensions. The 3-D ## grid is reshaped to fit into two dimensions accordingly. ## ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-07-19 function [xx, yy, zz] = meshgrid (x, y, z) if (nargin > 3) print_usage (); return endif if (not (isa (x, "infsup"))) x = infsup (x); endif if (nargin >= 2 && not (isa (y, "infsup"))) y = infsup (y); endif if (nargin >= 3 && not (isa (z, "infsup"))) z = infsup (z); endif switch (nargin) case 1 if (nargout >= 3) [lxx, lyy, lzz] = meshgrid (x.inf); [uxx, uyy, uzz] = meshgrid (x.sup); else [lxx, lyy] = meshgrid (x.inf); [uxx, uyy] = meshgrid (x.sup); endif case 2 if (nargout >= 3) [lxx, lyy, lzz] = meshgrid (x.inf, y.inf); [uxx, uyy, uzz] = meshgrid (x.sup, y.sup); else [lxx, lyy] = meshgrid (x.inf, y.inf); [uxx, uyy] = meshgrid (x.sup, y.sup); endif case 3 [lxx, lyy, lzz] = meshgrid (x.inf, y.inf, z.inf); [uxx, uyy, uzz] = meshgrid (x.sup, y.sup, z.sup); endswitch if (nargout >= 3 || nargin >= 3) ## Reshape 3 dimensions into 2 dimensions f = @(A) reshape (A, [size(A,1), prod(size (A)(2 : end))]); lxx = f (lxx); uxx = f (uxx); lyy = f (lyy); uyy = f (uyy); lzz = f (lzz); uzz = f (uzz); endif xx = infsup (lxx, uxx); yy = infsup (lyy, uyy); if (nargout >= 3) zz = infsup (lzz, uzz); endif endfunction %!xtest assert (isequal (meshgrid (infsup (0 : 3)), infsup (meshgrid (0 : 3)))); %!demo %! clf %! blue = [38 139 210] ./ 255; %! shade = [238 232 213] ./ 255; %! [x, y, z] = meshgrid (midrad (1 : 6, 0.125)); %! plot3 (x, y, z, shade, blue) %! view ([-42.5, 30]) %! box off %! set (gca, "xgrid", "on", "ygrid", "on", "zgrid", "on") interval-1.4.1/inst/@infsup/mid.m0000644000000000000000000000436012657475772015030 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} mid (@var{X}) ## ## Get the midpoint of interval @var{X}. ## ## If @var{X} is empty, @code{mid (@var{X})} is NaN. ## If @var{X} is entire, @code{mid (@var{X})} is 0. ## If @var{X} is unbounded in one direction, @code{mid (@var{X})} is positive ## or negative @code{realmax ()}. ## ## Accuracy: The result is rounded to the nearest floating point number and ## may thus be exact or not. However, it is guaranteed that the interval ## @var{X} is tightly enclosed by ## @code{[mid (@var{X}) - rad (@var{X}), mid (@var{X}) + rad (@var{X})]}. ## ## @example ## @group ## mid (infsup (2.5, 3.5)) ## @result{} ans = 3 ## @end group ## @end example ## @seealso{@@infsup/inf, @@infsup/sup, @@infsup/rad} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-05 function result = mid (x) if (nargin ~= 1) print_usage (); return endif ## First divide by 2 and then add, because this will prevent overflow. ## The different rounding modes for division will make errors of 2^-1075 ## with subnormal numbers cancel each other out, or will make the round ## to nearest prefer the side that had an underflow error. l = mpfr_function_d ('rdivide', -inf, x.inf, 2); u = mpfr_function_d ('rdivide', +inf, x.sup, 2); result = l + u; result (x.inf == -inf) = -realmax (); result (x.sup == inf) = realmax (); result (isentire (x)) = 0; result (isempty (x)) = nan (); endfunction %!assert (mid (infsup (-inf, inf)), 0); %!test "from the documentation string"; %! assert (mid (infsup (2.5, 3.5)), 3); interval-1.4.1/inst/@infsup/mig.m0000644000000000000000000000275712657475772015043 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} mig (@var{X}) ## ## Get the mignitude of numbers in interval @var{X}, that is the minimum of ## absolute values for each element. ## ## If @var{X} is empty, @code{mig (@var{X})} is NaN. ## ## Accuracy: The result is exact. ## ## @example ## @group ## mig (infsup (-2, -1)) ## @result{} ans = 1 ## @end group ## @end example ## @seealso{@@infsup/mag, @@infsup/inf, @@infsup/sup} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-30 function result = mig (x) if (nargin ~= 1) print_usage (); return endif result = min (abs (x.inf), abs (x.sup)); result (sign (x.inf) ~= sign (x.sup)) = 0; result (isempty (x)) = nan (); endfunction %!assert (mig (infsup (-1, 2)), 0); %!assert (mig (infsup (-42, -23)), 23); interval-1.4.1/inst/@infsup/min.m0000644000000000000000000000473312657475772015046 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} min (@var{X}) ## @defmethodx {@@infsup} min (@var{X}, @var{Y}) ## @defmethodx {@@infsup} min (@var{X}, [], @var{DIM}) ## ## Compute the minimum value chosen from intervals. ## ## This function does not return the least element of the interval (see ## @code{inf}), but returns an interval enclosure of the function: ## @display ## min (@var{x}, @var{y}) = ( (x + y) - abs (x - y) ) / 2 ## @end display ## ## With two arguments the function is applied element-wise. Otherwise the ## minimum is computed for all interval members along dimension @var{DIM}, ## which defaults to the first non-singleton dimension. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## x = infsup (2, 3); ## y = infsup (1, 2); ## min (x, y) ## @result{} ans = [1, 2] ## @end group ## @end example ## @seealso{@@infsup/max} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-04 function result = min (x, y, dim) if (not (isa (x, "infsup"))) x = infsup (x); endif switch (nargin) case 1 l = min (x.inf); u = min (x.sup); l (any (isempty (x))) = inf; case 2 if (not (isa (y, "infsup"))) y = infsup (y); endif l = min (x.inf, y.inf); u = min (x.sup, y.sup); l (isempty (x) | isempty (y)) = inf; case 3 if (not (builtin ("isempty", y))) warning ("min: second argument is ignored"); endif l = min (x.inf, [], dim); u = min (x.sup, [], dim); l (any (isempty (x), dim)) = inf; otherwise print_usage (); return endswitch result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (min (infsup (2, 3), infsup (1, 2)) == infsup (1, 2)); interval-1.4.1/inst/@infsup/mince.m0000644000000000000000000000421112657475772015345 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} mince (@var{X}) ## @defmethodx {@@infsup} mince (@var{X}, @var{N}) ## ## Mince interval @var{X} into a row vector of @var{N} sub-intervals of equal ## size. ## ## The sub-intervals are returned in ascending order and may overlap due to ## round-off errors. ## ## If @var{X} is not a scalar, the result is a matrix. The default value for ## @var{N} is 100. ## ## Accuracy: The result is an accurate enclosure. ## ## @example ## @group ## mince (infsup (0, 10), 4) ## @result{} ans = 1×4 interval vector ## ## [0, 2.5] [2.5, 5] [5, 7.5] [7.5, 10] ## @end group ## @end example ## @seealso{@@infsup/linspace, @@infsup/bisect} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-07-19 function result = mince (x, n) if (nargin > 2) print_usage (); return endif if (not (isa (x, "infsup"))) x = infsup (x); endif if (nargin < 2) n = 100; endif base = limit = x; idx.type = '()'; idx.subs = {isfinite(x.inf)}; base = subsasgn (base, idx, infsup (subsref (x.inf, idx))); idx.subs = {isfinite(x.sup)}; limit = subsasgn (limit, idx, infsup (subsref (x.sup, idx))); boundaries = linspace (base, limit, n + 1); l = boundaries.inf (:, 1 : end - 1); u = boundaries.sup (:, 2 : end); empty = vec (isempty (x)); l(empty, :) = inf; u(empty, :) = -inf; result = infsup (l, u); endfunction %!xtest assert (isequal (mince (infsup (0, 10), 10), infsup (0 : 9, 1 : 10))); interval-1.4.1/inst/@infsup/minus.m0000644000000000000000000000346312657475772015415 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} minus (@var{X}, @var{Y}) ## @defopx Operator {@@infsup} {@var{X} - @var{Y}} ## ## Subtract all numbers of interval @var{Y} from all numbers of @var{X}. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## x = infsup (2, 3); ## y = infsup (1, 2); ## x - y ## @result{} ans = [0, 2] ## @end group ## @end example ## @seealso{@@infsup/plus} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-30 function result = minus (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsup"))) x = infsup (x); endif if (not (isa (y, "infsup"))) y = infsup (y); elseif (isa (y, "infsupdec")) ## Workaround for bug #42735 result = minus (x, y); return endif l = mpfr_function_d ('minus', -inf, x.inf, y.sup); u = mpfr_function_d ('minus', +inf, x.sup, y.inf); emptyresult = isempty (x) | isempty (y); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (infsup (2, 3) - infsup (1, 2) == infsup (0, 2)); interval-1.4.1/inst/@infsup/mldivide.m0000644000000000000000000002240512657475772016054 0ustar 00000000000000## Copyright 1990-2000 Institut für Angewandte Mathematik, ## Universität Karlsruhe, Germany ## Copyright 2000-2014 Wissenschaftliches Rechnen/Softwaretechnologie, ## Universität Wuppertal, Germany ## Copyright 2015-2016 Oliver Heimlich ## ## This program is derived from FastLSS in CXSC, C++ library for eXtended ## Scientific Computing (V 2.5.4), which is distributed under the terms of ## LGPLv2+. Original Author is Michael Zimmer. Migration to Octave code has ## been performed by Oliver Heimlich. ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} mldivide (@var{X}, @var{Y}) ## @defopx Operator {@@infsup} {@var{X} \ @var{Y}} ## ## Return the interval matrix left division of @var{X} and @var{Y}. ## ## Accuracy: The result is a valid enclosure. ## ## @example ## @group ## infsup ([1, 0; 0, 2]) \ [2, 0; 0, 4] ## @result{} ans = 2×2 interval matrix ## [2] [0] ## [0] [2] ## @end group ## @end example ## @seealso{@@infsup/mtimes, @@infsup/gauss} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-17 function result = mldivide (A, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (A, "infsup"))) A = infsup (A); endif if (not (isa (b, "infsup"))) b = infsup (b); elseif (isa (b, "infsupdec")) ## Workaround for bug #42735 result = mldivide (A, b); return endif if (isscalar (A.inf)) result = ldivide (A, b); return elseif (not (issquare (A.inf))) error ("interval:InvalidOperand", "mldivide: Matrix is not square"); elseif (rows (A.inf) ~= rows (b.inf)) error ("interval:InvalidOperand", ["mldivide: ", ... "nonconformant arguments ", ... "(op1 is " num2str(rows (A.inf)) "×" num2str(columns (A.inf)) ",", ... " op2 is " num2str(rows (b.inf)) "×" num2str(columns (b.inf)) ")"]); elseif (isempty (A.inf)) result = infsup (zeros (0, columns (b.inf))); return endif ## Maximum number of iterations during the verification step cfg.maxIterVer = 5; ## Epsilon for the verification step ## (used for the Epsilon inflation during verification) cfg.epsVer = 1e-1; ## Maximum number of iterations during the refinement step cfg.maxIterRef = 5; ## Epsilon for the refinement step (stopping criterion for refinement step) cfg.epsRef = 1e-5; ## Maximum number of iterations during residual correction ## (not available for K=1) cfg.maxIterResCorr = 10; ## Epsilon for the residual correction cfg.epsResCorr = 1e-6; ## An approximate inverse R of A is computed. Then an approximate solution ## x1 is computed applying a conventional residual iteration. For the final ## verification, an interval residual iteration is performed. An enclosure of ## the unique solution is returned. ## ## If this first step fails, the solver will try to compute a verified solution ## by using an approximate inverse of double length. This second step takes ## considerably longer than the first step, because all computations must be ## performed using high precision scalar products. ## Compute midpoints of A and b for future reference Am = mid (A); bm = mid (b); ## Approximate inversion (non-interval computation) [R, cond] = inv (Am); if (cond == 0) result = gauss (A, b); return endif ## Part 1 ===================================================================== ## Approximate solution x1 (non-interval computation) x1 = R * bm; x1 += R * (bm - Am * x1); ## Interval residual x x = mtimes (R, b - mtimes (A, x1, "valid"), "valid"); C = eye (rows (R)) - mtimes (R, A, "valid"); ## Verify solution x1 + x [x, verified] = verify_and_refine (x, C, cfg, "valid"); if (verified) result = x1 + x; return endif ## Part 2 ===================================================================== ## R2 = inv (R * Am), with correctly rounded dot product R2 = zeros (size (R)); for i = 1 : rows (R) for j = 1 : columns (R) R2 (i, j) = mpfr_vector_dot_d (0.5, R (i, :), Am (:, j)); endfor endfor [R2, cond] = inv (R2); if (cond == 0) result = gauss (A, b); return endif ## R = R2 * R with correctly rounded dot product; error in R2 R1_ = R2_ = zeros (size (R)); for i = 1 : rows (R) for j = 1 : columns (R) [R1_(i, j), R2_(i, j)] = mpfr_vector_dot_d (0.5, R2 (i, :), R (:, j)); endfor endfor R = R1_; R2 = R2_; clear R1_ R2_; ## Loop over all right hand sides C_computed = false (); result = infsup (zeros (size (b.inf))); for s = 1 : columns (b.inf) s_idx.type = "()"; s_idx.subs = {":", s}; ## x1 = R * bm + R2 * bm with correctly rounded dot product; error in x0 x1 = x0 = zeros (rows (R), 1); parfor i = 1 : rows (R) [x1(i), x0(i)] = mpfr_vector_dot_d (0.5, [R(i, :), R2(i, :)], ... [bm(:, s); bm(:, s)]); endparfor ## Residual iteration (non-interval computation) for k = 1 : cfg.maxIterResCorr ## d = bm - Am * x1 - Am * x0 with correctly rounded dot product d = zeros (rows (R), 1); parfor i = 1 : rows (R) d (i) = mpfr_vector_dot_d (0.5, ... [bm(i, s), Am(i, :), Am(i, :)], ... [1; -x1; -x0]); endparfor ## y0 = x0 + R * d + R2 * d with correctly rounded dot product y0 = zeros (rows (R), 1); parfor i = 1 : rows (R) y0 (i) = mpfr_vector_dot_d (0.5, ... [x0(i), R(i, :), R2(i, :)], ... [1; d; d]); endparfor d = x1 + y0; p = relative_error (d, x1 + x0); if (p >= cfg.epsResCorr && k < cfg.maxIterResCorr) ## x0 = x1 + x0 - d with correctly rounded sum parfor i = 1 : rows (R) x0 (i) = mpfr_vector_sum_d (0.5, [x1(i), x0(i), -d(i)]); endparfor endif x1 = d; if (p < cfg.epsResCorr) break endif endfor ## compute enclosure y+Y1 of the residuum b-A*x1 of the approximation x1 ## and initialize x:= (R+R2)*(b-A*x1), C:= I-(R+R2)*A ## y = mid (b - A * x1) y = mid ([subsref(b, s_idx), A] * [1; -x1]); ## Y1 = b - A * x1 - y Y1 = [subsref(b, s_idx), A, y] * [1; -x1; -1]; ## x = R * y + R2 * y + R * Y1 + R2 * Y1 x = [R, R2, R, R2] * [y; y; Y1; Y1]; ## Verifying solution x1 + x ... if (all (x.inf == 0 & x.sup == 0)) ## exact solution! (however, not necessarily unique!) subsasgn (result, s_idx, x1); continue endif if (not (C_computed)) ## C = I - R * A - R2 * A (lazy computation) C = [eye(rows (R)), R, R2] * [eye(rows (R)); -A; -A]; C_computed = true (); endif [x, verified] = verify_and_refine (x, C, cfg, "tight"); if (not (verified)) error ("Verification failed") endif ## The exact solution lies x1 + x subsasgn (result, s_idx, x1 + x); endfor endfunction ## Perform an epsilon inflation function y = blow (x, eps) y = nextout ((1 + eps) .* x - eps .* x); endfunction ## Compute component-wise the maximum relative error function e = relative_error (new, old) nonzero = old ~= 0 & (1e6 * abs (new) >= abs (old)); e = max (abs ((new (nonzero) - old (nonzero)) ./ old (nonzero))); if (isempty (e)) e = 0; endif endfunction ## Interval iteration until inclusion is obtained (or max. iteration count) function [x, verified] = verify_and_refine (x0, C, cfg, accuracy) verified = false (); x = x0; for p = 1 : cfg.maxIterVer y = blow (x, cfg.epsVer); # epsilon inflation x = x0 + mtimes (C, y, accuracy); # new iterate verified = all (all (subset (x, y))); if (verified) break endif endfor if (verified) ## Iterative refinement for p = 1 : cfg.maxIterRef y = x; x = intersect (x0 + mtimes (C, x, accuracy), x); if (p == cfg.maxIterRef) break endif distance = max (abs (x.inf - y.inf), ... abs (x.sup - y.sup)); if (max (max (distance)) <= cfg.epsRef) break endif endfor endif endfunction %!test "unique solution"; %! assert (infsup ([1, 0; 0, 2]) \ [2, 0; 0, 4] == [2, 0; 0 2]); %!test "no solution"; %! assert (all (isempty (infsup ([1, 0; 2, 0]) \ [3; 0]))); %!test "many solutions"; %! assert (infsup ([1, 0; 2, 0]) \ [4; 8] == infsup ([4; -inf], [4; inf])); %!assert (all (subset (infsup ([2, -1; -1, 2], [4, 1; 1, 4]) \ infsup ([-3; .8], [3; .8]), infsup ([-2.3; -1.1], [2.3; 1.6])))); interval-1.4.1/inst/@infsup/mpower.m0000644000000000000000000000633312657475772015572 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} mpower (@var{X}, @var{Y}) ## @defopx Operator {@@infsup} {@var{X} ^ @var{Y}} ## ## Return the matrix power operation of @var{X} raised to the @var{Y} power. ## ## If @var{X} is a scalar, this function and @code{power} are equivalent. ## Otherwise, @var{X} must be a square matrix and @var{Y} must be a single ## integer. ## ## Warning: This function is not defined by IEEE Std 1788-2015. ## ## Accuracy: The result is a valid enclosure. The result is tightest for ## @var{Y} in @{0, 1, 2@}. ## ## @example ## @group ## infsup (magic (3)) ^ 2 ## @result{} ans = 3×3 interval matrix ## [91] [67] [67] ## [67] [91] [67] ## [67] [67] [91] ## @end group ## @end example ## @seealso{@@infsup/pow, @@infsup/pown, @@infsup/pow2, @@infsup/pow10, @@infsup/exp} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-31 function result = mpower (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsup"))) x = infsup (x); endif if (isscalar (x)) ## Short-circuit for scalars result = power (x, y); return endif if (not (isreal (y)) || fix (y) ~= y) error ("interval:InvalidOperand", ... "mpower: only integral powers can be computed"); endif if (not (issquare (x.inf))) error ("interval:InvalidOperand", ... "mpower: must be square matrix"); endif ## Implements log-time algorithm A.1 in ## Heimlich, Oliver. 2011. “The General Interval Power Function.” ## Diplomarbeit, Institute for Computer Science, University of Würzburg. ## http://exp.ln0.de/heimlich-power-2011.htm. result = infsup (eye (length (x))); while (y ~= 0) if (rem (y, 2) == 0) # y is even [x.inf, x.sup] = mpfr_matrix_sqr_d (x.inf, x.sup); y /= 2; else # y is odd result = mtimes (result, x); if (all (all (isempty (result))) || all (all (isentire (result)))) ## We can stop the computation here, this is a fixed point break endif if (y > 0) y --; else y ++; if (y == 0) ## Inversion after computation of a negative power. ## Inversion should be the last step, because it is not ## tightest and would otherwise increase rounding errors. result = inv (result); endif endif endif endwhile endfunction %!xtest "from the documentation string"; %! assert (isequal (infsup (magic (3)) ^ 2, infsup (magic (3) ^ 2))); interval-1.4.1/inst/@infsup/mrdivide.m0000644000000000000000000000355212657475772016064 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} mrdivide (@var{X}, @var{Y}) ## @defopx Operator {@@infsup} {@var{X} / @var{Y}} ## ## Return the interval matrix right division of @var{X} and @var{Y}. ## ## Accuracy: The result is a valid enclosure. ## ## @example ## @group ## infsup ([1, 2; 3, 4]) / [3, 4; 1, 2] ## @result{} ans = 2×2 interval matrix ## [0] [1] ## [1] [0] ## @end group ## @end example ## @seealso{@@infsup/mtimes} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-31 function result = mrdivide (x, y) if (nargin ~= 2) print_usage (); return endif if (isa (y, "infsupdec")) if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif elseif (not (isa (x, "infsup"))) x = infsup (x); endif if (isa (x, "infsupdec")) if (not (isa (y, "infsupdec"))) y = infsupdec (y); endif elseif (not (isa (y, "infsup"))) y = infsup (y); endif if (isscalar (x) || isscalar (y)) result = rdivide (x, y); return endif result = mldivide (y', x')'; endfunction %!test "from the documentation string"; %! assert (infsup ([1, 2; 3, 4]) / [3, 4; 1, 2] == infsup ([0, 1; 1, 0])); interval-1.4.1/inst/@infsup/mtimes.m0000644000000000000000000001227412657475772015560 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} mtimes (@var{X}, @var{Y}) ## @defopx Method {@@infsup} mtimes (@var{X}, @var{Y}, @var{ACCURACY}) ## @defopx Operator {@@infsup} {@var{X} * @var{Y}} ## ## Compute the interval matrix multiplication. ## ## The @var{ACCURACY} can be set to @code{tight} (default) or @code{valid}. ## With @code{valid} accuracy an algorithm for fast matrix multiplication based ## on BLAS routines is used. The latter is published by ## Siegried M. Rump (2012), “Fast interval matrix multiplication,” ## Numerical Algorithms 61(1), 1-34. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## x = infsup ([1, 2; 7, 15], [2, 2; 7.5, 15]); ## y = infsup ([3, 3; 0, 1], [3, 3.25; 0, 2]); ## x * y ## @result{} ans = 2×2 interval matrix ## [3, 6] [5, 10.5] ## [21, 22.5] [36, 54.375] ## @end group ## @end example ## @seealso{@@infsup/mrdivide} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-31 function result = mtimes (x, y, accuracy) if (nargin < 2 || nargin > 3 || (nargin == 3 && not (ischar (accuracy)))) print_usage (); return endif if (not (isa (x, "infsup"))) x = infsup (x); endif if (not (isa (y, "infsup"))) y = infsup (y); elseif (isa (y, "infsupdec")) ## Workaround for bug #42735 result = mtimes (x, y); return endif if (isscalar (x) || isscalar (y)) result = times (x, y); return endif if (size (x.inf, 2) ~= size (y.inf, 1)) error ("interval:InvalidOperand", ... "operator *: nonconformant arguments"); endif if (nargin == 3) switch (accuracy) case "valid" ## Fast matrix multiplication uses rounding mode switches, which ## might not work on all systems. Thus, we validate whether the ## BLAS routines respect rounding modes correctly on the current ## platform and fall back to the slow implementation otherwise. persistent use_rounding_mode = check_rounding_mode (); if (use_rounding_mode) result = fast_mtimes (x, y); return else warning ('interval:rounding', ... ['mtimes: rounding modes not supported, falling ', ... 'back to slow but accurate matrix multiplication']); endif case "tight" ## Default mode otherwise print_usage(); return endswitch endif ## mtimes could also be computed with a for loop and the dot operation. ## However, that would take significantly longer (loop + missing JIT-compiler, ## several OCT-file calls), so we use an optimized ## OCT-file for that particular operation. [l, u] = mpfr_matrix_mul_d (x.inf, y.inf, x.sup, y.sup); result = infsup (l, u); endfunction function C = fast_mtimes (A, B) ## Implements Algorithm 4.8 ## IImul7: interval interval multiplication with 7 point matrix multiplications ## Rump, Siegried M. 2012. “Fast interval matrix multiplication.” ## Numerical Algorithms 61(1), 1-34. ## http://www.ti3.tu-harburg.de/paper/rump/Ru11a.pdf. ## ## Although this is the slowest of the published fast algorithms, it is the ## most accurate. [mA, rA] = rad (A); [mB, rB] = rad (B); rhoA = sign (mA) .* min (abs (mA), rA); rhoB = sign (mB) .* min (abs (mB), rB); unwind_protect __setround__ (+inf); rC = abs (mA) * rB + rA * (abs (mB) + rB) + (-abs (rhoA)) * abs (rhoB); u = mA * mB + rhoA * rhoB + rC; __setround__ (-inf); l = mA * mB + rhoA * rhoB - rC; unwind_protect_cleanup __setround__ (0.5); # restore default rounding mode (to nearest) end_unwind_protect C = infsup (l, u); endfunction function works = check_rounding_mode () try unwind_protect works = true (); __setround__ (+inf); works &= (1 + realmin > 1); works &= ([1 1 -1] * [1; realmin; realmin] > 1); __setround__ (-inf); works &= (1 + realmin == 1); works &= ([1 1 -1] * [1; realmin; realmin] < 1); unwind_protect_cleanup __setround__ (0.5); end_unwind_protect catch works = false (); end_try_catch endfunction %!test "from the documentation string"; %! assert (infsup ([1, 2; 7, 15], [2, 2; 7.5, 15]) * infsup ([3, 3; 0, 1], [3, 3.25; 0, 2]) == infsup ([3, 5; 21, 36], [6, 10.5; 22.5, 54.375])); %!test "matrix multiplication using BLAS routines"; %! assert (mtimes (infsup ([1, 2; 7, 15], [2, 2; 7.5, 15]), infsup ([3, 3; 0, 1], [3, 3.25; 0, 2]), 'valid') == infsup ([3, 5; 21, 36], [6, 10.5; 22.5, 54.375])); interval-1.4.1/inst/@infsup/mulrev.m0000644000000000000000000001672212657475772015576 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {@var{X} =} mulrev (@var{B}, @var{C}, @var{X}) ## @deftypemethodx {@@infsup} {@var{X} =} mulrev (@var{B}, @var{C}) ## @deftypemethodx {@@infsup} {[@var{U}, @var{V}] =} mulrev (@var{B}, @var{C}) ## @deftypemethodx {@@infsup} {[@var{U}, @var{V}] =} mulrev (@var{B}, @var{C}, @var{X}) ## ## Compute the reverse multiplication function or the two-output division. ## ## That is, an enclosure of all @code{x ∈ @var{X}} where ## @code{x .* b ∈ @var{C}} for any @code{b ∈ @var{B}}. ## ## This function is similar to interval division @code{@var{C} ./ @var{B}}. ## However, it treats the case 0/0 as “any real number” instead of “undefined”. ## ## Interval division, considered as a set, can have zero, one or two disjoint ## connected components as a result. If called with two output parameters, ## this function returns the components separately. @var{U} contains the ## negative or unique component, whereas @var{V} contains the positive ## component in cases with two components. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## c = infsup (1); ## b = infsup (-inf, inf); ## [u, v] = mulrev (b, c) ## @result{} ## u = [-Inf, 0] ## v = [0, Inf] ## @end group ## @end example ## @seealso{@@infsup/times} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function [u, v] = mulrev (b, c, x) if (nargin < 2 || nargin > 3) print_usage (); return endif if (nargin < 3) x = infsup (-inf, inf); endif if (not (isa (b, "infsup"))) b = infsup (b); endif if (not (isa (c, "infsup"))) c = infsup (c); endif if (not (isa (x, "infsup"))) x = infsup (x); endif ## Resize, if scalar × matrix or vector × matrix or scalar × vector if (rows (b.inf) ~= rows (c.inf)) b.inf = ones (rows (c.inf), columns (b.inf)) .* b.inf; b.sup = ones (rows (c.inf), columns (b.inf)) .* b.sup; c.inf = ones (rows (b.inf), columns (c.inf)) .* c.inf; c.sup = ones (rows (b.inf), columns (c.inf)) .* c.sup; endif if (columns (b.inf) ~= columns (c.inf)) b.inf = ones (rows (b.inf), columns (c.inf)) .* b.inf; b.sup = ones (rows (b.inf), columns (c.inf)) .* b.sup; c.inf = ones (rows (c.inf), columns (b.inf)) .* c.inf; c.sup = ones (rows (c.inf), columns (b.inf)) .* c.sup; endif u.inf = v.inf = inf (size (b.inf)); u.sup = v.sup = -inf (size (b.inf)); emptyresult = b.inf == inf | c.inf == inf ... | (b.inf == 0 & b.sup == 0 & (c.sup < 0 | c.inf > 0)); # x * 0 ~= 0 twocomponents = b.inf < 0 & b.sup > 0 & not (emptyresult) & ... (c.sup < 0 | c.inf > 0); onecomponent = not (twocomponents) & not (emptyresult); u.inf (twocomponents) = -inf; v.sup (twocomponents) = inf; dom = twocomponents & c.inf <= 0 & c.sup >= 0; u.sup (dom) = v.inf (dom) = 0; dom = twocomponents & c.inf > 0; if (not (isempty (dom))) u.sup (dom) = mpfr_function_d ('rdivide', +inf, c.inf (dom), b.inf (dom)); v.inf (dom) = mpfr_function_d ('rdivide', -inf, c.inf (dom), b.sup (dom)); endif dom = twocomponents & c.sup < 0; if (not (isempty (dom))) u.sup (dom) = mpfr_function_d ('rdivide', +inf, c.sup (dom), b.sup (dom)); v.inf (dom) = mpfr_function_d ('rdivide', -inf, c.sup (dom), b.inf (dom)); endif dom = onecomponent & b.inf >= 0 & c.inf >= 0; if (not (isempty (dom))) b.inf (dom & b.inf == 0) = +0; c.inf (dom & c.inf == 0) = +0; u.inf (dom) = mpfr_function_d ('rdivide', -inf, c.inf (dom), b.sup (dom)); u.sup (dom) = mpfr_function_d ('rdivide', +inf, c.sup (dom), b.inf (dom)); endif dom = onecomponent & b.sup <= 0 & c.inf >= 0; if (not (isempty (dom))) b.sup (dom & b.sup == 0) = -0; c.inf (dom & c.inf == 0) = +0; u.inf (dom) = mpfr_function_d ('rdivide', -inf, c.sup (dom), b.sup (dom)); u.sup (dom) = mpfr_function_d ('rdivide', +inf, c.inf (dom), b.inf (dom)); endif dom = onecomponent & b.inf >= 0 & c.sup <= 0; if (not (isempty (dom))) b.inf (dom & b.inf == 0) = +0; c.sup (dom & c.sup == 0) = -0; u.inf (dom) = mpfr_function_d ('rdivide', -inf, c.inf (dom), b.inf (dom)); u.sup (dom) = mpfr_function_d ('rdivide', +inf, c.sup (dom), b.sup (dom)); endif dom = onecomponent & b.sup <= 0 & c.sup <= 0; if (not (isempty (dom))) b.sup (dom & b.sup == 0) = -0; c.sup (dom & c.sup == 0) = -0; u.inf (dom) = mpfr_function_d ('rdivide', -inf, c.sup (dom), b.inf (dom)); u.sup (dom) = mpfr_function_d ('rdivide', +inf, c.inf (dom), b.sup (dom)); endif dom = onecomponent & c.inf < 0 & c.sup > 0 & b.inf > 0; if (not (isempty (dom))) u.inf (dom) = mpfr_function_d ('rdivide', -inf, c.inf (dom), b.inf (dom)); u.sup (dom) = mpfr_function_d ('rdivide', +inf, c.sup (dom), b.inf (dom)); endif dom = onecomponent & c.inf < 0 & c.sup > 0 & b.sup < 0; if (not (isempty (dom))) u.inf (dom) = mpfr_function_d ('rdivide', -inf, c.sup (dom), b.sup (dom)); u.sup (dom) = mpfr_function_d ('rdivide', +inf, c.inf (dom), b.sup (dom)); endif dom = onecomponent & b.inf <= 0 & b.sup >= 0 & c.inf <= 0 & c.sup >= 0; # x * 0 == 0 u.inf (dom) = -inf; u.sup (dom) = inf; ## Intersect u and v with x (don't do this with infsup objects, for performance ## reasons). u.inf = max (u.inf, x.inf); u.sup = min (u.sup, x.sup); v.inf = max (v.inf, x.inf); v.sup = min (v.sup, x.sup); if (nargout < 2) u.inf (twocomponents) = min (u.inf (twocomponents), v.inf (twocomponents)); u.sup (twocomponents) = max (u.sup (twocomponents), v.sup (twocomponents)); emptyresult = u.inf > u.sup; u.inf (emptyresult) = inf; u.sup (emptyresult) = -inf; u = infsup (u.inf, u.sup); else empty_u = u.inf > u.sup; u.inf (empty_u) = inf; u.sup (empty_u) = -inf; u = infsup (u.inf, u.sup); empty_v = v.inf > v.sup; v.inf (empty_v) = inf; v.sup (empty_v) = -inf; v = infsup (v.inf, v.sup); ## It can happen that the twocomponents result has only one component, ## because x is positive for example. Then, only one component shall be ## returned swap = twocomponents & isempty (u) & not (isempty (v)); [u.inf(swap), u.sup(swap), v.inf(swap), v.sup(swap)] = deal (... v.inf (swap), v.sup (swap), u.inf (swap), u.sup (swap)); endif endfunction %!test "IEEE Std 1788-2015 mulRevToPair examples"; %! [u, v] = mulrev (infsup (0), infsup (1, 2)); %! assert (isempty (u) & isempty (v)); %! [u, v] = mulrev (infsup (0), infsup (0, 1)); %! assert (isentire (u) & isempty (v)); %! [u, v] = mulrev (infsup (1), infsup (1, 2)); %! assert (eq (u, infsup (1, 2)) & isempty (v)); %! [u, v] = mulrev (infsup (1, inf), infsup (1)); %! assert (eq (u, infsup (0, 1)) & isempty (v)); %! [u, v] = mulrev (infsup (-1, 1), infsup (1, 2)); %! assert (eq (u, infsup (-inf, -1)) & eq (v, infsup (1, inf))); %! [u, v] = mulrev (infsup (-inf, inf), infsup (1)); %! assert (eq (u, infsup (-inf, 0)) & eq (v, infsup (0, inf))); interval-1.4.1/inst/@infsup/ndims.m0000644000000000000000000000252712657475772015374 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} ndims (@var{A}) ## ## Return the number of dimensions of @var{A}. ## ## For any array, the result will always be larger than or equal to 2. ## Trailing singleton dimensions are not counted. ## @seealso{@@infsup/length, @@infsup/numel, @@infsup/size, @@infsup/rows, @@infsup/columns} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-29 function result = ndims (a) if (nargin ~= 1) print_usage (); return endif result = ndims (a.inf); endfunction %!assert (ndims (infsup ([])), 2); %!assert (ndims (infsup (0)), 2); %!assert (ndims (infsup (magic (3))), 2); interval-1.4.1/inst/@infsup/ne.m0000644000000000000000000000267312657475772014666 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} ne (@var{A}, @var{B}) ## @defopx Operator {@@infsup} {@var{A} ~= @var{B}} ## @defopx Operator {@@infsup} {@var{A} != @var{B}} ## ## Compare intervals @var{A} and @var{B} for inequality. ## ## True, if @var{A} contains a number which is not a member in @var{B} or vice ## versa. False, if all numbers from @var{A} are also contained in @var{B} and ## vice versa. ## ## @seealso{@@infsup/eq, @@infsup/subset, @@infsup/interior, @@infsup/disjoint} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-30 function result = ne (a, b) if (nargin ~= 2) print_usage (); return endif result = not (eq (a, b)); endfunction %!assert (ne (infsup (1, 2), infsup (1, 3))); interval-1.4.1/inst/@infsup/newdec.m0000644000000000000000000000343512657475772015526 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} newdec (@var{X}) ## ## Create a decorated interval from a bare interval. ## ## The decorated interval will carry the best possible decoration, i. e., ## @code{trv} for empty intervals, @code{dac} for unbound intervals, and ## @code{com} for common intervals. ## ## If @var{X} already is decorated, nothing happens. In particular, the ## decoration will not be changed in order to not lose any information. ## ## @example ## @group ## newdec (infsup (2, 3)) ## @result{} ans = [2, 3]_com ## @end group ## @end example ## @seealso{@@infsupdec/infsupdec} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-12 function xd = newdec (x) if (nargin ~= 1) print_usage (); return endif warning ("off", "interval:ImplicitPromote", "local"); xd = infsupdec (x); endfunction %!test "from the documentation string"; %! assert (isequal (newdec (infsup (2, 3)), infsupdec (2, 3))); %!assert (isequal (newdec (infsupdec (2, 3)), infsupdec (2, 3))); %!assert (isequal (newdec (infsupdec (1, "trv")), infsupdec (1, "trv"))); interval-1.4.1/inst/@infsup/nextout.m0000644000000000000000000000301612657475772015762 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} nextout (@var{X}) ## ## Increases the interval's boundaries in each direction to the next number. ## ## This is the equivalent function to IEEE 754's nextDown and nextUp. ## ## @example ## @group ## x = infsup (1); ## nextout (x) == infsup (1 - eps / 2, 1 + eps) ## @result{} ans = 1 ## @end group ## @end example ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-30 function result = nextout (x) if (nargin ~= 1) print_usage (); return endif delta = pow2 (-1074); l = mpfr_function_d ('minus', -inf, x.inf, delta); u = mpfr_function_d ('plus', +inf, x.sup, delta); result = infsup (l, u); endfunction %!test "from the documentation string"; %! x = nextout (infsup (1)); %! assert (inf (x), 1 - eps / 2); %! assert (sup (x), 1 + eps); interval-1.4.1/inst/@infsup/norm.m0000644000000000000000000001007712657475772015234 0ustar 00000000000000## Copyright 2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} norm (@var{A}, @var{P}) ## @defmethodx {@@infsup} norm (@var{A}, @var{P}, @var{OPT}) ## ## Compute the p-norm of the matrix @var{A}. ## ## If @var{A} is a matrix: ## @table @asis ## @item @var{P} = 1 ## 1-norm, the largest column sum of the absolute values of @var{A}. ## @item @var{P} = inf ## Infinity norm, the largest row sum of the absolute values of @var{A}. ## @item @var{P} = "fro" ## Frobenius norm of @var{A}, @code{sqrt (sum (diag (A' * A)))}. ## @end table ## ## If @var{A} is a vector or a scalar: ## @table @asis ## @item @var{P} = inf ## @code{max (abs (A))}. ## @item @var{P} = -inf ## @code{min (abs (A))}. ## @item @var{P} = "fro" ## Frobenius norm of @var{A}, @code{sqrt (sumsq (abs (A)))}. ## @item @var{P} = 0 ## Hamming norm - the number of nonzero elements. ## @item other @var{P}, @code{@var{P} > 1} ## p-norm of @var{A}, @code{(sum (abs (A) .^ P)) ^ (1/P)}. ## @item other @var{P}, @code{@var{P} < 1} ## p-pseudonorm defined as above. ## @end table ## ## If @var{OPT} is the value "rows", treat each row as a vector and compute its ## norm. The result returned as a column vector. Similarly, if @var{OPT} is ## "columns" or "cols" then compute the norms of each column and return a row ## vector. ## ## Accuracy: The result is a valid enclosure. ## ## @example ## @group ## norm (infsup (magic (3)), "fro") ## @result{} ans ⊂ [16.881, 16.882] ## @end group ## @group ## norm (infsup (magic (3)), 1, "cols") ## @result{} ans = 1×3 interval vector ## ## [15] [15] [15] ## ## @end group ## @end example ## @seealso{@@infsup/abs, @@infsup/max} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2016-01-26 function result = norm (A, p, opt) if (nargin > 3 || not (isa (A, "infsup"))) print_usage (); return endif if (isa (A, "infsupdec")) if (isnai (A)) result = A; return endif endif if (nargin < 2) p = 2; opt = ""; elseif (nargin < 3) opt = ""; endif switch (opt) case "rows" dim = 2; case {"columns", "cols"} dim = 1; case "" if (isvector (A.inf)) ## Try to find non-singleton dimension dim = find (size (A.inf) > 1, 1); if (isempty (dim)) dim = 1; endif else dim = []; endif endswitch if (isempty (dim)) ## Matrix norm switch (p) case 1 result = max (sum (abs (A), 1)); case inf result = max (sum (abs (A), 2)); case "fro" result = sqrt (sumsq (vec (A))); otherwise error ("norm: Particular matrix norm is not yet supported") endswitch else ## Vector norm switch (p) case inf result = max (abs (A), [], dim); case -inf result = min (abs (A), [], dim); case "fro" result = sqrt (sumsq (abs (A), dim)); case 0 result = infsup (sum (not (ismember (0, A)), dim), ... sum (0 != A, dim)) - ... sum (isempty (A), dim); otherwise warning ("off", "interval:ImplicitPromote", "local"); result = (sum (abs (A) .^ p, dim)) .^ (1 ./ infsup (p)); endswitch endif endfunction %!xtest %! A = infsup ("0 [Empty] [0, 1] 1"); %! assert (isequal (norm (A, 0, "cols"), infsup ("0 0 [0, 1] 1"))); interval-1.4.1/inst/@infsup/nthroot.m0000644000000000000000000001303312657475772015751 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} nthroot (@var{X}, @var{N}) ## ## Compute the real n-th root of @var{X}. ## ## Accuracy: The result is a valid enclosure. The result is a tight ## enclosure for @var{n} ≥ -2. The result also is a tight enclosure if the ## reciprocal of @var{n} can be computed exactly in double-precision. ## @seealso{@@infsup/pown, @@infsup/pownrev, @@infsup/realsqrt, @@infsup/cbrt} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-20 function result = nthroot (x, n) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsup"))) x = infsup (x); endif if (not (isnumeric (n)) || fix (n) ~= n) error ("interval:InvalidOperand", "nthroot: degree is not an integer"); endif even = mod (n, 2) == 0; if (even) x = intersect (x, infsup (0, inf)); endif switch sign (n) case +1 emptyresult = isempty (x); l = mpfr_function_d ('nthroot', -inf, x.inf, n); u = mpfr_function_d ('nthroot', +inf, x.sup, n); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); case -1 emptyresult = isempty (x) ... | (x.sup <= 0 & even) | (x.inf == 0 & x.sup == 0); if (even) l = zeros (size (x.inf)); u = inf (size (x.inf)); select = x.inf > 0 & isfinite (x.inf); if (any (any (select))) u (select) = invrootrounded (x.inf (select), -n, +inf); endif select = x.sup > 0 & isfinite (x.sup); if (any (any (select))) l (select) = invrootrounded (x.sup (select), -n, -inf); endif l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); else # uneven l = zeros (size (x.inf)); u = inf (size (x.inf)); select = x.inf > 0 & isfinite (x.inf); if (any (any (select))) u (select) = invrootrounded (x.inf (select), -n, +inf); endif select = x.sup > 0 & isfinite (x.sup); if (any (any (select))) l (select) = invrootrounded (x.sup (select), -n, -inf); endif notpositive = x.sup <= 0; l (emptyresult | notpositive) = inf; u (emptyresult | notpositive) = -inf; result = infsup (l, u); # this is only the positive part l = zeros (size (x.inf)); u = inf (size (x.inf)); select = x.sup < 0 & isfinite (x.sup); if (any (any (select))) u (select) = invrootrounded (-x.sup (select), -n, +inf); endif select = x.inf < 0 & isfinite (x.inf); if (any (any (select))) l (select) = invrootrounded (-x.inf (select), -n, -inf); endif notnegative = x.inf >= 0; l (emptyresult | notnegative) = inf; u (emptyresult | notnegative) = -inf; result = union (result, infsup (-u, -l)); endif otherwise error ("interval:InvalidOperand", "nthroot: degree must not be zero"); endswitch endfunction function x = invrootrounded (z, n, direction) ## We cannot compute the inverse of the n-th root of z in a single step. ## Thus, we use three different ways for computation, each of which has an ## intermediate result with possible rounding errors and can't guarantee to ## produce a correctly rounded result. ## When we finally merge the 3 results, it is still not guaranteed to be ## correctly rounded. However, chances are good that one of the three ways ## produced a “relatively good” result. ## ## x1: z ^ (- 1 / n) ## x2: 1 / root (z, n) ## x3: root (1 / z, n) inv_n = 1 ./ infsup (n); if (direction > 0) x1 = z; select = z > 1; x1 (select) = mpfr_function_d ('pow', direction, z (select), -inv_n.inf); select = z < 1; x1 (select) = mpfr_function_d ('pow', direction, z (select), -inv_n.sup); else x1 = z; select = z > 1; x1 (select) = mpfr_function_d ('pow', direction, z (select), -inv_n.sup); select = z < 1; x1 (select) = mpfr_function_d ('pow', direction, z (select), -inv_n.inf); endif if (issingleton (inv_n)) ## We are lucky: The result is correctly rounded x = x1; return endif x2 = mpfr_function_d ('rdivide', direction, 1, ... mpfr_function_d ('nthroot', -direction, z, n)); x3 = mpfr_function_d ('nthroot', direction, ... mpfr_function_d ('rdivide', direction, 1, z), n); ## Choose the most accurate result if (direction > 0) x = min (min (x1, x2), x3); else x = max (max (x1, x2), x3); endif endfunction %!assert (nthroot (infsup (25, 36), 2) == infsup (5, 6)); interval-1.4.1/inst/@infsup/numel.m0000644000000000000000000000247312657475772015402 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} numel (@var{A}) ## ## Return the number of elements in the interval object @var{A}. ## @seealso{@@infsup/length, @@infsup/size, @@infsup/rows, @@infsup/columns} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-29 function result = numel (a) if (nargin ~= 1) print_usage (); return endif result = numel (a.inf); endfunction %!assert (numel (infsup ([])), 0); %!assert (numel (infsup (0)), 1); %!assert (numel (infsup (zeros (3, 1))), 3); %!assert (numel (infsup (zeros (1, 4))), 4); %!assert (numel (infsup (zeros (3, 4))), 12); interval-1.4.1/inst/@infsup/overlap.m0000644000000000000000000001107612657475772015731 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {[@var{STATE}, @var{BITMASK}] =} overlap(@var{A}, @var{B}) ## ## Extensively compare the positions of intervals @var{A} and @var{B} on the ## real number line. ## ## Return the @var{STATE} as a string and the @var{BITMASK} of the state as an ## uint16 number, which represents one of the 16 possible states by taking a ## value 2^i (i = 0 … 15). ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## @table @asis ## @item @code{bothEmpty}, 2^0 ## Both intervals are empty ## @item @code{firstEmpty}, 2^1 ## Interval @var{A} is empty and @var{B} is not ## @item @code{secondEmpty}, 2^2 ## Interval @var{A} is not empty, but @var{B} is ## @item @code{before}, 2^3 ## [- - - @var{A} - - -]@ @ @ [- - - @var{B} - - -] ## @item @code{meets}, 2^4 ## [- - - @var{A} - - -][- - - @var{B} - - -] ## @*Interval @var{A}'s upper boundary equals interval @var{B}'s lower boundary ## and neither consists of a single point only. ## @item @code{overlaps}, 2^5 ## [- - - @var{A} - - - [= = =] - - - @var{B} - - -] ## @item @code{starts}, 2^6 ## [[= = = @var{A} = = =] - - - @var{B} - - -] ## @item @code{containedBy}, 2^7 ## [- - - @var{B} - - - [= = = @var{A} = = =] - - -] ## @item @code{finishes}, 2^8 ## [- - - @var{B} - - - [= = = @var{A} = = =]] ## @item @code{equals}, 2^9 ## Both intervals are equal (and not empty) ## @item @code{finishedBy}, 2^10 ## [- - - @var{A} - - - [= = = @var{B} = = =]] ## @item @code{contains}, 2^11 ## [- - - @var{A} - - - [= = = @var{B} = = =] - - -] ## @item @code{startedBy}, 2^12 ## [[= = = @var{B} = = =] - - - @var{A} - - -] ## @item @code{overlappedBy}, 2^13 ## [- - - @var{B} - - - [= = =] - - - @var{A} - - -] ## @item @code{metBy}, 2^14 ## [- - - @var{B} - - -][- - - @var{A} - - -] ## @*Interval @var{A}'s lower boundary equals interval @var{B}'s upper boundary ## and neither consists of a single point only. ## @item @code{after}, 2^15 ## [- - - @var{B} - - -]@ @ @ [- - - @var{A} - - -] ## @end table ## ## @seealso{@@infsup/eq, @@infsup/subset, @@infsup/interior, @@infsup/disjoint} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-04 function [state, bitmask] = overlap (a, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (a, "infsup"))) a = infsup (a); endif if (not (isa (b, "infsup"))) b = infsup (b); endif emptya = isempty (a); emptyb = isempty (b); notempty = not (emptya | emptyb); comparison = {... "bothEmpty", (emptya & emptyb); ... "firstEmpty", (emptya & not (emptyb)); ... "secondEmpty", (emptyb & not (emptya)); ... "before", (notempty & a.sup < b.inf); ... "meets", (notempty & a.inf < a.sup & a.sup == b.inf & b.inf < b.sup); ... "overlaps", (notempty & a.inf < b.inf & b.inf < a.sup & a.sup < b.sup); ... "starts", (notempty & a.inf == b.inf & a.sup < b.sup); ... "containedBy", (notempty & b.inf < a.inf & a.sup < b.sup); ... "finishes", (notempty & b.inf < a.inf & a.sup == b.sup); ... "equals", (notempty & a.inf == b.inf & a.sup == b.sup); ... "finishedBy", (notempty & a.inf < b.inf & b.sup == a.sup); ... "contains", (notempty & a.inf < b.inf & b.sup < a.sup); ... "startedBy", (notempty & b.inf == a.inf & b.sup < a.sup); ... "overlappedBy", ... (notempty & b.inf < a.inf & a.inf < b.sup & b.sup < a.sup); ... "metBy", (notempty & b.inf < b.sup & b.sup == a.inf & a.inf < a.sup); ... "after", (notempty & b.sup < a.inf)}; if (nargout >= 2) bitmask = zeros (size (comparison {1, 2}), "uint16"); for i = 1 : rows (comparison) bitmask (comparison {i, 2}) = pow2 (16 - i); endfor endif state = cell (size (comparison {1, 2})); for i = 1 : rows (comparison) state (comparison {i, 2}) = comparison {i, 1}; endfor if (numel (state) == 1) state = state {1}; endif endfunction %!assert (overlap (infsup (1, 2), infsup (3, 4)), "before"); interval-1.4.1/inst/@infsup/plot.m0000644000000000000000000001201112657475772015225 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} plot (@var{X}, @var{Y}) ## @defmethodx {@@infsup} plot (@var{Y}) ## @defmethodx {@@infsup} plot (@var{X}, @var{Y}, @var{COLOR}) ## @defmethodx {@@infsup} plot (@var{X}, @var{Y}, @var{COLOR}, @var{EDGECOLOR}) ## ## Create a 2D-plot of intervals. ## ## If either of @var{X} or @var{Y} is an empty interval, nothing is plotted. ## If both @var{X} and @var{Y} are singleton intervals, a single point is ## plotted. If only one of @var{X} and @var{Y} is a singleton interval, a ## single line is plotted. If neither of @var{X} and @var{Y} is a singleton ## interval, a filled rectangle is plotted. ## ## If @var{X} or @var{Y} are matrices, each pair of elements is plotted ## separately. No connection of the interval areas is plotted, because that ## kind of interpolation would be wrong in general (in the sense that the ## actual values are enclosed by the plot). ## ## Without parameter @var{X}, the intervals in @var{Y} are plotted as points or ## lines, which are parallel to the y axis, at the coordinates ## @code{@var{X} = [1, …, n]}. ## ## If no @var{COLOR} is given, the current @command{colormap} is used. Use ## @var{COLOR} = @option{none} to disable plotting of filled rectangles. If an ## optional parameter @var{EDGECOLOR} is given, rectangles will have visible ## edges in a distinct color. ## ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-05-10 function plot (x, y, color, edgecolor) if (nargin > 4) print_usage (); return endif warning ("off", "interval:ImplicitPromote", "local"); if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (nargin >= 2 && not (isa (y, "infsupdec"))) y = infsupdec (y); endif if (isnai (x) || (nargin >= 2 && isnai (y))) error ("interval:NaI", "Cannot plot NaIs"); return endif if (nargin < 2) y = x; ## x = 1 ... n x = infsupdec (reshape (1 : numel (y.inf), size (y.inf))); endif if (nargin < 3 || isempty (color)) # don't use last row of colormap, which would often be just white color = colormap ()(ceil (rows (colormap ()) / 2), :); if (nargin < 4) # will only be used for lines and dots edgecolor = colormap ()(1, :); endif elseif (nargin < 4) # will only be used for lines and dots edgecolor = color; endif oldhold = ishold (); if (not (oldhold)) clf hold on endif pointsize = 3; edgewidth = 2; unwind_protect empty = isempty (x) | isempty (y); points = issingleton (x) & issingleton (y); lines = xor (issingleton (x), issingleton (y)) & not (empty); boxes = not (points | lines | empty); if (any (any (points))) scatter (x.inf (points), y.inf (points), ... pointsize, ... edgecolor, ... 'filled'); endif if (any (any (lines))) x_line = [vec(x.inf (lines)), vec(x.sup (lines))]'; y_line = [vec(y.inf (lines)), vec(y.sup (lines))]'; plot (x_line, y_line, ... 'color', edgecolor, ... 'linewidth', edgewidth); endif if (any (any (boxes))) x_box = [vec(x.inf (boxes)), vec(x.sup (boxes))] (:, [1 2 2 1])'; y_box = [vec(y.inf (boxes)), vec(y.sup (boxes))] (:, [1 1 2 2])'; if (nargin < 4) edgecolor = 'none'; endif fill (x_box, y_box, [], ... 'linewidth', edgewidth, ... 'edgecolor', edgecolor, ... 'facecolor', color); endif unwind_protect_cleanup ## Reset hold state if (not (oldhold)) hold off endif end_unwind_protect endfunction %!test "this test is rather pointless"; %! clf %! plot (empty ()); %! close %!demo %! clf %! hold on %! plot (infsup (0), infsup (0)); %! plot (infsup (1, 2), infsup (0)); %! plot (infsup (0), infsup (1, 2)); %! plot (infsup (1, 2), infsup (1, 2)); %! axis ([-.5, 2.5, -.5, 2.5]); %! hold off %!demo %! clf %! plot (infsup (-rand (50, 1), +rand (50, 1))); %!demo %! clf %! hold on %! axis off %! range = infsup (0, 9); %! x = linspace (inf (range), sup (range), 250); %! X = mince (range, 9); %! f = @ (x) 0.5 * sin (x) .* x .^ 2; %! y = f (x); %! Y = f (X); %! plot (range, f (range), [42 161 152]/255); %! plot (X, Y, [238 232 213]/255, [88 110 117]/255); %! plot (x, y, '-', 'color', [220 50 47]/255, 'linewidth', 2); %! hold off interval-1.4.1/inst/@infsup/plot3.m0000644000000000000000000001705712657475772015327 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} plot3 (@var{X}, @var{Y}, @var{Z}) ## @defmethodx {@@infsup} plot3 (@var{X}, @var{Y}, @var{Z}, @var{COLOR}) ## @defmethodx {@@infsup} plot3 (@var{X}, @var{Y}, @var{Z}, @var{COLOR}, @var{EDGECOLOR}) ## ## Create a 3D-plot of intervals. ## ## If either of @var{X}, @var{Y} or @var{Z} is an empty interval, nothing is ## plotted. If all are singleton intervals, a single point is plotted. If ## two intervals are a singleton interval, a line is plotted. If one interval ## is a singleton interval, a rectangle is plotted. If neither of @var{X}, ## @var{Y} and @var{Z} is a singleton interval, a cuboid is plotted. ## ## When interval matrices of equal size are given, each triple of elements is ## printed separately. ## ## No connection of the interval areas is plotted, because that kind of ## interpolation would be wrong in general (in the sense that the actual values ## are enclosed by the plot). ## ## If no @var{COLOR} is given, the current @command{colormap} is used. Use ## @var{COLOR} = @option{none} to disable plotting of filled rectangles. If an ## optional parameter @var{EDGECOLOR} is given, rectangles and cuboids will ## have visible edges in a distinct color. ## ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-05-17 function plot3 (x, y, z, color, edgecolor) if (nargin < 3 || nargin > 5) print_usage (); return endif warning ("off", "interval:ImplicitPromote", "local"); if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (not (isa (y, "infsupdec"))) y = infsupdec (y); endif if (not (isa (z, "infsupdec"))) z = infsupdec (z); endif if (isnai (x) || isnai (y) || isnai (z)) error ("interval:NaI", "Cannot plot3 NaIs"); return else x = intervalpart (x); y = intervalpart (y); z = intervalpart (z); endif if (nargin < 4 || isempty (color)) color = 'interp'; if (nargin < 5) # will only be used for lines and dots edgecolor = colormap ()(1, :); endif elseif (nargin < 5) # will only be used for lines and dots edgecolor = color; endif oldhold = ishold (); if (not (oldhold)) clf hold on endif pointsize = 3; edgewidth = 2; unwind_protect empty = isempty (x) | isempty (y) | isempty (z); number_of_singletons = issingleton (x) + issingleton (y) + issingleton (z); points = number_of_singletons == 3; lines = number_of_singletons == 2 & not (empty); boxes = number_of_singletons <= 1 & not (empty); if (any (any (points))) scatter3 (x.inf (points), y.inf (points), z.inf (points), ... pointsize, ... edgecolor, ... 'filled'); endif if (any (any (lines))) x_line = [vec(x.inf (lines)), vec(x.sup (lines))]'; y_line = [vec(y.inf (lines)), vec(y.sup (lines))]'; z_line = [vec(z.inf (lines)), vec(z.sup (lines))]'; plot3 (x_line, y_line, z_line, ... 'linewidth', edgewidth, ... 'color', edgecolor); endif ## + z ## | ## ## B--------D ## /| /| ## / | / | ## / A-----/--C -+ ## F--------H / y ## | / | / ## |/ |/ ## E--------G ## ## / ## + x ## The variables A through H help indexing the relevant rows in vertices. [A, B, C, D, E, F, G, H] = num2cell ((0 : 7) * sum (sum (boxes))) {:}; vertices = [vec(x.inf (boxes)), vec(y.inf (boxes)), vec(z.inf (boxes)); ... vec(x.inf (boxes)), vec(y.inf (boxes)), vec(z.sup (boxes)); ... vec(x.inf (boxes)), vec(y.sup (boxes)), vec(z.inf (boxes)); ... vec(x.inf (boxes)), vec(y.sup (boxes)), vec(z.sup (boxes)); ... vec(x.sup (boxes)), vec(y.inf (boxes)), vec(z.inf (boxes)); ... vec(x.sup (boxes)), vec(y.inf (boxes)), vec(z.sup (boxes)); ... vec(x.sup (boxes)), vec(y.sup (boxes)), vec(z.inf (boxes)); ... vec(x.sup (boxes)), vec(y.sup (boxes)), vec(z.sup (boxes))]; if (any (any (boxes))) faces = zeros (0, 4); ## x-y rectangle at z.inf select = vec (find (x.inf (boxes) < x.sup (boxes) & ... y.inf (boxes) < y.sup (boxes))); faces = [faces; ... A+select, C+select, G+select, E+select]; ## x-z rectangle at y.inf select = vec (find (x.inf (boxes) < x.sup (boxes) & ... z.inf (boxes) < z.sup (boxes))); faces = [faces; ... A+select, E+select, F+select, B+select]; ## y-z rectangle at x.inf select = vec (find (y.inf (boxes) < y.sup (boxes) & ... z.inf (boxes) < z.sup (boxes))); faces = [faces; ... A+select, B+select, D+select, C+select]; ## The cuboids have 6 sides instead of only one select = vec (find (x.inf (boxes) < x.sup (boxes) & ... y.inf (boxes) < y.sup (boxes) & ... z.inf (boxes) < z.sup (boxes))); faces = [faces; ... ## x-y rectangle at z.sup B+select, F+select, H+select, D+select; ... ## x-z rectangle at y.sup C+select, D+select, H+select, G+select; ... ## y-z rectangle at x.inf E+select, G+select, H+select, F+select]; if (nargin < 5) edgecolor = 'none'; endif if (isempty (color)) color = 'none'; endif patch ('Vertices', vertices, ... 'Faces', faces, ... 'EdgeColor', edgecolor, ... 'LineWidth', edgewidth, ... 'FaceColor', color, ... 'FaceVertexCData', vertices (:, 3)); endif unwind_protect_cleanup ## Reset hold state if (not (oldhold)) hold off endif end_unwind_protect endfunction %!test "this test is rather pointless"; %! clf %! plot3 (empty (), empty (), empty ()); %! close %!demo %! clf %! colormap hot %! x = y = z = (1 : 3) + infsup ("[0, 1]"); %! plot3 (x, y, z); %! view (300, 30) %! grid on %!demo %! clf %! colormap jet %! z = 1 : 8; %! x = y = infsup ("[-1, 1]") ./ z; %! plot3 (x, y, z); %! view (33, 24) %! grid on %!demo %! clf %! [x, y] = meshgrid (mince (infsup ("[-5, 5]"), 20), ... %! mince (infsup ("[0.1, 5]"), 10)); %! z = log (hypot (x, y)); %! blue = [38 139 210]/255; base2 = [238 232 213]/255; %! plot3 (x, y, z, base2, blue); %! view (330, 12) %!demo %! clf %! [x, y] = meshgrid (midrad (-10 : 0.5 : 10, .25)); %! z = sin (hypot (x, y)) .* hypot (x, y); %! plot3 (mid (x), mid (y), z); %! view (33, 50) %! grid on interval-1.4.1/inst/@infsup/plus.m0000644000000000000000000000345012657475772015241 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} plus (@var{X}, @var{Y}) ## @defopx Operator {@@infsup} {@var{X} + @var{Y}} ## ## Add all numbers of interval @var{X} to all numbers of @var{Y}. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## x = infsup (2, 3); ## y = infsup (1, 2); ## x + y ## @result{} ans = [3, 5] ## @end group ## @end example ## @seealso{@@infsup/minus} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-30 function result = plus (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsup"))) x = infsup (x); endif if (not (isa (y, "infsup"))) y = infsup (y); elseif (isa (y, "infsupdec")) ## Workaround for bug #42735 result = plus (x, y); return endif l = mpfr_function_d ('plus', -inf, x.inf, y.inf); u = mpfr_function_d ('plus', +inf, x.sup, y.sup); emptyresult = isempty (x) | isempty (y); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (infsup (2, 3) + infsup (1, 2) == infsup (3, 5)); interval-1.4.1/inst/@infsup/polyval.m0000644000000000000000000001144512657475772015747 0ustar 00000000000000## Copyright 1995 Rolf Hammer, Matthias Hocks, Dietmar Ratz ## Copyright 1990-2000 Institut für Angewandte Mathematik, ## Universität Karlsruhe, Germany ## Copyright 2000-2014 Wissenschaftliches Rechnen/Softwaretechnologie, ## Universität Wuppertal, Germany ## Copyright 2015-2016 Oliver Heimlich ## ## This program is derived from RPolyEval in CXSC, C++ library for eXtended ## Scientific Computing (V 2.5.4), which is distributed under the terms of ## LGPLv2+. Migration to Octave code has been performed by Oliver Heimlich. ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} polyval (@var{P}, @var{X}) ## ## Evaluate polynomial @var{P} with argument @var{X}. ## ## Horner's scheme is used to evaluate a first approximation. The result is ## improved with iterative refinement. ## ## Accuracy: The result is a tight enclosure for polynomials of degree 1 or ## less. For polynomials of higher degree the result is a valid enclosure. ## For @var{X} being no singleton interval, the algorithm suffers from the ## dependency problem. ## ## @example ## @group ## output_precision (16, 'local') ## polyval (infsup ([3 4 2 1]), 42) # 3x^3 + 4x^2 + 2x^1 + 1 | x = 42 ## @result{} [229405] ## polyval (infsup ([3 4 2 1]), "42?") # ... | x = 41.5 .. 42.5 ## @result{} [221393.125, 237607.875] ## @end group ## @end example ## @seealso{@@infsup/fzero} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-05-29 function result = polyval (p, x) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsup"))) x = infsup (x); endif if (not (isa (p, "infsup"))) p = infsup (p); endif if (not (isscalar (x))) error ('point of evaluation X must be a scalar') endif if (not (isvector (p))) error ('polynomial P must be a vector of coefficients') endif n = numel (p); switch (n) case 0 # empty sum result = infsup (0); return case 1 # p .* x.^0 result = p; return case 2 # p(1) .* x.^1 + p(2) .* x.^0 result = fma (x, subsref (p, struct ('type', '()', 'subs', {{1}})), ... subsref (p, struct ('type', '()', 'subs', {{2}}))); return endswitch if (x == 0) result = subsref (p, struct ('type', '()', 'subs', {{n}})); return elseif (x == 1) result = sum (p); return elseif (x == -1) result = dot (p, (-1) .^ ((n : -1 : 1) - 1)); return endif kMax = 20; idxNext.type = '()'; idxLast.type = '()'; ## Compute first approximation using Horner's scheme yy = infsup (zeros (n, 1)); idxNext.subs = {1}; result = subsref (p, idxNext); yy = subsasgn (yy, idxNext, result); for i = 2 : n idxNext.subs = {i}; result = fma (result, x, subsref (p, idxNext)); yy = subsasgn (yy, idxNext, result); endfor y = zeros (n, kMax); for k = 1 : kMax lastresult = result; ## Iterative refinement ## Store middle of residual as the next correction of y y (:, k) = mid (yy); ## Computation of the residual [r] and ## evaluation of the interval system A*[y] = [r] yy = infsup (zeros (n, 1)); for i = 2 : n idxNext.subs = {i}; idxLast.subs = {i-1}; coef = subsref (p, idxNext); yy = subsasgn (yy, idxNext, dot (... [subsref(yy, idxLast), coef, y(i, 1 : k), y(i - 1, 1 : k)], ... [x, 1, -ones(1, k), x.*ones(1, k)])); endfor ## Determination of a new enclosure of p (x) idxLast.subs = {n}; result = intersect (result, sum ([subsref(yy, idxLast), y(n, 1 : k)])); if (eq (result, lastresult)) ## No improvement break endif if (mpfr_function_d ('plus', +inf, inf (result), pow2 (-1074)) >= ... sup (result)) ## 1 ULP accuracy reached break endif endfor endfunction %!assert (polyval (infsup (42), 0) == 42); %!assert (polyval (infsup ([42 42]), 0) == 42); %!assert (polyval (infsup ([42 42]), 1) == 84); %!assert (polyval (infsup ([42 42]), -1) == 0); %!assert (polyval (infsup ([-42 42 42]), .5) == -42*0.5^2 + 42*0.5 + 42); %!assert (polyval (infsup (vec (pascal (3))), 0.1) == "[0X6.502E9A7231A08P+0, 0X6.502E9A7231A0CP+0]"); interval-1.4.1/inst/@infsup/postpad.m0000644000000000000000000000443412657475772015733 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} postpad (@var{X}, @var{L}) ## @defmethodx {@@infsup} postpad (@var{X}, @var{L}, @var{C}) ## @defmethodx {@@infsup} postpad (@var{X}, @var{L}, @var{C}, @var{DIM}) ## ## Append the scalar interval value @var{C} to the interval vector @var{X} ## until it is of length @var{L}. If @var{C} is not given, a value of 0 is ## used. ## ## If @code{length (@var{X}) > L}, elements from the end of @var{X} are removed ## until an interval vector of length @var{L} is obtained. ## ## If @var{X} is an interval matrix, elements are appended or removed from each ## row or column. ## ## If the optional argument DIM is given, operate along this dimension. ## ## @example ## @group ## postpad (infsup (1 : 3), 5, 42) ## @result{} ans = 1×5 interval vector ## [1] [2] [3] [42] [42] ## @end group ## @end example ## @seealso{@@infsup/reshape, @@infsup/cat, @@infsup/prepad, @@infsup/resize} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-19 function result = postpad (x, len, c, dim) if (nargin < 2 || nargin > 4) print_usage (); return endif if (nargin < 3) c = infsup (0); elseif (not (isa (c, "infsup"))) c = infsup (c); endif if (nargin < 4) if (isvector (x.inf) && not (isscalar (x.inf))) dim = find (size (x.inf) ~= 1, 1); else dim = 1; endif endif l = postpad (x.inf, len, c.inf, dim); u = postpad (x.sup, len, c.sup, dim); result = infsup (l, u); endfunction %!assert (postpad (infsup (1:3), 4, 4) == infsup (1:4)); %!assert (postpad (infsup (1:3), 2, 4) == infsup (1:2)); interval-1.4.1/inst/@infsup/pow.m0000644000000000000000000000654312657475772015071 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} pow (@var{X}, @var{Y}) ## ## Compute the simple power function on intervals defined by ## @code{exp (@var{Y} * log (@var{X}))}. ## ## The function is only defined where @var{X} is positive or where @var{X} is ## zero and @var{Y} is positive. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## pow (infsup (5, 6), infsup (2, 3)) ## @result{} ans = [25, 216] ## @end group ## @end example ## @seealso{@@infsup/pown, @@infsup/pow2, @@infsup/pow10, @@infsup/exp, @@infsup/power} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-04 function result = pow (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsup"))) x = infsup (x); endif if (not (isa (y, "infsup"))) y = infsup (y); endif ## Resize, if scalar × matrix if (isscalar (x.inf) ~= isscalar (y.inf)) x.inf = ones (size (y.inf)) .* x.inf; x.sup = ones (size (y.inf)) .* x.sup; y.inf = ones (size (x.inf)) .* y.inf; y.sup = ones (size (x.inf)) .* y.sup; endif ## Intersect with domain x = intersect (x, infsup (0, inf)); y.inf (x.sup == 0) = max (0, y.inf (x.sup == 0)); y.sup (y.inf > y.sup) = -inf; y.inf (y.inf > y.sup) = inf; ## Simple cases with no limit values, see Table 3.3 in ## Heimlich, Oliver. 2011. “The General Interval Power Function.” ## Diplomarbeit, Institute for Computer Science, University of Würzburg. ## http://exp.ln0.de/heimlich-power-2011.htm. ## ## The min/max is located at the boundaries of the input intervals. Like with ## the times function we do not start a case by case analysis but simply ## compute all four combinations for each result boundary. ## ## We have to compensate for boundary x.inf = -0 with the abs function. ## Otherwise the limit values of the MPFR pow function would be wrong. l = min (min (min (... mpfr_function_d ('pow', -inf, abs (x.inf), y.inf), ... mpfr_function_d ('pow', -inf, abs (x.inf), y.sup)), ... mpfr_function_d ('pow', -inf, x.sup, y.inf)), ... mpfr_function_d ('pow', -inf, x.sup, y.sup)); u = max (max (max (... mpfr_function_d ('pow', +inf, abs (x.inf), y.inf), ... mpfr_function_d ('pow', +inf, abs (x.inf), y.sup)), ... mpfr_function_d ('pow', +inf, x.sup, y.inf)), ... mpfr_function_d ('pow', +inf, x.sup, y.sup)); emptyresult = isempty (x) | isempty (y) | (x.sup == 0 & y.sup == 0); l (emptyresult) = inf; u (emptyresult) = -inf; ## Fix 0 ^ positive = 0 u (x.sup == 0 && u == 1) = 0; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (pow (infsup (5, 6), infsup (2, 3)) == infsup (25, 216)); interval-1.4.1/inst/@infsup/pow10.m0000644000000000000000000000307212657475772015224 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} pow10 (@var{X}) ## ## Compute @code{10^x} for all numbers in @var{X}. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## pow10 (infsup (5)) ## @result{} ans = [1e+05] ## @end group ## @end example ## @seealso{@@infsup/log10, @@infsup/pow, @@infsup/pow2, @@infsup/exp} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-04 function result = pow10 (x) if (nargin ~= 1) print_usage (); return endif ## pow10 is monotonically increasing from (-inf, 0) to (inf, inf) l = mpfr_function_d ('pow10', -inf, x.inf); # this works for empty intervals u = mpfr_function_d ('pow10', +inf, x.sup); # ... this does not u (isempty (x)) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (pow10 (infsup (5)) == infsup (100000)); interval-1.4.1/inst/@infsup/pow2.m0000644000000000000000000000305312657475772015144 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} pow2 (@var{X}) ## ## Compute @code{2^x} for all numbers in @var{X}. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## pow2 (infsup (5)) ## @result{} ans = [32] ## @end group ## @end example ## @seealso{@@infsup/log2, @@infsup/pow, @@infsup/pow10, @@infsup/exp} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-30 function result = pow2 (x) if (nargin ~= 1) print_usage (); return endif ## pow2 is monotonically increasing from (-inf, 0) to (inf, inf) l = mpfr_function_d ('pow2', -inf, x.inf); # this works for empty intervals u = mpfr_function_d ('pow2', +inf, x.sup); # ... this does not u (isempty (x)) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (pow2 (infsup (5)) == infsup (32)); interval-1.4.1/inst/@infsup/power.m0000644000000000000000000002300412657475772015407 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} power (@var{X}, @var{Y}) ## @defopx Operator {@@infsup} {@var{X} .^ @var{Y}} ## ## Compute the general power function on intervals, which is defined for ## (1) any positive base @var{X}; (2) @code{@var{X} = 0} when @var{Y} is ## positive; (3) negative base @var{X} together with integral exponent @var{Y}. ## ## This definition complies with the common complex valued power function, ## restricted to the domain where results are real, plus limit values where ## @var{X} is zero. The complex power function is defined by ## @code{exp (@var{Y} * log (@var{X}))} with initial branch of complex ## logarithm and complex exponential function. ## ## Warning: This function is not defined by IEEE Std 1788-2015. However, it ## has been published as “pow2” in O. Heimlich, M. Nehmeier, J. Wolff von ## Gudenberg. 2013. “Variants of the general interval power function.” ## Soft Computing. Volume 17, Issue 8, pp 1357–1366. ## Springer Berlin Heidelberg. DOI 10.1007/s00500-013-1008-8. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## infsup (-5, 6) .^ infsup (2, 3) ## @result{} ans = [-125, +216] ## @end group ## @end example ## @seealso{@@infsup/pow, @@infsup/pown, @@infsup/pow2, @@infsup/pow10, @@infsup/exp} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2011 function z = power (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsup"))) x = infsup (x); endif if (not (isa (y, "infsup"))) y = infsup (y); elseif (isa (y, "infsupdec")) ## Workaround for bug #42735 z = power (x, y); return endif ## Short circuit integral powers, e.g., x.^2 if (not (any (any (y.inf == 0))) && ... # can't use pown, because 0^0 = [Empty] all (all (y.inf == y.sup & isfinite (y.inf) & fix (y.inf) == y.inf))) z = pown (x, y.inf); return endif ## Resize, if scalar × matrix or vector × matrix or scalar × vector if (rows (x.inf) ~= rows (y.inf)) x.inf = ones (rows (y.inf), columns (x.inf)) .* x.inf; x.sup = ones (rows (y.inf), columns (x.inf)) .* x.sup; y.inf = ones (rows (x.inf), columns (y.inf)) .* y.inf; y.sup = ones (rows (x.inf), columns (y.inf)) .* y.sup; endif if (columns (x.inf) ~= columns (y.inf)) x.inf = ones (rows (x.inf), columns (y.inf)) .* x.inf; x.sup = ones (rows (x.inf), columns (y.inf)) .* x.sup; y.inf = ones (rows (y.inf), columns (x.inf)) .* y.inf; y.sup = ones (rows (y.inf), columns (x.inf)) .* y.sup; endif idx.type = "()"; emptyresult = x.inf == inf | y.inf == inf | ... (x.inf == 0 & x.sup == 0 & y.sup <= 0); zPlus = pow (x, y); # pow is only defined for x > 0 zContainsZero = y.inf > 0 & x.inf <= 0 & x.sup >= 0; zMinus = infsup (); zMinus.inf = zMinus.inf (ones (size (x.inf))); zMinus.sup = zMinus.sup (ones (size (x.sup))); xMinusWithIntegerY = not (emptyresult) & x.inf < 0 & ... not (isfinite (y.inf) & isfinite (y.sup) & ... ceil (y.inf) > floor (y.sup)); if (any (any (xMinusWithIntegerY))) ySingleInteger = isfinite (y.inf) & isfinite (y.sup) & ... ceil (y.inf) == floor (y.sup); ## y contains a single integer idx.subs = {xMinusWithIntegerY & ySingleInteger}; if (any (any (idx.subs {1}))) xMinus = intersect (subsref (x, idx), ... # intersect to infsup (-inf, 0)); # speed up computation zMinus = subsasgn (zMinus, idx, ... pown (xMinus, ceil (subsref (y.inf, idx)))); endif ## y contains several integers idx.subs = {xMinusWithIntegerY & not(ySingleInteger)}; if (any (any (idx.subs {1}))) zMinus = subsasgn (zMinus, idx, ... multipleintegers (subsref (x, idx), ... subsref (y, idx))); endif endif z = union (zMinus, zPlus); idx.subs = {zContainsZero}; z = subsasgn (z, idx, union (subsref (z, idx), 0)); z.inf(emptyresult) = inf; z.sup(emptyresult) = -inf; endfunction function z = multipleintegers (x, y) ## Value of power on NEGATIVE base and multiple integral exponents ## Intersect to simplify computation x = intersect (x, infsup (-inf, 0)); y = intersect (ceil (y), floor (y)); assert (all (all (y.inf < y.sup & x.inf < 0))); ## Implements Table 3.4 in ## Heimlich, Oliver. 2011. “The General Interval Power Function.” ## Diplomarbeit, Institute for Computer Science, University of Würzburg. ## http://exp.ln0.de/heimlich-power-2011.htm. z = infsup (); z.inf = z.inf(ones (size (x.inf))); z.sup = z.sup(ones (size (x.sup))); idx.type = "()"; idx.subs = {(x.sup <= -1 & y.sup <= 0)}; if (any (any (idx.subs {1}))) xsup_idx = subsref (x.sup, idx); y_idx = subsref (y, idx); z = subsasgn (z, idx, twointegers (xsup_idx, goe (y_idx), gee (y_idx))); endif idx.subs = {(-1 <= x.inf & 0 <= y.inf)}; if (any (any (idx.subs {1}))) xinf_idx = subsref (x.inf, idx); y_idx = subsref (y, idx); z = subsasgn (z, idx, twointegers (xinf_idx, loe (y_idx), lee (y_idx))); endif idx.subs = {((x.sup <= -1 | (x.inf < -1 & -1 < x.sup)) & ... ((0 <= y.inf & not (-1 <= x.inf)) | (y.inf <= -1 & 1 <= y.sup)))}; if (any (any (idx.subs {1}))) xinf_idx = subsref (x.inf, idx); y_idx = subsref (y, idx); z = subsasgn (z, idx, twointegers (xinf_idx, goe (y_idx), gee (y_idx))); endif idx.subs = {(((x.inf < -1 & -1 < x.sup) | -1 <= x.inf) & ... ((y.inf <= -1 & 1 <= y.sup) | (y.sup <= 0 & not (x.sup <= -1))))}; if (any (any (idx.subs {1}))) xsup_idx = subsref (x.sup, idx); y_idx = subsref (y, idx); z = subsasgn (z, idx, union (subsref (z, idx), ... twointegers (xsup_idx, loe (y_idx), lee (y_idx)))); endif endfunction function z = twointegers (base, oddexponent, evenexponent) ## Range of power on single NEGATIVE base and two integral exponents ## ## twointegers (base, oddexponent, evenexponent) returns the interval ## [-abs(base) ^ oddexponent, abs(base) ^ evenexponent] with correctly ## rounded boundaries. ## ## twointegers (0, oddexponent, evenexponent) returns the limit value of ## [-abs(base) ^ oddexponent, abs(base) ^ evenexponent] for base -> 0. ## ## twointegers (-inf, oddexponent, evenexponent) returns the limit value of ## [-abs(base) ^ oddexponent, abs(base) ^ evenexponent] for base -> -inf. ## ## Note: oddexponent must not necessarily be odd, since it can be an ## overestimation of an actual odd exponent, if its magnitude is > 2^53. assert (all (all (oddexponent ~= 0))); assert (all (all (not (isfinite (oddexponent) & isfinite (evenexponent)) | ... abs (oddexponent - evenexponent) <= 1))); base = abs (base); z.inf = z.sup = zeros (size (base)); z.inf(base == 0 & oddexponent < 0) = -inf; z.sup(base == 0 & evenexponent < 0) = inf; z.sup(base == 0 & evenexponent == 0) = 1; z.inf(base == inf & oddexponent > 0) = -inf; z.sup(base == inf & evenexponent > 0) = inf; z.sup(base == inf & evenexponent == 0) = 1; z.sup(base == 1) = 1; z.sup(0 < base & base < 1 & evenexponent <= 0) = inf; z.sup(1 < base & base < inf & evenexponent >= 0) = inf; select = 0 < base & base < inf & isfinite (evenexponent); if (any (any (select))) z.sup(select) = sup (pown (infsup (base(select)), evenexponent(select))); endif z.inf(base == 1) = -1; z.inf(0 < base & base < 1 & oddexponent <= 0) = -inf; z.inf(1 < base & base < inf & oddexponent >= 0) = -inf; bigexponent = oddexponent == evenexponent; select = 0 < base & base < inf & bigexponent; z.inf(select) = -z.sup(select); select = 0 < base & base < inf & isfinite (oddexponent) & not (bigexponent); if (any (any (select))) z.inf(select) = -sup (pown (infsup (base(select)), oddexponent(select))); endif z = infsup (z.inf, z.sup); endfunction function e = goe (y) ## GOE Greatest odd exponent in interval y e = floor (y.sup); even = rem (e, 2) == 0; e(even) = mpfr_function_d ('minus', +inf, e(even), 1); e(e < y.inf) = nan (); # no odd number in interval endfunction function e = gee (y) ## GEE Greatest even exponent in interval y e = floor (y.sup); odd = rem (e, 2) ~= 0; e(odd) = mpfr_function_d ('minus', +inf, e(odd), 1); e(e < y.inf) = nan (); # no even number in interval endfunction function e = loe (y) ## LOE Least odd exponent in interval y e = ceil (y.inf); even = rem (e, 2) == 0; e(even) = mpfr_function_d ('plus', -inf, e(even), 1); e(e > y.sup) = nan (); # no odd number in interval endfunction function e = lee (y) ## LOE Least even exponent in interval y e = ceil (y.inf); odd = rem (e, 2) ~= 0; e(odd) = mpfr_function_d ('plus', -inf, e(odd), 1); e(e > y.sup) = nan (); # no odd number in interval endfunction %!test "from the documentation string"; %! assert (infsup (-5, 6) .^ infsup (2, 3) == infsup (-125, 216)); %!assert (infsup (-10, 0) .^ infsup (0, 1:8) == infsup ([-1e1, -1e1, -1e3, -1e3, -1e5, -1e5, -1e7, -1e7], [1e0, 1e2, 1e2, 1e4, 1e4, 1e6, 1e6, 1e8])); interval-1.4.1/inst/@infsup/pown.m0000644000000000000000000000664212657475772015247 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} pown (@var{X}, @var{P}) ## ## Compute the monomial @code{x^@var{P}} for all numbers in @var{X}. ## ## Monomials are defined for all real numbers and the special monomial ## @code{@var{P} == 0} evaluates to @code{1} everywhere. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## pown (infsup (5, 6), 2) ## @result{} ans = [25, 36] ## @end group ## @end example ## @seealso{@@infsup/pow, @@infsup/pow2, @@infsup/pow10, @@infsup/exp} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-04 function result = pown (x, p) if (nargin ~= 2) print_usage (); return endif if (not (isnumeric (p)) || any (any (fix (p) ~= p))) error ("interval:InvalidOperand", "pown: exponent is not an integer"); endif ## Resize, if scalar × matrix if (isscalar (x.inf) ~= isscalar (p)) x.inf = ones (size (p)) .* x.inf; x.sup = ones (size (p)) .* x.sup; p = ones (size (x.inf)) .* p; endif result = x; % already correct for p == 1 select = (p == 0 & not (isempty (x))); result.inf(select) = result.sup(select) = 1; idx.type = "()"; idx.subs = {(p == 2)}; # x^2 if (any (any (idx.subs{1}))) result = subsasgn (result, idx, sqr (subsref (x, idx))); endif idx.subs = {(p == -1)}; # x^-1 = 1./x if (any (any (idx.subs{1}))) result = subsasgn (result, idx, 1 ./ subsref (x, idx)); endif idx.subs = {(rem (p, 2) == 0 & p ~= 2 & p ~= 0)}; if (any (any (idx.subs{1}))) # p even x_mig = mig (subsref (x, idx)); x_mig(isnan (x_mig)) = inf; x_mag = mag (subsref (x, idx)); x_mag(isnan (x_mag)) = -inf; x.inf = subsasgn (x.inf, idx, x_mig); x.sup = subsasgn (x.sup, idx, x_mag); result = subsasgn (result, idx, pow (subsref (x, idx), subsref (p, idx))); endif idx.subs = {(rem (p, 2) ~= 0 & p ~= -1)}; if (any (any (idx.subs{1}))) # p odd x_idx = subsref (x, idx); p_idx = infsup (subsref (p, idx)); result = subsasgn (result, idx, ... union (pow (x_idx, p_idx), ... -pow (-x_idx, p_idx))); endif ## Special case: x = [0]. The pow function used above would be undefined. select = (p > 0 & x.inf == 0 & x.sup == 0); result.inf(select) = -0; result.sup(select) = +0; endfunction function result = sqr (x) ## Compute the square for each entry in @var{X}. ## ## Accuracy: The result is a tight enclosure. l = mpfr_function_d ('sqr', -inf, mig (x)); u = mpfr_function_d ('sqr', +inf, mag (x)); emptyresult = isempty (x); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (pown (infsup (5, 6), 2) == infsup (25, 36)); %!assert (pown (infsup (-2, 1), 2) == infsup (0, 4)); interval-1.4.1/inst/@infsup/pownrev.m0000644000000000000000000000523312657475772015757 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {@var{X} =} pownrev (@var{C}, @var{X}, @var{P}) ## @deftypemethodx {@@infsup} {@var{X} =} pownrev (@var{C}, @var{P}) ## ## Compute the reverse monomial @code{x^@var{P}}. ## ## That is, an enclosure of all @code{x ∈ @var{X}} where ## @code{pown (x, @var{P}) ∈ @var{C}}. ## ## Accuracy: The result is a valid enclosure. The result is a tight ## enclosure for @var{P} ≥ -2. The result also is a tight enclosure if the ## reciprocal of @var{P} can be computed exactly in double-precision. ## ## @seealso{@@infsup/pown} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = pownrev (c, x, p) if (nargin < 2 || nargin > 3) print_usage (); return endif if (nargin < 3) p = x; x = infsup (-inf, inf); endif if (not (isa (c, "infsup"))) c = infsup (c); endif if (not (isa (x, "infsup"))) x = infsup (x); endif if (not (isnumeric (p)) || fix (p) ~= p) error ("interval:InvalidOperand", "pownrev: exponent is not an integer"); endif ## Resize, if scalar × matrix if (isscalar (x.inf) ~= isscalar (c.inf)) x.inf = x.inf (ones (size (c.inf))); x.sup = x.sup (ones (size (c.inf))); c.inf = c.inf (ones (size (x.inf))); c.sup = c.sup (ones (size (x.inf))); endif if (p == 0) # x^p == 1 result = x; emptyresult = c.inf > 1 | c.sup < 1; result.inf (emptyresult) = inf; result.sup (emptyresult) = -inf; else even = mod (p, 2) == 0; if (even) result = union (... intersect (x, nthroot (intersect (c, infsup (0, inf)), p)), ... intersect (x, -nthroot (intersect (c, infsup (0, inf)), p))); else result = union (... intersect (x, nthroot (intersect (c, infsup (0, inf)), p)), ... intersect (x, nthroot (intersect (c, infsup (-inf, 0)), p))); endif endif endfunction %!assert (pownrev (infsup (25, 36), infsup (0, inf), 2) == infsup (5, 6)); interval-1.4.1/inst/@infsup/powrev1.m0000644000000000000000000001650312657475772015664 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {@var{X} =} powrev1 (@var{B}, @var{C}, @var{X}) ## @deftypemethodx {@@infsup} {@var{X} =} powrev1 (@var{B}, @var{C}) ## ## Compute the reverse power function for the first parameter. ## ## That is, an enclosure of all @code{x ∈ @var{X}} where ## @code{pow (x, b) ∈ @var{C}} for any @code{b ∈ @var{B}}. ## ## Accuracy: The result is a valid enclosure. ## ## @example ## @group ## powrev1 (infsup (2, 5), infsup (3, 6)) ## @result{} ans ⊂ [1.2457, 2.4495] ## @end group ## @end example ## @seealso{@@infsup/pow} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2011 function result = powrev1 (b, c, x) if (nargin < 2 || nargin > 3) print_usage (); return endif if (nargin < 3) x = infsup (-inf, inf); endif if (not (isa (b, "infsup"))) b = infsup (b); endif if (not (isa (c, "infsup"))) c = infsup (c); endif if (not (isa (x, "infsup"))) x = infsup (x); endif x = intersect (x, infsup (0, inf)); c = intersect (c, infsup (0, inf)); ## Resize, if scalar × matrix or vector × matrix or scalar × vector if (rows (b.inf) ~= rows (c.inf)) b.inf = ones (rows (c.inf), columns (b.inf)) .* b.inf; b.sup = ones (rows (c.inf), columns (b.inf)) .* b.sup; c.inf = ones (rows (b.inf), columns (c.inf)) .* c.inf; c.sup = ones (rows (b.inf), columns (c.inf)) .* c.sup; endif if (rows (b.inf) ~= rows (x.inf)) b.inf = ones (rows (x.inf), columns (b.inf)) .* b.inf; b.sup = ones (rows (x.inf), columns (b.inf)) .* b.sup; c.inf = ones (rows (x.inf), columns (c.inf)) .* c.inf; c.sup = ones (rows (x.inf), columns (c.inf)) .* c.sup; x.inf = ones (rows (b.inf), columns (x.inf)) .* x.inf; x.sup = ones (rows (b.inf), columns (x.inf)) .* x.sup; endif if (columns (b.inf) ~= columns (c.inf)) b.inf = ones (rows (b.inf), columns (c.inf)) .* b.inf; b.sup = ones (rows (b.inf), columns (c.inf)) .* b.sup; c.inf = ones (rows (c.inf), columns (b.inf)) .* c.inf; c.sup = ones (rows (c.inf), columns (b.inf)) .* c.sup; endif if (columns (b.inf) ~= columns (x.inf)) b.inf = ones (rows (b.inf), columns (x.inf)) .* b.inf; b.sup = ones (rows (b.inf), columns (x.inf)) .* b.sup; c.inf = ones (rows (c.inf), columns (x.inf)) .* c.inf; c.sup = ones (rows (c.inf), columns (x.inf)) .* c.sup; x.inf = ones (rows (x.inf), columns (b.inf)) .* x.inf; x.sup = ones (rows (x.inf), columns (b.inf)) .* x.sup; endif l = x.inf; u = x.sup; emptyresult = isempty (b) | isempty (c) | (x.sup == 0 & b.sup <= 0) ... | (b.sup <= 0 & ((x.sup <= 1 & c.sup < 1) | (x.inf >= 1 & c.inf > 1))) ... | (b.inf >= 0 & ((x.sup <= 1 & c.inf > 1) | (x.inf >= 1 & c.sup < 1))); l (emptyresult) = inf; u (emptyresult) = -inf; ## Implements Table B.1 in ## Heimlich, Oliver. 2011. “The General Interval Power Function.” ## Diplomarbeit, Institute for Computer Science, University of Würzburg. ## http://exp.ln0.de/heimlich-power-2011.htm. ## y before [0, 0] ============================================================ y = b.sup < 0; z = c.sup < 1; select = y & z & l < inf; if (any (any (select))) l (select) = max (l (select), ... powrev1rounded (c.sup (select), b.inf (select), -inf)); endif z = c.sup == 1; select = y & z & l < 1; l (select) = 1; z = c.sup > 1 & c.sup < inf; select = y & z & l < 1; if (any (any (select))) l (select) = max (l (select), ... powrev1rounded (c.sup (select), b.sup (select), -inf)); endif z = c.inf > 0 & c.inf < 1; select = y & z & u > 1; if (any (any (select))) u (select) = min (u (select), ... powrev1rounded (c.inf (select), b.sup (select), +inf)); endif z = c.inf == 1; select = y & z & u > 1; u (select) = 1; z = c.inf > 1; select = y & z & u > 0; if (any (any (select))) u (select) = min (u (select), ... powrev1rounded (c.inf (select), b.inf (select), +inf)); endif ## ismember (0, y) ============================================================ y = b.inf <= 0 & b.sup >= 0; gap.inf = -inf (size (l)); gap.sup = +inf (size (u)); z = c.sup < 1; select = y & z & b.sup > 0; if (any (any (select))) gap.inf (select) = powrev1rounded (c.sup (select), b.sup (select), +inf); endif select = y & z & b.inf < 0; if (any (any (select))) gap.sup (select) = powrev1rounded (c.sup (select), b.inf (select), -inf); endif z = c.inf > 1; select = y & z & b.inf < 0; if (any (any (select))) gap.inf (select) = powrev1rounded (c.inf (select), b.inf (select), +inf); endif select = y & z & b.sup > 0; if (any (any (select))) gap.sup (select) = powrev1rounded (c.inf (select), b.sup (select), -inf); endif z = c.sup < 1 | c.inf > 1; select = y & z & (l > gap.inf | (gap.inf == 1 & l == 1)); l (select) = max (l (select), gap.sup (select)); select = y & z & (u < gap.sup | gap.sup == inf | (gap.sup == 1 & u == 1)); u (select) = min (u (select), gap.inf (select)); ## y after [0, 0] ============================================================= y = b.inf > 0; z = c.sup < 1; select = y & z & u > 0; if (any (any (select))) u (select) = min (u (select), ... powrev1rounded (c.sup (select), b.sup (select), +inf)); endif z = c.sup == 1; select = y & z & u > 1; u (select) = 1; z = c.sup > 1 & c.sup < inf; select = y & z & u > 1; if (any (any (select))) u (select) = min (u (select), ... powrev1rounded (c.sup (select), b.inf (select), +inf)); endif z = c.inf > 0 & c.inf < 1; select = y & z & l < 1; if (any (any (select))) l (select) = max (l (select), ... powrev1rounded (c.inf (select), b.inf (select), -inf)); endif z = c.inf == 1; select = y & z & l < 1; l (select) = 1; z = c.inf > 1; select = y & z & l < inf; if (any (any (select))) l (select) = max (l (select), ... powrev1rounded (c.inf (select), b.sup (select), -inf)); endif ## ============================================================================ emptyresult = l > u | l == inf | u == -inf; l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction function x = powrev1rounded (z, y, direction) ## Return x = z ^ (1 / y) with directed rounding and limit values x = ones (size (z)); x ((z == inf & y < 0) | (z == 0 & y > 0)) = 0; x ((z == inf & y > 0) | (z == 0 & y < 0)) = inf; select = z > 1 & z < inf & isfinite (y); y (select) = mpfr_function_d ('rdivide', direction, 1, y (select)); select = z < 1 & z > 0 & isfinite (y); y (select) = mpfr_function_d ('rdivide', -direction, 1, y (select)); select = isfinite (y) & z > 0 & z ~= 1 & z < inf; x (select) = mpfr_function_d ('pow', direction, z (select), y (select)); endfunction %!test "from the documentation string"; %! assert (powrev1 (infsup (2, 5), infsup (3, 6)) == "[0x1.3EE8390D43955, 0x1.3988E1409212Fp1]"); interval-1.4.1/inst/@infsup/powrev2.m0000644000000000000000000002077612657475772015674 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {@var{Y} =} powrev2 (@var{A}, @var{C}, @var{Y}) ## @deftypemethodx {@@infsup} {@var{Y} =} powrev2 (@var{A}, @var{C}) ## ## Compute the reverse power function for the second parameter. ## ## That is, an enclosure of all @code{y ∈ @var{Y}} where ## @code{pow (a, y) ∈ @var{C}} for any @code{a ∈ @var{A}}. ## ## Accuracy: The result is a valid enclosure. ## ## @example ## @group ## powrev2 (infsup (2, 5), infsup (3, 6)) ## @result{} ans ⊂ [0.6826, 2.585] ## @end group ## @end example ## @seealso{@@infsup/pow} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2011 function result = powrev2 (a, c, y) if (nargin < 2 || nargin > 3) print_usage (); return endif if (nargin < 3) y = infsup (-inf, inf); endif if (not (isa (a, "infsup"))) a = infsup (a); endif if (not (isa (c, "infsup"))) c = infsup (c); endif if (not (isa (y, "infsup"))) y = infsup (y); endif a = intersect (a, infsup (0, inf)); c = intersect (c, infsup (0, inf)); ## Resize, if scalar × matrix or vector × matrix or scalar × vector if (rows (a.inf) ~= rows (c.inf)) a.inf = ones (rows (c.inf), columns (a.inf)) .* a.inf; a.sup = ones (rows (c.inf), columns (a.inf)) .* a.sup; c.inf = ones (rows (a.inf), columns (c.inf)) .* c.inf; c.sup = ones (rows (a.inf), columns (c.inf)) .* c.sup; endif if (rows (a.inf) ~= rows (y.inf)) a.inf = ones (rows (y.inf), columns (a.inf)) .* a.inf; a.sup = ones (rows (y.inf), columns (a.inf)) .* a.sup; c.inf = ones (rows (y.inf), columns (c.inf)) .* c.inf; c.sup = ones (rows (y.inf), columns (c.inf)) .* c.sup; y.inf = ones (rows (a.inf), columns (y.inf)) .* y.inf; y.sup = ones (rows (a.inf), columns (y.inf)) .* y.sup; endif if (columns (a.inf) ~= columns (c.inf)) a.inf = ones (rows (a.inf), columns (c.inf)) .* a.inf; a.sup = ones (rows (a.inf), columns (c.inf)) .* a.sup; c.inf = ones (rows (c.inf), columns (a.inf)) .* c.inf; c.sup = ones (rows (c.inf), columns (a.inf)) .* c.sup; endif if (columns (a.inf) ~= columns (y.inf)) a.inf = ones (rows (a.inf), columns (y.inf)) .* a.inf; a.sup = ones (rows (a.inf), columns (y.inf)) .* a.sup; c.inf = ones (rows (c.inf), columns (y.inf)) .* c.inf; c.sup = ones (rows (c.inf), columns (y.inf)) .* c.sup; y.inf = ones (rows (y.inf), columns (a.inf)) .* y.inf; y.sup = ones (rows (y.inf), columns (a.inf)) .* y.sup; endif l = y.inf; u = y.sup; emptyresult = isempty (a) | isempty (c) ... | (a.sup == 0 & (y.sup <= 0 | c.inf > 0)) ... | (y.sup <= 0 & ((a.sup <= 1 & c.sup < 1) | (a.inf > 1 & c.inf > 1))) ... | (y.inf >= 0 & ((a.sup <= 1 & c.inf > 1) | (a.inf > 1 & c.sup < 1))) ... | (((a.inf == 1 & a.sup == 1) | (y.inf == 0 & y.sup == 0)) ... & (c.sup < 1 | c.inf > 1)); l(emptyresult) = inf; u(emptyresult) = -inf; ## Implements Table B.2 in ## Heimlich, Oliver. 2011. “The General Interval Power Function.” ## Diplomarbeit, Institute for Computer Science, University of Würzburg. ## http://exp.ln0.de/heimlich-power-2011.htm. ## x overlaps/starts/containedBy [0, 1] ======================================= x = a.sup < 1; select = a.sup == 0 & l < 0; l(select) = 0; z = c.sup <= 1; select = x & z & (a.inf == 0 | c.sup == 1) & l < 0; l(select) = 0; z = c.sup > 1 & c.sup < inf; select = x & z & l < 0; if (any (any (select))) l(select) = max (l(select), ... powrev2rounded (a.sup(select), c.sup(select), -inf)); endif z = c.inf >= 1; select = x & z & (a.inf == 0 | c.inf == 1) & u > 0; u(select) = 0; z = c.inf > 0 & c.inf < 1; select = x & z & u > 0; if (any (any (select))) u (select) = min (u (select), powrev2rounded (a.sup, c.inf, +inf)); endif ## x containedBy/finishes [0, 1] ============================================== x = a.inf > 0 & a.inf < 1 & a.sup <= 1; z = c.sup < 1 & c.sup > 0; select = x & z & l < inf; if (any (any (select))) l(select) = max (l(select), ... powrev2rounded (a.inf(select), c.sup(select), -inf)); endif z = c.inf > 1 & c.sup < inf; select = x & z & u > -inf; if (any (any (select))) u(select) = min (u(select), ... powrev2rounded (a.inf(select), c.inf (select), +inf)); endif ## ismember (1, x) ============================================================ x = a.sup >= 1 & a.inf <= 1; z = c.inf == 0 & c.sup == 0; select = x & z & l < 0; l(select) = 0; z = c.sup == inf & c.inf > 1; select = x & z & u > 0 && a.sup <= 1; u(select) = 0; gap.inf = -inf (size (l)); gap.sup = +inf (size (u)); z = c.sup < 1; select = x & z & a.inf == 0; gap.sup(select) = 0; select = x & z & a.sup > 1; if (any (any (select))) gap.inf(select) = powrev2rounded (a.sup(select), c.sup(select), +inf); endif select = x & z & a.inf > 0 & a.inf < 1 & a.sup > 1; if (any (any (select))) gap.sup(select) = powrev2rounded(a.inf(select), c.sup(select), -inf); endif z = c.inf > 1; select = x & z & a.inf == 0; gap.inf(select) = 0; select = x & z & a.sup > 1; if (any (any (select))) gap.sup(select) = powrev2rounded (a.sup(select), c.inf(select), -inf); endif select = x & z & a.inf > 0 & a.inf < 1 & a.sup > 1; if (any (any (select))) gap.inf(select) = powrev2rounded (a.inf(select), c.inf(select), +inf); endif z = c.sup < 1 | c.inf > 1; select = x & z & (l > gap.inf | gap.inf == -inf | (gap.inf == 0 & l == 0)) ... & (a.inf >= 1 | a.sup > 1 | a.inf <= 0); l(select) = max (l(select), gap.sup(select)); select = x & z & (u < gap.sup | gap.sup == inf | (gap.sup == 0 & u == 0)) ... & (a.inf >= 1 | a.sup > 1 | a.inf <= 0); u(select) = min (u(select), gap.inf(select)); ## x after [0, 1] ============================================================= x = a.inf > 1; z = c.sup < 1; select = x & z & u > -inf; if (any (any (select))) u(select) = min (u(select), ... powrev2rounded (a.sup(select), c.sup(select), +inf)); endif z = c.inf > 0 & c.inf < 1; select = x & z & l < 0; if (any (any (select))) l(select) = max (l(select), ... powrev2rounded (a.inf(select), c.inf(select), -inf)); endif z = c.inf == 1; select = x & z & l < 0; l(select) = 0; z = c.inf > 1; select = x & z & l < inf; if (any (any (select))) l(select) = max (l(select), ... powrev2rounded (a.sup(select), c.inf(select), -inf)); endif z = c.sup == 1; select = x & z & u > 0; u (select) = 0; z = c.sup > 1 & c.sup < inf; select = x & z & u > 0; if (any (any (select))) u(select) = min (u(select), ... powrev2rounded (a.inf(select), c.sup(select), +inf)); endif ## ============================================================================ emptyresult = l > u | l == inf | u == -inf; l(emptyresult) = inf; u(emptyresult) = -inf; result = infsup (l, u); endfunction function y = powrev2rounded (x, z, direction) ## Return y = log z / log x with directed rounding and limit values y = nominator = denominator = zeros (size (x)); y (z == inf & x < 1) = -inf; y (z == inf & x > 1 & x < inf) = inf; ## We do not use log here, because log2 is able to produce some results without ## rounding errors. rnd_log_numerator_up = (direction > 0) == (sign (x - 1) == sign (z - 1)); select = isfinite (x) & isfinite (z) & rnd_log_numerator_up; if (any (any (select))) denominator (select) = mpfr_function_d ('log2', -inf, x (select)); nominator (select) = mpfr_function_d ('log2', +inf, z (select)); endif select = isfinite (x) & isfinite (z) & not (rnd_log_numerator_up); if (any (any (select))) denominator (select) = mpfr_function_d ('log2', +inf, x (select)); nominator (select) = mpfr_function_d ('log2', -inf, z (select)); endif select = isfinite (x) & isfinite (z); if (any (any (select))) y (select) = mpfr_function_d ('rdivide', direction, ... nominator (select), ... denominator (select)); endif endfunction %!test "from the documentation string"; %! assert (powrev2 (infsup (2, 5), infsup (3, 6)) == "[0x1.5D7E8F22BA886p-1, 0x1.4AE00D1CFDEB5p1]"); interval-1.4.1/inst/@infsup/precedes.m0000644000000000000000000000321512657475772016047 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} precedes (@var{A}, @var{B}) ## ## Evaluate precedes comparison on intervals. ## ## True, if @var{A} is left of @var{B}. The intervals may touch. ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## @seealso{@@infsup/eq, @@infsup/le, @@infsup/lt, @@infsup/gt, @@infsup/strictprecedes, @@infsup/subset, @@infsup/interior, @@infsup/disjoint} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-07 function result = precedes (a, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (a, "infsup"))) a = infsup (a); endif if (not (isa (b, "infsup"))) b = infsup (b); endif ## This comparison also works for empty intervels, where the comparison must ## always return true. result = (a.sup <= b.inf); endfunction %!assert (precedes (infsup (1, 2), infsup (2, 3))); %!assert (not (precedes (infsup (1, 2.1), infsup (1.9, 3)))); interval-1.4.1/inst/@infsup/prepad.m0000644000000000000000000000443412657475772015534 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} prepad (@var{X}, @var{L}) ## @defmethodx {@@infsup} prepad (@var{X}, @var{L}, @var{C}) ## @defmethodx {@@infsup} prepad (@var{X}, @var{L}, @var{C}, @var{DIM}) ## ## Prepend the scalar interval value @var{C} to the interval vector @var{X} ## until it is of length @var{L}. If @var{C} is not given, a value of 0 is ## used. ## ## If @code{length (@var{X}) > L}, elements from the beginning of @var{X} are ## removed until an interval vector of length @var{L} is obtained. ## ## If @var{X} is an interval matrix, elements are prepended or removed from ## each row or column. ## ## If the optional argument DIM is given, operate along this dimension. ## ## @example ## @group ## prepad (infsup (1 : 3), 5, 42) ## @result{} ans = 1×5 interval vector ## [42] [42] [1] [2] [3] ## @end group ## @end example ## @seealso{@@infsup/reshape, @@infsup/cat, @@infsup/postpad, @@infsup/resize} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-19 function result = prepad (x, len, c, dim) if (nargin < 2 || nargin > 4) print_usage (); return endif if (nargin < 3) c = infsup (0); elseif (not (isa (c, "infsup"))) c = infsup (c); endif if (nargin < 4) if (isvector (x.inf) && not (isscalar (x.inf))) dim = find (size (x.inf) ~= 1, 1); else dim = 1; endif endif l = prepad (x.inf, len, c.inf, dim); u = prepad (x.sup, len, c.sup, dim); result = infsup (l, u); endfunction %!assert (prepad (infsup (2:4), 4, 1) == infsup (1:4)); %!assert (prepad (infsup (0:2), 2, 1) == infsup (1:2)); interval-1.4.1/inst/@infsup/private/decimaladd.m0000644000000000000000000000573612657475772020010 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypefun {@var{DECIMAL} =} decimaladd (@var{DECIMAL}, @var{ADDEND}) ## ## Add two decimal numbers. ## ## @end deftypefun ## Author: Oliver Heimlich ## Created: 2014-10-21 function [decimal] = decimaladd (decimal, addend) ## Align mantissas if (addend.e < decimal.e) addend.m = [zeros(decimal.e - addend.e, 1); ... addend.m]; addend.e = decimal.e; elseif (addend.e > decimal.e) decimal.m = [zeros(addend.e - decimal.e, 1); ... decimal.m]; decimal.e = addend.e; endif if (length (decimal.m) > length (addend.m)) addend.m = [addend.m; ... zeros(length (decimal.m) - ... length (addend.m), 1)]; elseif (length (decimal.m) < length (addend.m)) decimal.m = [decimal.m; ... zeros(length (addend.m) - ... length (decimal.m), 1)]; endif assert (length (decimal.m) == length (addend.m)); assert (decimal.e == addend.e); ## Add if (decimal.s == addend.s) decimal.m += addend.m; else decimal.m -= addend.m; endif ## Carry while (not (isempty (find (decimal.m >= 10)))) decimal.m = [0; rem(decimal.m, 10)] ... + [(decimal.m >= 10); 0]; if (decimal.m(1) == 0) decimal.m(1) = []; else decimal.e ++; endif endwhile ## Resolve negative decimal digits while (1) highestnegative = find (decimal.m < 0, 1); if (isempty (highestnegative)) break; endif highestpositive = find (decimal.m > 0, 1); if (isempty (highestpositive) || ... highestnegative < highestpositive) ## Flip sign decimal.s = not (decimal.s); decimal.m *= -1; else assert (decimal.m(1) >= 0); decimal.m += 10 * (decimal.m < 0) ... - [(decimal.m(2:end) < 0); 0]; endif endwhile clear highestnegative highestpositive; ## Normalize mantissa: remove leading zeroes firstnonzerodigit = find (decimal.m ~= 0, 1, "first"); if (firstnonzerodigit > 1) decimal.m = decimal.m(firstnonzerodigit:end); decimal.e -= firstnonzerodigit - 1; elseif (isempty (firstnonzerodigit)) # all digits are zero decimal.s = false; decimal.m = []; decimal.e = int64 (0); return endif ## Remove trailing zeros decimal.m = decimal.m(1 : find (decimal.m ~= 0, 1, "last")); endfunctioninterval-1.4.1/inst/@infsup/private/decimalcompare.m0000644000000000000000000000371312657475772020677 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deffun decimalcompare (@var{X}, @var{Y}) ## ## Compare two decimal floating point numbers. ## ## The result is a negative number, if @code{@var{X} < @var{Y}}; ## zero, if @code{@var{X} == @var{Y}}; a positive number, ## if @code{@var{X} > @var{Y}}. ## ## @seealso{str2decimal, double2decimal} ## @end deffun ## Author: Oliver Heimlich ## Created: 2014-09-29 function result = decimalcompare (x, y) ## Comparison with zero if (isempty (x.m) ~= isempty (y.m)) if (y.s || ... # Y < 0 not (x.s || isempty (x.m))) # X > 0 result = 1; else result = -1; endif return endif ## Different signs if (x.s ~= y.s) result = y.s - x.s; return endif ## Different exponents if (x.e ~= y.e) result = x.e - y.e; if (x.s) result .*= -1; endif return endif ## Compare common mantissa places for i = 1 : min (length (x.m), length (y.m)) if (x.m(i) ~= y.m(i)) result = x.m(i) - y.m(i); if (x.s) result .*= -1; endif return endif endfor ## Compare mantissa length. There is no need to inspect the digits, because the ## mantissa is normalized (no trailing zeroes). result = length (x.m) - length (y.m); if (x.s) result .*= -1; endif endfunctioninterval-1.4.1/inst/@infsup/private/decimaldivide.m0000644000000000000000000000417512657475772020520 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypefun {[@var{QUOTIENT}, @var{REMAINDER}] =} decimaldivide (@var{DIVIDEND}, @var{DIVISOR}, @var{PRECISION}) ## ## Divide two decimal numbers. The parameter @var{PRECISION} limits the ## maximum significand places in the @var{QUOTIENT}. ## ## @end deftypefun ## Author: Oliver Heimlich ## Created: 2014-10-22 function [quotient, remainder] = decimaldivide (dividend, divisor, precision) assert (not (isempty (divisor.m)), "division by zero"); if (isempty (dividend.m)) # 0 / divisor quotient = dividend; remainder = dividend; return endif ## Compute exponent and sign of the result quotient.e = dividend.e - divisor.e + 1; divisor.e = dividend.e; quotient.s = xor (dividend.s, divisor.s); divisor.s = dividend.s; quotient.m = zeros (precision, 1); ## Perform long division remainder = dividend; i = 1; while (i <= length (quotient.m)) if (isempty (remainder.m)) break endif while (sign (decimalcompare (divisor, remainder)) ~= (-1) ^ remainder.s) quotient.m (i) ++; ## Subtract divisor from remainder divisor.s = not (remainder.s); remainder = decimaladd (remainder, divisor); divisor.s = remainder.s; endwhile divisor.e --; if (i == 1 && quotient.m (i) == 0) quotient.e --; else i++; endif endwhile ## Remove trailing zeros quotient.m = quotient.m(1 : find (quotient.m ~= 0, 1, "last")); endfunctioninterval-1.4.1/inst/@infsup/private/double2decimal.m0000644000000000000000000000704612657475772020610 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deffun double2decimal (@var{X}) ## ## Convert a binary floating point number @var{X} in double precision to a ## decimal floating point number with arbitrary precision. The number must be ## a finite number and must not be NaN. ## ## Conversion is exact, because @code{rem (10, 2) == 0}. ## ## Sign: true (-) or false (+) ## ## Mantissa: Vector that holds the decimal digits after the decimal point. The ## first digit is not zero. Trailing zeroes are removed. ## ## Exponent: Integral exponent (base 10). ## ## @example ## @group ## x = double2decimal (-200) ## @result{} ## x.s = 1 ## x.m = [2] ## x.e = 2 ## y = double2decimal (0.125) ## @result{} ## y.s = 0 ## y.m = [1 2 5]' ## y.e = 0 ## z = double2decimal (0) ## @result{} ## z.s = 0 ## z.m = [] ## z.e = 0 ## @end group ## @end example ## @seealso{str2decimal} ## @end deffun ## Author: Oliver Heimlich ## Created: 2014-09-29 function decimal = double2decimal (binary) [decimal.s, exponent, fraction] = parsedouble (binary); if (sum (fraction) == 0) # this number equals zero decimal.s = false; # normalize: remove sign from -0 decimal.m = []; decimal.e = int64 (0); return endif ## Remove trailing zeroes if this might reduce the number of loop cycles below if (exponent < length (fraction)) fraction = fraction(1:find (fraction, 1, "last")); endif ## Move the point to the end of the mantissa and interpret mantissa as a binary ## integer number that is now in front of the point. Convert binary integer ## to decimal. exponent -= length (fraction); decimal.m = zeros (); for i = 1 : length(fraction) ## Multiply by 2 decimal.m .*= 2; ## Add 1 if necessary decimal.m(end) += fraction(i); ## Carry decimal.m = [0; rem(decimal.m, 10)] ... + [(decimal.m >= 10); 0]; endfor clear fraction; ## Normalize: Remove leading zeroes (for performance reasons not in loop) decimal.m = decimal.m(find (decimal.m ~= 0, 1, "first"):end); assert (length (decimal.m) > 0, "number must not equal zero at this point"); decimal.e = int64 (length (decimal.m)); ## Multiply decimal integer with 2 ^ exponent while (exponent > 0) decimal.m .*= 2; decimal.m = [0; rem(decimal.m, 10)] ... + [(decimal.m >= 10); 0]; if (decimal.m(1) == 0) decimal.m(1) = []; else decimal.e ++; endif exponent --; endwhile while (exponent < 0) ## Instead of division by 2 we devide by 10 and multiply by 5 decimal.e --; # cheap division by 10 decimal.m .*= 5; decimal.m = [0; rem(decimal.m, 10)] ... + [floor(decimal.m ./ 10); 0]; if (decimal.m(1) == 0) decimal.m(1) = []; else decimal.e ++; endif exponent ++; endwhile ## Normalize mantissa: remove trailing zeroes; decimal.m = decimal.m(1 : find (decimal.m ~= 0, 1, "last")); endfunctioninterval-1.4.1/inst/@infsup/private/hex2double.m0000644000000000000000000001266512657475772020001 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypefun {[@var{X}, @var{ISEXACT}] =} hex2double (@var{S}, @var{DIRECTION}) ## ## Convert a hexadecimal floating point number @var{S} to double precision with ## directed rounding. ## ## The input number format is [+-]0xh[,.]h[[pP][+-]d]. ## ## @seealso{str2decimal} ## @end deftypefun ## Author: Oliver Heimlich ## Created: 2014-10-20 function [binary, isexact] = hex2double (string, direction) ## Strip Sign if (isempty (string)) hex.s = false; else hex.s = (string (1) == "-"); if (strfind("+-", string(1))) string = string (2:end); endif endif ## Strip hex indicator if (strncmpi ("0x", string, 2)) string = string (3:end); else error ("interval:InvalidOperand", ... ["invalid hex number does not start with 0x: " string]); endif ## Split mantissa & exponent [hex.m, hex.e] = strtok (string, "pP"); ## Convert exponent from string to number if (isempty (hex.e)) hex.e = int64(0); # 2 ^ 0 = 1 else if (strfind (hex.e, ".") || strfind (hex.e, ",")) error ("interval:InvalidOperand", ... ["invalid hex number with rational exponent: " string]); endif hex.e = str2double (hex.e(2:end)); # remove “p” and convert if (isnan (hex.e) || ... # greater than realmax or illegal format abs(hex.e) >= pow2 (53)) # possibly lost precision error ("interval:InvalidOperand", ... ["invalid hex number with big/invalid exponent: " string]); endif hex.e = int64 (hex.e); endif ## Split Mantissa at point hex.m = strsplit (hex.m, {".",","}); switch length(hex.m) case 0 hex.m = {"", ""}; case 1 hex.m{2} = ""; case 2 # nothing to do otherwise error ("interval:InvalidOperand", ... ["invalid hex number with multiple points: " string]); endswitch ## Normalize mantissa string: move point to the right if (hex.e - length (hex.m{2}) * 4 <= intmin (class (hex.e))) error ("interval:InvalidOperand", ... ["exponent overflow during normalization: " string ]); endif hex.e -= length (hex.m{2}) * 4; hex.m = strcat (hex.m{1}, hex.m{2}); hexvalues = rem (uint8 (hex.m) - 47, 39); # 1 .. 16 lookup = [0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1;... 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1;... 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1;... 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1]; hex.m = (logical (lookup (:, hexvalues))) (:)'; ## Normalize mantissa: remove leading zeroes firstnonzerodigit = find (hex.m, 1, "first"); if (firstnonzerodigit > 1) hex.m = hex.m (firstnonzerodigit:end); elseif (isempty (firstnonzerodigit)) ## All digits are zero isexact = true (); if (hex.s) binary = -0; else binary = 0; endif return endif ## Move point to the left, right after the first significand binary digit if (length (hex.m) > 1) if (hex.e + (length (hex.m) - 1) >= intmax (class (hex.e))) error ("interval:InvalidOperand", ... ["exponent overflow during normalization: " string ]); endif hex.e += length (hex.m) - 1; endif ## Overflow if (hex.e > 1023) isexact = false (); if (hex.s && direction < 0) binary = -inf; elseif (hex.s) binary = -realmax (); elseif (direction > 0) binary = inf; else binary = realmax (); endif return endif ## Underflow if (hex.e < -1074) isexact = false (); if (hex.s && direction < 0) binary = -pow2 (-1074); elseif (hex.s) binary = -0; elseif (direction > 0) binary = pow2 (-1074); else binary = 0; endif return endif if (hex.e < -1022) ## Subnormal numbers hex.m = [zeros(1, -1022 - hex.e), hex.m]; ieee754exponent = -1023; else ## Normal numbers ieee754exponent = hex.e; endif ## Only the most significand 53 bits are relevant. significand = postpad (hex.m, 53, 0, 2); isexact = length (hex.m) <= length (significand) || ... isempty (find (hex.m (54:end), 1)); ## The first bit can be omitted (normalization). significand (1) = []; ## The remaining 52 bits can be converted to 13 hex digits ieee754mantissa = dec2hex (pow2 (51 : -1 : 0) * significand', 13); if (not (hex.s)) ieee754signandexponent = ieee754exponent + 1023; else ieee754signandexponent = ieee754exponent + 1023 + pow2 (11); endif ieee754double = strcat (dec2hex (ieee754signandexponent, 3), ieee754mantissa); binary = hex2num (ieee754double); ## Last, consider the rounding direction if (isexact || ... (direction < 0 && not (hex.s)) || (direction > 0 && hex.s)) ## The number is exact or the truncation of digits above resulted in ## correct rounding direction else delta = pow2 (-1074); binary = mpfr_function_d ('plus', direction, binary, delta); endif endfunctioninterval-1.4.1/inst/@infsup/private/parsedouble.m0000644000000000000000000000414112657475772020233 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypefun {[@var{SIGN}, @var{EXPONENT}, @var{MANTISSA}] =} parsedouble (@var{X}) ## ## Parse a finite binary floating point number @var{X} in double precision. ## ## The mantissa is normalized, the implicit first bit is moved after the point ## @code{@var{X} = (-1) ^ @var{SIGN} * @var{MANTISSA} (=0.XXXXX… in binary) * 2 ^ @var{EXPONENT}}. ## @end deftypefun ## Author: Oliver Heimlich ## Created: 2014-10-24 function [sign, exponent, mantissa] = parsedouble (binary) if (not (isfinite (binary)) || isnan (binary)) assert (false (), "Invalid call to parsedouble"); endif ## Decode bit representation hex = num2hex (binary); # 16 hexadecimal digits (with leading zeros) hexvalues = rem (uint8 (hex) - 47, 39); # 1 .. 16 lookup = [0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1;... 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1;... 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1;... 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1]; bits = (logical (lookup (:, hexvalues))) (:)'; ## Separate sign, exponent, and mantissa bits. sign = bits(1); exponent = bits(2 : 12); fraction = bits(13 : end)'; if (sum (exponent) == 0) # denormalized numbers mantissa = fraction; else # normalized numbers mantissa = [true(); fraction]; endif ## Decode IEEE 754 exponent exponent = int64(pow2 (10 : -1 : 0) * exponent') - 1023; ## binary == (-1) ^ sign * fraction (=X.XXXXX… in binary) * 2 ^ exponent exponent ++; endfunctioninterval-1.4.1/inst/@infsup/private/str2decimal.m0000644000000000000000000001121612657475772020140 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deffun str2decimal (@var{S}) ## ## Parse a decimal number string @var{S} and split the sign, the mantissa and ## the exponent information. ## ## The input number format is [+-]d[,.]d[[eE][+-]d] (cf. str2double). ## ## Limitations: The decimal exponent of the input format must be a number ## between -2^53 (exclusive) and +2^53 (exclusive). ## The number itself either must equal zero or its absolute value must be ## between 10^(-2^62) (inclusive) and 10^(2^63 - 1) (exclusive). ## ## Sign: true (-) or false (+) ## ## Mantissa: Vector that holds the decimal digits after the decimal point. The ## first digit is not zero. Trailing zeroes are removed. ## ## Exponent: Integral exponent (base 10). ## ## @example ## @group ## x = str2decimal ("-12.3e14") ## @result{} ## x.s = 1 ## x.m = [1 2 3]' ## x.e = 16 ## y = str2decimal ("0.00123e-14") ## @result{} ## y.s = 0 ## y.m = [1 2 3]' ## y.e = -12 ## z = str2decimal ("0") ## @result{} ## z.s = 0 ## z.m = [] ## z.e = 0 ## @end group ## @end example ## @seealso{double2decimal} ## @end deffun ## Author: Oliver Heimlich ## Created: 2014-09-27 function decimal = str2decimal (string) ## Strip Sign if (isempty (string)) decimal.s = false; else decimal.s = (string(1) == "-"); if (strfind("+-", string(1))) string = string (2:end); endif endif ## Split mantissa & exponent [decimal.m, decimal.e] = strtok (string, "eE"); ## Convert exponent from string to number if (isempty (decimal.e)) decimal.e = int64(0); # 10 ^ 0 = 1 else if (strfind (decimal.e, ".") || strfind (decimal.e, ",")) error ("interval:InvalidOperand", ... ["invalid decimal number with rational exponent: " string]); endif decimal.e = str2double (decimal.e(2:end)); # remove “e” and convert if (isnan (decimal.e) || ... # greater than realmax or illegal format abs(decimal.e) >= pow2 (53)) # possibly lost precision error ("interval:InvalidOperand", ... ["invalid decimal number with big/invalid exponent: " string]); endif decimal.e = int64 (decimal.e); endif ## Normalize mantissa: remove leading zeroes within string representation ## before decimal point. This does not affect the exponent and is therefore ## preferred over the normalization below, which might produce overflow errors. decimal.m = decimal.m(find(decimal.m ~= "0", 1):end); ## Split Mantissa at decimal point decimal.m = strsplit (decimal.m, {".",","}); switch length(decimal.m) case 0 decimal.m = {"", ""}; case 1 decimal.m{2} = ""; case 2 # nothing to do otherwise error ("interval:InvalidOperand", ... ["invalid decimal number with multiple decimal points: " ... string]); endswitch ## Normalize mantissa string: move decimal point to the left if (decimal.e + length (decimal.m{1}) >= intmax (class (decimal.e))) error ("interval:InvalidOperand", ... ["exponent overflow during normalization: " string ]); endif decimal.e += length (decimal.m{1}); decimal.m = strcat (decimal.m{1}, decimal.m{2}); ## Convert mantissa to numeric vector with decimal digits decimal.m = str2num (decimal.m'); ## Normalize mantissa: remove leading zeroes firstnonzerodigit = find (decimal.m ~= 0, 1, "first"); if (firstnonzerodigit > 1) decimal.m = decimal.m(firstnonzerodigit:end); if (decimal.e - (firstnonzerodigit - 1) <= intmin (class (decimal.e))) error ("interval:InvalidOperand", ... ["exponent overflow during normalization: " string ]); endif decimal.e -= firstnonzerodigit - 1; elseif (isempty (firstnonzerodigit)) # all digits are zero decimal.s = false; decimal.m = []; decimal.e = int64 (0); return endif ## Normalize mantissa: remove trailing zeroes; lastnonzerodigit = find (decimal.m ~= 0, 1, "last"); if (lastnonzerodigit < length (decimal.m)) decimal.m = decimal.m(1:lastnonzerodigit); endif endfunctioninterval-1.4.1/inst/@infsup/private/uncertainsplit.m0000644000000000000000000000513112657475772020772 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypefun {[@var{BOUNDARY}, @var{UNCERTAIN}] =} uncertainsplit (@var{BOUNDARY}) ## ## The the decimal number itself and the decimal number that represents the ## uncertainty for the number. ## @end deftypefun ## Author: Oliver Heimlich ## Created: 2014-10-21 function [boundary, uncertain] = uncertainsplit (boundary) uncertainseparator = find (boundary == "?", 1); assert (not (isempty (uncertainseparator))); exponentseparator = find (lower (boundary) == "e", 1); if (isempty (exponentseparator)) exponentfield = ""; if (uncertainseparator == length (boundary)) ulpcount = ""; else ulpcount = boundary ((uncertainseparator + 1) : end); endif else exponentfield = boundary (exponentseparator : end); ulpcount = boundary ((uncertainseparator + 1) : (exponentseparator - 1)); endif ## Strip uncertain information from the boundary literal = boundary (1 : (uncertainseparator - 1)); boundary = strcat (literal, exponentfield); ## Make a decimal number that represents the uncertainty decimalseparator = find ((literal == ".") + (literal == ","), 1); if (isempty (ulpcount)) ## Half-ULP if (isempty (decimalseparator)) uncertain = "0.5"; else uncertain = strcat (regexprep (literal, "[0-9]", "0"), "5"); endif else uncertain = ulpcount; if (not (isempty (decimalseparator))) ## Insert decimal point in ulp number placesafterpoint = length (literal) - decimalseparator; if (length (uncertain) < length (literal)) uncertain = prepad (uncertain, length (literal), "0", 2); endif uncertain = strcat (uncertain (1 : ... (length (uncertain) - placesafterpoint)), ... ".", ... uncertain ((length (uncertain) - placesafterpoint + 1) ... : length (uncertain))); endif endif uncertain = strcat (uncertain, exponentfield); endfunctioninterval-1.4.1/inst/@infsup/prod.m0000644000000000000000000000520512657475772015222 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} prod (@var{X}) ## @defmethodx {@@infsup} prod (@var{X}, @var{DIM}) ## ## Product of elements along dimension @var{DIM}. If @var{DIM} is omitted, it ## defaults to the first non-singleton dimension. ## ## Accuracy: The result is a valid enclosure. ## ## @example ## @group ## prod (infsup (1 : 4)) ## @result{} ans = [24] ## @end group ## @end example ## @seealso{@@infsup/sum} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-10-23 function result = prod (x, dim) if (nargin > 2) print_usage (); return endif if (nargin < 2) ## Try to find non-singleton dimension dim = find (size (x.inf) > 1, 1); if (isempty (dim)) dim = 1; endif endif switch (dim) case 1 result = infsup (ones (1, max (1, size (x.inf, 2)))); case 2 result = infsup (ones (max (1, size (x.inf, 1)), 1)); otherwise error ("interval:InvalidOperand", ... "prod: DIM must be a valid dimension"); endswitch ## Short circuit in simple cases emptyresult = any (isempty (x), dim); result.inf (emptyresult) = +inf; result.sup (emptyresult) = -inf; zeroresult = not (emptyresult) & any (x.inf == 0 & x.sup == 0, dim); result.inf (zeroresult) = -0; result.sup (zeroresult) = +0; entireresult = not (emptyresult | zeroresult) & any (isentire (x), dim); result.inf (entireresult) = -inf; result.sup (entireresult) = +inf; idx.type = "()"; idx.subs = {":", ":"}; idx.subs{3 - dim} = not (emptyresult | zeroresult | entireresult); if (any (idx.subs{3 - dim})) idx.subs{dim} = 1; result2 = subsref (result, idx); for i = 1 : size (x.inf, dim) idx.subs{dim} = i; result2 = times (result2, subsref (x, idx)); endfor idx.subs{dim} = 1; result = subsasgn (result, idx, result2); endif endfunction %!test "from the documentation string"; %! assert (prod (infsup (1 : 4)) == 24); %!assert (prod (infsup ([])) == 1); interval-1.4.1/inst/@infsup/psi.m0000644000000000000000000000562412657475772015056 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} psi (@var{X}) ## ## Compute the digamma function, also known as the psi function. ## ## @tex ## $$ ## {\rm psi} (x) = \int_0^\infty \left( {{\exp(-t)} \over t} - {{\exp (-xt)} \over {1 - \exp (-t)}} \right) dt ## $$ ## @end tex ## @ifnottex ## @group ## @verbatim ## ∞ ## / exp (-t) exp (-xt) ## psi (x) = | ---------- - -------------- dt ## / t 1 - exp (-t) ## 0 ## @end verbatim ## @end group ## @end ifnottex ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## psi (infsup (1)) ## @result{} ans ⊂ [-0.57722, -0.57721] ## @end group ## @end example ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-28 function result = psi (x) if (nargin ~= 1) print_usage (); return endif u = inf (size (x.inf)); l = -u; ## psi is monotonically increasing, but not defined for non-positive integers. nosingularity = x.inf >= 0 | ceil (x.inf) > floor (x.sup) | ... (ceil (x.inf) == floor (x.sup) & ... (fix (x.inf) == x.inf | fix (x.sup) == x.sup)); if (any (any (nosingularity))) x.inf (x.inf == 0) = 0; # fix negative zero l (nosingularity & (x.inf > 0 | fix (x.inf) ~= x.inf)) = ... mpfr_function_d ('psi', -inf, x.inf (nosingularity)); u (nosingularity & (x.sup > 0 | fix (x.sup) ~= x.sup)) = ... mpfr_function_d ('psi', +inf, x.sup (nosingularity)); endif emptyresult = x.inf == x.sup & fix (x.inf) == x.inf & x.inf <= 0; l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!assert (isempty (psi (infsup (0)))); %!assert (isempty (psi (infsup (-1)))); %!assert (isempty (psi (infsup (-2)))); %!assert (isempty (psi (infsup (-3)))); %!assert (isentire (psi (infsup (-inf, -42.23)))); %!assert (isentire (psi (infsup (0, inf)))); %!assert (isentire (psi (infsup (-1, 0)))); %!assert (isentire (psi (infsup (-2, -1)))); %!assert (isentire (psi (infsup (-eps, eps)))); %!assert (isentire (psi (infsup (-1-eps, -1+eps)))); %!assert (isentire (psi (infsup (-4.1, -3.9)))); %!test "from the documentation string"; %! assert (psi (infsup (1)) == "[-0x1.2788CFC6FB619p-1, -0x1.2788CFC6FB618p-1]"); interval-1.4.1/inst/@infsup/rad.m0000644000000000000000000000406612657475772015030 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {@var{R} =} rad (@var{X}) ## @deftypemethodx {@@infsup} {[@var{M}, @var{R}] =} rad (@var{X}) ## ## Get the radius (and midpoint) of interval @var{X}. ## ## If @var{X} is empty, @code{rad (@var{X})} is NaN. ## If @var{X} is unbounded in one or both directions, @code{rad (@var{X})} is ## positive infinity. ## ## With two output parameters the midpoint and radius are computed. ## ## Accuracy: The radius @var{R} will make a tight enclosure of the interval ## together with midpoint @var{M}. ## ## @example ## @group ## rad (infsup (2.5, 3.5)) ## @result{} ans = 0.50000 ## @end group ## @end example ## @seealso{@@infsup/inf, @@infsup/sup, @@infsup/mid, @@infsup/wid} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-05 function [out1, out2] = rad (x) if (nargin ~= 1) print_usage (); return endif m = mid (x); ## The midpoint is rounded to nearest and the radius must cover both boundaries r1 = mpfr_function_d ('minus', +inf, m, x.inf); r2 = mpfr_function_d ('minus', +inf, x.sup, m); r = max (r1, r2); r (isempty (x)) = nan (); if (nargout >= 2) out1 = m; out2 = r; else out1 = r; endif endfunction %!test; %! [m, r] = rad (infsup (2.5, 3.5)); %! assert (m, 3); %! assert (r, .5); %!test "from the documentation string"; %! assert (rad (infsup (2.5, 3.5)), .5); interval-1.4.1/inst/@infsup/rdivide.m0000644000000000000000000001227312657475772015707 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} rdivide (@var{X}, @var{Y}) ## @defopx Operator {@@infsup} {@var{X} ./ @var{Y}} ## ## Divide all numbers of interval @var{X} by all numbers of @var{Y}. ## ## For @var{X} = 1 compute the reciprocal of @var{Y}. Thus this function can ## compute @code{recip} as defined by IEEE Std 1788-2015. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## x = infsup (2, 3); ## y = infsup (1, 2); ## x ./ y ## @result{} ans = [1, 3] ## @end group ## @end example ## @seealso{@@infsup/times} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-30 function result = rdivide (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsup"))) x = infsup (x); endif if (not (isa (y, "infsup"))) y = infsup (y); elseif (isa (y, "infsupdec")) ## Workaround for bug #42735 result = rdivide (x, y); return endif ## Short-circuit evaluation for 1 ./ x if (all (all (x.inf == 1 & x.sup == 1))) result = recip (y); ## Resize, if scalar × matrix if (isscalar (x.inf) ~= isscalar (y.inf)) result.inf = ones (size (x.inf)) .* result.inf; result.sup = ones (size (x.inf)) .* result.sup; endif return endif ## Resize, if scalar × matrix if (isscalar (x.inf) ~= isscalar (y.inf)) x.inf = ones (size (y.inf)) .* x.inf; x.sup = ones (size (y.inf)) .* x.sup; y.inf = ones (size (x.inf)) .* y.inf; y.sup = ones (size (x.inf)) .* y.sup; endif ## Partitionize the function's domain q1 = x.sup <= 0 & y.sup < 0; q2 = x.sup <= 0 & y.inf > 0; q3 = x.sup <= 0 & y.sup == 0; q4 = x.sup <= 0 & y.sup > 0 & y.inf == 0; q5 = x.inf >= 0 & x.sup > 0 & y.sup < 0; q6 = x.inf >= 0 & x.sup > 0 & y.inf > 0; q7 = x.inf >= 0 & x.sup > 0 & y.sup == 0; q8 = x.inf >= 0 & x.sup > 0 & y.sup > 0 & y.inf == 0; q9 = x.inf < 0 & 0 < x.sup & y.sup < 0; q10 = x.inf < 0 & 0 < x.sup & y.inf > 0; l = u = zeros (size (x.inf)); l (q1) = mpfr_function_d ('rdivide', -inf, x.sup (q1), y.inf (q1)); l (q2) = mpfr_function_d ('rdivide', -inf, x.inf (q2), y.inf (q2)); l (q3) = mpfr_function_d ('rdivide', -inf, x.sup (q3), y.inf (q3)); l (q4) = -inf; l (q5) = mpfr_function_d ('rdivide', -inf, x.sup (q5), y.sup (q5)); l (q6) = mpfr_function_d ('rdivide', -inf, x.inf (q6), y.sup (q6)); l (q7) = -inf; l (q8) = mpfr_function_d ('rdivide', -inf, x.inf (q8), y.sup (q8)); l (q9) = mpfr_function_d ('rdivide', -inf, x.sup (q9), y.sup (q9)); l (q10) = mpfr_function_d ('rdivide', -inf, x.inf (q10), y.inf (q10)); u (q1) = mpfr_function_d ('rdivide', +inf, x.inf (q1), y.sup (q1)); u (q2) = mpfr_function_d ('rdivide', +inf, x.sup (q2), y.sup (q2)); u (q3) = inf; u (q4) = mpfr_function_d ('rdivide', +inf, x.sup (q4), y.sup (q4)); u (q5) = mpfr_function_d ('rdivide', +inf, x.inf (q5), y.inf (q5)); u (q6) = mpfr_function_d ('rdivide', +inf, x.sup (q6), y.inf (q6)); u (q7) = mpfr_function_d ('rdivide', +inf, x.inf (q7), y.inf (q7)); u (q8) = inf; u (q9) = mpfr_function_d ('rdivide', +inf, x.inf (q9), y.sup (q9)); u (q10) = mpfr_function_d ('rdivide', +inf, x.sup (q10), y.inf (q10)); entireresult = (y.inf < 0 & y.sup > 0) | (x.inf < 0 & x.sup > 0 & ... (y.inf == 0 | y.sup == 0)); l (entireresult) = -inf; u (entireresult) = inf; zeroresult = x.inf == 0 & x.sup == 0; l (zeroresult) = u (zeroresult) = 0; emptyresult = isempty (x) | isempty (y) | (y.inf == 0 & y.sup == 0); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction function result = recip (x) ## Compute the reciprocal of @var{X}. ## ## The result is equivalent to @code{1 ./ @var{X}}, but is computed more ## efficiently. ## ## Accuracy: The result is a tight enclosure. l = inf (size (x.inf)); u = -l; ## Fix signs to make use of limit values for 1 ./ x. x.inf(x.inf == 0) = +0; x.sup(x.sup == 0) = -0; select = (x.inf >= 0 | x.sup <= 0) & ... # undefined for x = [0, 0] not (x.inf == 0 & x.sup == 0) & ... # x is not empty x.inf < inf; if (any (any (select))) ## recip is monotonically decreasing l(select) = mpfr_function_d ('rdivide', -inf, 1, x.sup(select)); u(select) = mpfr_function_d ('rdivide', +inf, 1, x.inf(select)); endif ## singularity at x = 0 select = x.inf < 0 & x.sup > 0; if (any (any (select))) l(select) = -inf; u(select) = +inf; endif result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (infsup (2, 3) ./ infsup (1, 2) == infsup (1, 3)); %!assert (1 ./ infsup (1, 4) == infsup (0.25, 1)); interval-1.4.1/inst/@infsup/realsqrt.m0000644000000000000000000000301512657475772016110 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} realsqrt (@var{X}) ## ## Compute the square root (for all non-negative numbers). ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## realsqrt (infsup (-6, 4)) ## @result{} ans = [0, 2] ## @end group ## @end example ## @seealso{@@infsup/sqr, @@infsup/rsqrt, @@infsup/pow, @@infsup/cbrt, @@infsup/nthroot} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-01 function result = realsqrt (x) l = mpfr_function_d ('realsqrt', -inf, max (0, x.inf)); u = mpfr_function_d ('realsqrt', +inf, max (0, x.sup)); emptyresult = isempty (x) | x.sup < 0; l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (realsqrt (infsup (-6, 4)) == infsup (0, 2)); interval-1.4.1/inst/@infsup/recip.m0000644000000000000000000000273412657475772015364 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} recip (@var{X}) ## ## Compute the reciprocal of @var{X}. ## ## THIS FUNCTION IS DEPRECATED AND WILL BE REMOVED IN A FUTURE RELEASE OF THIS ## SOFTWARE. PLEASE USE @code{1 ./ @var{X}} INSTEAD. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## recip (infsup (1, 4)) @c doctest: +SKIP ## @result{} ans = [0.25, 1] ## @end group ## @end example ## @seealso{@@infsup/inv, @@infsup/rdivide} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-11-07 function result = recip (x) if (nargin ~= 1) print_usage (); return endif warning ("interval:deprecated", ... "recip: This function is deprecated, please use 1 ./ x instead") result = rdivide (1, x); endfunction interval-1.4.1/inst/@infsup/reshape.m0000644000000000000000000000431512657475772015706 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} reshape (@var{A}, @var{M}, @var{N}) ## @defmethodx {@@infsup} reshape (@var{X}, [@var{M} @var{N}]) ## ## Return an interval matrix with the specified dimensions (M, N) whose ## elements are taken from the interval matrix @var{A}. The elements of the ## matrix are accessed in column-major order (like Fortran arrays are stored). ## ## Note that the total number of elements in the original matrix ## (@code{prod (size (@var{A}))}) must match the total number of elements in ## the new matrix (@code{prod ([@var{M} @var{N}])}). ## ## @example ## @group ## reshape (infsup (1 : 6), 2, 3) ## @result{} ans = 2×3 interval matrix ## [1] [3] [5] ## [2] [4] [6] ## @end group ## @end example ## @seealso{@@infsup/resize, @@infsup/cat, @@infsup/postpad, @@infsup/prepad} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-19 function result = reshape (a, m, n) switch nargin case 2 if (numel (m) ~= 2) error ("interval:InvalidOperand", ... "reshape: SIZE must have 2 dimensions") else n = m (2); m = m (1); endif case 3 ## Nothing to do otherwise print_usage (); return endswitch if (not (isa (a, "infsup"))) print_usage (); return endif l = reshape (a.inf, m, n); u = reshape (a.sup, m, n); result = infsup (l, u); endfunction %!assert (reshape (infsup (1 : 6), 2, 3) == infsup (reshape (1 : 6, 2, 3))); interval-1.4.1/inst/@infsup/resize.m0000644000000000000000000000565112657475772015564 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} resize (@var{X}, @var{M}) ## @defmethodx {@@infsup} resize (@var{X}, @var{M}, @var{N}) ## @defmethodx {@@infsup} resize (@var{X}, [@var{M} @var{N}]) ## ## Resize interval matrix @var{X} cutting off elements as necessary. ## ## In the result, element with certain indices is equal to the corresponding ## element of @var{X} if the indices are within the bounds of @var{X}; ## otherwise, the element is set to the empty interval. ## ## If only @var{M} is supplied, and it is a scalar, the dimension of the result ## is @var{M}-by-@var{M}. If @var{M} and @var{N} are all scalars, then the ## dimensions of the result are @var{M}-by-@var{N}. If given a vector as ## input, then the dimensions of the result are given by the elements of that ## vector. ## ## @example ## @group ## resize (infsup (magic (3)), 4, 2) ## @result{} ans = 4×2 interval matrix ## [8] [1] ## [3] [5] ## [4] [9] ## [Empty] [Empty] ## @end group ## @end example ## @seealso{@@infsup/reshape, @@infsup/cat, @@infsup/postpad, @@infsup/prepad} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-19 function result = resize (x, m, n) switch nargin case 2 if (isempty (m)) m = n = 0; elseif (isscalar (m)) n = m; elseif (numel (m) > 2) error ("interval:InvalidOperand", ... "resize: no more than 2 dimensions are supported") else n = m (2); m = m (1); endif case 3 ## Nothing to do otherwise print_usage (); return endswitch if (not (isa (x, "infsup"))) print_usage (); return endif l = resize (x.inf, m, n); u = resize (x.sup, m, n); ## Implicit new elements in the matrices take the value 0. We can detect them ## in the inf matrix, because zeros in the inf matrix are set to -0 by the ## infsup constructor. newelements = not (signbit (l)) & (l == 0); ## Set the implicit new elements to [Empty]. l (newelements) = inf; u (newelements) = -inf; result = infsup (l, u); endfunction %!assert (resize (infsup (magic (3)), 4, 2) == [infsup([8, 1; 3, 5; 4, 9]); infsup([inf, inf], [-inf, -inf])]); interval-1.4.1/inst/@infsup/round.m0000644000000000000000000000505012657475772015403 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} round (@var{X}) ## ## Round each number in interval @var{X} to the nearest integer. Ties are ## rounded away from zero (towards +Inf or -Inf depending on the sign). ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## round (infsup (2.5, 3.5)) ## @result{} ans = [3, 4] ## round (infsup (-0.5, 5)) ## @result{} ans = [-1, +5] ## @end group ## @end example ## @seealso{@@infsup/floor, @@infsup/ceil, @@infsup/roundb, @@infsup/fix} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-04 function result = round (x) if (nargin ~= 1) print_usage (); return endif result = infsup (round (x.inf), round (x.sup)); endfunction %!test "Empty interval"; %! assert (round (infsup ()) == infsup ()); %!test "Singleton intervals"; %! assert (round (infsup (0)) == infsup (0)); %! assert (round (infsup (0.5)) == infsup (1)); %! assert (round (infsup (0.25)) == infsup (0)); %! assert (round (infsup (0.75)) == infsup (1)); %! assert (round (infsup (-0.5)) == infsup (-1)); %!test "Bounded intervals"; %! assert (round (infsup (-0.5, 0)) == infsup (-1, 0)); %! assert (round (infsup (0, 0.5)) == infsup (0, 1)); %! assert (round (infsup (0.25, 0.5)) == infsup (0, 1)); %! assert (round (infsup (-1, 0)) == infsup (-1, 0)); %! assert (round (infsup (-1, 1)) == infsup (-1, 1)); %! assert (round (infsup (-realmin, realmin)) == infsup (0)); %! assert (round (infsup (-realmax, realmax)) == infsup (-realmax, realmax)); %!test "Unbounded intervals"; %! assert (round (infsup (-realmin, inf)) == infsup (0, inf)); %! assert (round (infsup (-realmax, inf)) == infsup (-realmax, inf)); %! assert (round (infsup (-inf, realmin)) == infsup (-inf, 0)); %! assert (round (infsup (-inf, realmax)) == infsup (-inf, realmax)); %! assert (round (infsup (-inf, inf)) == infsup (-inf, inf)); interval-1.4.1/inst/@infsup/roundb.m0000644000000000000000000000517512657475772015555 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} roundb (@var{X}) ## ## Round each number in interval @var{X} to the nearest integer. Ties are ## rounded towards the nearest even integer. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## roundb (infsup (2.5, 3.5)) ## @result{} ans = [2, 4] ## roundb (infsup (-0.5, 5.5)) ## @result{} ans = [0, 6] ## @end group ## @end example ## @seealso{@@infsup/floor, @@infsup/ceil, @@infsup/round, @@infsup/fix} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-04 function result = roundb (x) if (nargin ~= 1) print_usage (); return endif result = infsup (roundb (x.inf), roundb (x.sup)); endfunction %!test "Empty interval"; %! assert (roundb (infsup ()) == infsup ()); %!test "Singleton intervals"; %! assert (roundb (infsup (0)) == infsup (0)); %! assert (roundb (infsup (0.5)) == infsup (0)); %! assert (roundb (infsup (0.25)) == infsup (0)); %! assert (roundb (infsup (0.75)) == infsup (1)); %! assert (roundb (infsup (1.5)) == infsup (2)); %! assert (roundb (infsup (-0.5)) == infsup (0)); %! assert (roundb (infsup (-1.5)) == infsup (-2)); %!test "Bounded intervals"; %! assert (roundb (infsup (-0.5, 0)) == infsup (0)); %! assert (roundb (infsup (0, 0.5)) == infsup (0)); %! assert (roundb (infsup (0.25, 0.5)) == infsup (0)); %! assert (roundb (infsup (-1, 0)) == infsup (-1, 0)); %! assert (roundb (infsup (-1, 1)) == infsup (-1, 1)); %! assert (roundb (infsup (-realmin, realmin)) == infsup (0)); %! assert (roundb (infsup (-realmax, realmax)) == infsup (-realmax, realmax)); %!test "Unbounded intervals"; %! assert (roundb (infsup (-realmin, inf)) == infsup (0, inf)); %! assert (roundb (infsup (-realmax, inf)) == infsup (-realmax, inf)); %! assert (roundb (infsup (-inf, realmin)) == infsup (-inf, 0)); %! assert (roundb (infsup (-inf, realmax)) == infsup (-inf, realmax)); %! assert (roundb (infsup (-inf, inf)) == infsup (-inf, inf)); interval-1.4.1/inst/@infsup/rows.m0000644000000000000000000000221112657475772015242 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} rows (@var{A}) ## ## Return the number of rows of @var{A}. ## @seealso{@@infsup/numel, @@infsup/size, @@infsup/length, @@infsup/columns} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-29 function result = rows (a) if (nargin ~= 1) print_usage (); return endif result = rows (a.inf); endfunction %!test; %! assert (rows (infsup (zeros (3, 4))), 3); interval-1.4.1/inst/@infsup/rsqrt.m0000644000000000000000000000272012657475772015430 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} rsqrt (@var{X}) ## ## Compute the reciprocal square root (for all positive numbers). ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## rsqrt (infsup (-6, 4)) ## @result{} ans = [0.5, Inf] ## @end group ## @end example ## @seealso{@@infsup/realsqrt} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-03-15 function result = rsqrt (x) l = mpfr_function_d ('rsqrt', -inf, max (0, x.sup)); u = mpfr_function_d ('rsqrt', +inf, max (0, x.inf)); emptyresult = isempty (x) | x.sup <= 0; l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (rsqrt (infsup (-6, 4)) == infsup (.5, inf)); interval-1.4.1/inst/@infsup/sdist.m0000644000000000000000000000544112657475772015406 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} sdist (@var{X}, @var{Y}) ## ## Compute the signed distance between two intervals as sets. ## ## The signed distance for closed real intervals is the minimum distance ## between each pair of numbers, where the result's sign indicates whether ## @var{x} precedes @var{y} (negative), @var{y} precedes @var{x} (positive), or ## @var{x} intersects @var{y} (zero). That is, the signed distance equals zero ## if a number can be found in both intervals. Otherwise the signed distance ## is the positive or negative size of the gap between both intervals on the ## real number lane. ## ## If any interval is empty, the result is NaN. For interval matrices the ## result is computed entry-wise. ## ## Accuracy: The result is correctly-rounded (away from zero). ## ## @example ## @group ## sdist (infsup (0, 6), infsup (7, 20)) ## @result{} ans = -1 ## sdist (infsup (3, 5), infsup (0, 1)) ## @result{} ans = 2 ## @end group ## @end example ## @seealso{@@infsup/idist, @@infsup/hdist} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-06-11 function result = sdist (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsup"))) x = infsup (x); endif if (not (isa (y, "infsup"))) y = infsup (y); endif ## Resize, if scalar × matrix if (isscalar (x.inf) ~= isscalar (y.inf)) x.inf = ones (size (y.inf)) .* x.inf; x.sup = ones (size (y.inf)) .* x.sup; y.inf = ones (size (x.inf)) .* y.inf; y.sup = ones (size (x.inf)) .* y.sup; endif result = zeros (size (x.inf)); select = x.sup < y.inf; if (any (any (select))) result (select) = ... mpfr_function_d ('minus', -inf, x.sup (select), y.inf (select)); endif select = x.inf > y.sup; if (any (any (select))) result (select) = max (result (select), ... mpfr_function_d ('minus', +inf, x.inf (select), y.sup (select))); endif result (isempty (x) | isempty (y)) = nan (); endfunction %!test "from the documentation string"; %! assert (sdist (infsup (0, 6), infsup (7, 20)), -1); %! assert (sdist (infsup (3, 5), infsup (0, 1)), 2); interval-1.4.1/inst/@infsup/sec.m0000644000000000000000000000545612657475772015040 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} sec (@var{X}) ## ## Compute the secant in radians, that is the reciprocal cosine. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## sec (infsup (1)) ## @result{} ans ⊂ [1.8508, 1.8509] ## @end group ## @end example ## @seealso{@@infsup/cos, @@infsup/csc, @@infsup/cot} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-03-15 function result = sec (x) if (nargin ~= 1) print_usage (); return endif l = u = derivl = derivu = zeros (size (x.inf)); ## Check, if wid (x) is certainly greater than 2*pi. This can save the ## computation if some values. width = mpfr_function_d ('minus', -inf, x.sup, x.inf); pi.sup = 0x6487ED5 * pow2 (-25) + 0x442D190 * pow2 (-55); certainlysingularity = width >= pi.sup; ## We simply compute the secant for both endpoints. select = not (certainlysingularity); l (select) = min (... mpfr_function_d ('sec', -inf, x.inf (select)), ... mpfr_function_d ('sec', -inf, x.sup (select))); u (select) = max (... mpfr_function_d ('sec', inf, x.inf (select)), ... mpfr_function_d ('sec', inf, x.sup (select))); ## A change of sign is a sufficient singularity indicator certainlysingularity = certainlysingularity | (select & sign (l) ~= sign (u)); l (certainlysingularity) = -inf; u (certainlysingularity) = inf; ## Check, whether the interval contains a local extremum using the derivative select = not (certainlysingularity); derivl (select) = mpfr_function_d ('sec', 0, x.inf (select)) .* ... mpfr_function_d ('tan', 0, x.inf (select)); derivu (select) = mpfr_function_d ('sec', 0, x.sup (select)) .* ... mpfr_function_d ('tan', 0, x.sup (select)); hasextremum = select & ((derivl <= 0 & derivu >= 0) | ... (derivl >= 0 & derivu <= 0)); l (hasextremum & l > 0) = 1; u (hasextremum & u < 0) = -1; emptyresult = isempty (x); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (sec (infsup (1)) == "[0x1.D9CF0F125CC29, 0x1.D9CF0F125CC2A]"); interval-1.4.1/inst/@infsup/sech.m0000644000000000000000000000305212657475772015176 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} sech (@var{X}) ## ## Compute the hyperbolic secant, that is the reciprocal hyperbolic cosine. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## sech (infsup (1)) ## @result{} ans ⊂ [0.64805, 0.64806] ## @end group ## @end example ## @seealso{@@infsup/cosh, @@infsup/csch, @@infsup/coth} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-03-15 function result = sech (x) if (nargin ~= 1) print_usage (); return endif l = mpfr_function_d ('sech', -inf, mag (x)); u = mpfr_function_d ('sech', +inf, mig (x)); emptyresult = isempty (x); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (sech (infsup (1)) == "[0x1.4BCDC50ED6BE7p-1, 0x1.4BCDC50ED6BE8p-1]"); interval-1.4.1/inst/@infsup/setdiff.m0000644000000000000000000000457712657475772015715 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} setdiff (@var{A}, @var{B}) ## ## Build the relative complement of interval @var{B} in interval @var{A}. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## x = infsup (1, 3); ## y = infsup (2, 4); ## setdiff (x, y) ## @result{} ans = [1, 2] ## @end group ## @end example ## @seealso{@@infsup/intersect, @@infsup/union, @@infsup/setxor} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-03 function result = setdiff (a, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (a, "infsup"))) a = infsup (a); endif if (not (isa (b, "infsup"))) b = infsup (b); endif ## Resize, if scalar × matrix if (isscalar (a.inf) ~= isscalar (b.inf)) a.inf = ones (size (b.inf)) .* a.inf; a.sup = ones (size (b.inf)) .* a.sup; b.inf = ones (size (a.inf)) .* b.inf; b.sup = ones (size (a.inf)) .* b.sup; endif l = a.inf; u = a.sup; select = b.sup >= a.sup & b.inf > a.inf; u (select) = min (u (select), b.inf (select)); select = b.inf <= a.inf & b.sup < a.sup; l (select) = max (l (select), b.sup (select)); emptyresult = b.inf <= a.inf & b.sup >= a.sup; l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!assert (isempty (setdiff (infsup (), infsup (1, 4)))); %!assert (setdiff (infsup (1, 3), infsup ()) == infsup (1, 3)); %!assert (isempty (setdiff (infsup (1, 3), infsup (-inf, inf)))); %!assert (isempty (setdiff (infsup (1, 3), infsup (1, 4)))); %!assert (setdiff (infsup (-inf, inf), infsup (1, 4)) == infsup (-inf, inf)); %!test "from the documentation string"; %! assert (setdiff (infsup (1, 3), infsup (2, 4)) == infsup (1, 2)); interval-1.4.1/inst/@infsup/setxor.m0000644000000000000000000000763212657475772015610 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {} setxor (@var{A}, @var{B}) ## @deftypemethodx {@@infsup} {[@var{C}, @var{C1}, @var{C2}] =} setxor (@var{A}, @var{B}) ## ## Build the symmetric difference of intervals @var{A} and @var{B}. ## ## With three output arguments, return intervals @var{C1} and @var{C2} such ## that @var{C1} and @var{C2} are enclosures of disjoint sets whose union is ## enclosed by interval @var{C}. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## x = infsup (1, 3); ## y = infsup (2, 4); ## [z, z1, z2] = setxor (x, y) ## @result{} ## z = [1, 4] ## z1 = [1, 2] ## z2 = [3, 4] ## @end group ## @end example ## @seealso{@@infsup/intersect, @@infsup/union, @@infsup/setdiff} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-03 function [c, c1, c2] = setxor (a, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (a, "infsup"))) a = infsup (a); endif if (not (isa (b, "infsup"))) b = infsup (b); endif ## Resize, if scalar × matrix if (isscalar (a.inf) ~= isscalar (b.inf)) a.inf = ones (size (b.inf)) .* a.inf; a.sup = ones (size (b.inf)) .* a.sup; b.inf = ones (size (a.inf)) .* b.inf; b.sup = ones (size (a.inf)) .* b.sup; endif ## Sort the four boundaries in ascending order b1 <= b2 <= b3 <= b4, ## if only one empty interval is present, then [b2, b3] = [Empty], ## with two empty intervals we also have [b1, b4] = [Empty]. b1 = min (a.inf, b.inf); b2 = max (a.inf, b.inf); b3 = min (a.sup, b.sup); b4 = max (a.sup, b.sup); [b2, b3] = deal (min (b2, b3), max (b2, b3)); l = b1; u = b4; select = a.inf == b.inf; l (select) = b3 (select); select = a.sup == b.sup; u (select) = b2 (select); select = a.inf == b.inf & a.sup == b.sup; l (select) = inf; u (select) = -inf; c = infsup (l, u); if (nargout > 1) select = isempty (a) | isempty (b); b1 (select) = a.inf (select); b2 (select) = a.sup (select); b3 (select) = b.inf (select); b4 (select) = b.sup (select); l1 = b1; u1 = b2; select = a.inf == b.inf; l1 (select) = inf; u1 (select) = -inf; c1 = infsup (l1, u1); l2 = b3; u2 = b4; select = a.sup == b.sup; l2 (select) = inf; u2 (select) = -inf; c2 = infsup (l2, u2); endif endfunction %!test %! [z, z1, z2] = setxor (infsup (), infsup ()); %! assert (isempty (z)); %! assert (isempty (z1)); %! assert (isempty (z2)); %!test %! [z, z1, z2] = setxor (infsup (-inf, inf), infsup ()); %! assert (isentire (z)); %! assert (isentire (z1)); %! assert (isempty (z2)); %!test %! [z, z1, z2] = setxor (infsup (-inf, inf), infsup (2)); %! assert (isentire (z)); %! assert (z1 == infsup (-inf, 2)); %! assert (z2 == infsup (2, inf)); %!test %! [z, z1, z2] = setxor (infsup (2, 3), infsup (2)); %! assert (z == infsup (2, 3)); %! assert (z1 == infsup ()); %! assert (z2 == infsup (2, 3)); %!test %! [z, z1, z2] = setxor (infsup (2, 3), infsup (2, 2.5)); %! assert (z == infsup (2.5, 3)); %! assert (z1 == infsup ()); %! assert (z2 == infsup (2.5, 3)); %!test "from the documentation string"; %! [z, z1, z2] = setxor (infsup (1, 3), infsup (2, 4)); %! assert (z == infsup (1, 4)); %! assert (z1 == infsup (1, 2)); %! assert (z2 == infsup (3, 4)); interval-1.4.1/inst/@infsup/sign.m0000644000000000000000000000311412657475772015213 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} sign (@var{X}) ## ## Compute the signum function for each number in interval @var{X}. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## sign (infsup (2, 3)) ## @result{} ans = [1] ## sign (infsup (0, 5)) ## @result{} ans = [0, 1] ## sign (infsup (-17)) ## @result{} ans = [-1] ## @end group ## @end example ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-04 function result = sign (x) if (nargin ~= 1) print_usage (); return endif l = sign (x.inf); u = sign (x.sup); emptyresult = isempty (x); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (sign (infsup (2, 3)) == infsup (1)); %! assert (sign (infsup (0, 5)) == infsup (0, 1)); %! assert (sign (infsup (-17)) == infsup (-1)); interval-1.4.1/inst/@infsup/sin.m0000644000000000000000000000614012657475772015046 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} sin (@var{X}) ## ## Compute the sine in radians. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## sin (infsup (1)) ## @result{} ans ⊂ [0.84147, 0.84148] ## @end group ## @end example ## @seealso{@@infsup/asin, @@infsup/csc, @@infsup/sinh} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-05 function result = sin (x) if (nargin ~= 1) print_usage (); return endif l = u = cossignl = cossignu = zeros (size (x.inf)); ## Check, if wid (x) is certainly greater than 2*pi. This can save the ## computation if some sine values. width = mpfr_function_d ('minus', -inf, x.sup, x.inf); pi.sup = 0x6487ED5 * pow2 (-25) + 0x442D190 * pow2 (-55); twopi.sup = 2 * pi.sup; certainlyfullperiod = width >= twopi.sup; l (certainlyfullperiod) = -1; u (certainlyfullperiod) = 1; possiblynotfullperiod = not (certainlyfullperiod); l (possiblynotfullperiod) = min (... mpfr_function_d ('sin', -inf, x.inf (possiblynotfullperiod)), ... mpfr_function_d ('sin', -inf, x.sup (possiblynotfullperiod))); u (possiblynotfullperiod) = max (... mpfr_function_d ('sin', inf, x.inf (possiblynotfullperiod)), ... mpfr_function_d ('sin', inf, x.sup (possiblynotfullperiod))); ## We use sign (cos) to know the gradient at the boundaries. cossignl (possiblynotfullperiod) = sign (... mpfr_function_d ('cos', .5, x.inf (possiblynotfullperiod))); cossignu (possiblynotfullperiod) = sign (... mpfr_function_d ('cos', .5, x.sup (possiblynotfullperiod))); ## In case of sign (cos) == 0, we conservatively use sign (cos) of nextout. cossignl (cossignl == 0) = sign (l (cossignl == 0)); cossignu (cossignu == 0) = (-1) * sign (u (cossignu == 0)); containsinf = possiblynotfullperiod & ((cossignl == -1 & cossignu == 1) | ... (cossignl == cossignu & ... width >= pi.sup)); l (containsinf) = -1; containssup = possiblynotfullperiod & ((cossignl == 1 & cossignu == -1) | ... (cossignl == cossignu & ... width >= pi.sup)); u (containssup) = 1; emptyresult = isempty (x); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (sin (infsup (1)) == "[0x1.AED548F090CEEp-1, 0x1.AED548F090CEFp-1]"); interval-1.4.1/inst/@infsup/sinh.m0000644000000000000000000000300212657475772015210 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} sinh (@var{X}) ## ## Compute the hyperbolic sine. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## sinh (infsup (1)) ## @result{} ans ⊂ [1.1752, 1.1753] ## @end group ## @end example ## @seealso{@@infsup/asinh, @@infsup/csch, @@infsup/cosh, @@infsup/tanh} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-06 function result = sinh (x) if (nargin ~= 1) print_usage (); return endif l = mpfr_function_d ('sinh', -inf, x.inf); u = mpfr_function_d ('sinh', +inf, x.sup); emptyresult = isempty (x); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (sinh (infsup (1)) == "[0x1.2CD9FC44EB982, 0x1.2CD9FC44EB983]"); interval-1.4.1/inst/@infsup/sinrev.m0000644000000000000000000001214612657475772015566 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {@var{X} =} sinrev (@var{C}, @var{X}) ## @deftypemethodx {@@infsup} {@var{X} =} sinrev (@var{C}) ## ## Compute the reverse sine function. ## ## That is, an enclosure of all @code{x ∈ @var{X}} where ## @code{sin (x) ∈ @var{C}}. ## ## Accuracy: The result is a valid enclosure. ## ## @example ## @group ## sinrev (infsup (-1), infsup (0, 6)) ## @result{} ans ⊂ [4.7123, 4.7124] ## @end group ## @end example ## @seealso{@@infsup/sin} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-19 function result = sinrev (c, x) if (nargin > 2) print_usage (); return endif if (nargin < 2) x = infsup (-inf, inf); endif if (not (isa (c, "infsup"))) c = infsup (c); endif if (not (isa (x, "infsup"))) x = infsup (x); endif arcsine = asin (c); result = x; ## Resize, if scalar × matrix if (isscalar (arcsine.inf) ~= isscalar (result.inf)) arcsine.inf = ones (size (result.inf)) .* arcsine.inf; arcsine.sup = ones (size (result.inf)) .* arcsine.sup; result.inf = ones (size (arcsine.inf)) .* result.inf; result.sup = ones (size (arcsine.inf)) .* result.sup; endif result.inf (isempty (arcsine)) = inf; result.sup (isempty (arcsine)) = -inf; idx.type = '()'; pi = infsup ("pi"); select = not (isempty (result)) ... & not (subset (infsup (-pi.sup / 2, pi.sup / 2), arcsine)); if (any (any (select))) ## Find a smaller upper bound for x, if the restriction from c allows it u = inf (size (result.inf)); select_u = select & result.sup < inf; ## Find n, such that result.sup is within a distance of pi/2 around n * pi. n = result.sup; n (select_u) = ceil (floor (sup (n (select_u) ./ (pi ./ 2))) ./ 2); arcsineshifted = arcsine; idx.subs = {(select_u & rem (n, 2) == 0)}; arcsineshifted = subsasgn (arcsineshifted, idx, ... subsref (arcsineshifted, idx) + subsref (n, idx) .* pi); idx.subs = {(select_u & rem (n, 2) ~= 0)}; arcsineshifted = subsasgn (arcsineshifted, idx, ... subsref (n, idx) .* pi - subsref (arcsineshifted, idx)); overlapping = not (isempty (intersect (result, arcsineshifted))); u (select_u & overlapping) = ... min (result.sup (select_u & overlapping), ... arcsineshifted.sup (select_u & overlapping)); m = n; m (select_u & ~overlapping) = ... mpfr_function_d ('minus', +inf, m (select_u & ~overlapping), 1); idx.subs = {(select_u & ~overlapping & rem (n, 2) == 0)}; u (idx.subs {1}) = ... sup (subsref (m, idx) .* pi - subsref (arcsine, idx)); idx.subs = {(select_u & ~overlapping & rem (n, 2) ~= 0)}; u (idx.subs {1}) = ... sup (subsref (arcsine, idx) + subsref (m, idx) .* pi); ## Find a larger lower bound for x, if the restriction from c allows it l = -inf (size (result.inf)); select_l = select & result.inf > -inf; ## Find n, such that result.inf is within a distance of pi/2 around n * pi. n = result.inf; n (select_l) = floor (ceil (inf (n (select_l) ./ (pi ./ 2))) ./ 2); arcsineshifted = arcsine; idx.subs = {(select_l & rem (n, 2) == 0)}; arcsineshifted = subsasgn (arcsineshifted, idx, ... subsref (arcsineshifted, idx) + subsref (n, idx) .* pi); idx.subs = {(select_l & rem (n, 2) ~= 0)}; arcsineshifted = subsasgn (arcsineshifted, idx, ... subsref (n, idx) .* pi - subsref (arcsineshifted, idx)); overlapping = not (isempty (intersect (result, arcsineshifted))); l (select_l & overlapping) = ... max (result.inf (select_l & overlapping), ... arcsineshifted.inf (select_l & overlapping)); m = n; m (select_l & ~overlapping) = ... mpfr_function_d ('plus', -inf, m (select_l & ~overlapping), 1); idx.subs = {(select_l & ~overlapping & rem (n, 2) == 0)}; l (idx.subs {1}) = ... inf (subsref (m, idx) .* pi - subsref (arcsine, idx)); idx.subs = {(select_l & ~overlapping & rem (n, 2) ~= 0)}; l (idx.subs {1}) = ... inf (subsref (arcsine, idx) + subsref (m, idx) .* pi); result.inf (select) = max (l (select), result.inf (select)); result.sup (select) = min (u (select), result.sup (select)); result.inf (result.inf > result.sup) = inf; result.sup (result.inf > result.sup) = -inf; endif endfunction %!test "from the documentation string"; %! assert (sinrev (infsup (-1), infsup (0, 6)) == "[0x1.2D97C7F3321D2p2, 0x1.2D97C7F3321D3p2]"); interval-1.4.1/inst/@infsup/size.m0000644000000000000000000000337412657475772015235 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} size (@var{A}) ## @defmethodx {@@infsup} size (@var{A}, @var{DIM}) ## ## Return the number of rows and columns of @var{A}. ## ## With one input argument and one output argument, the result is returned in a ## row vector. If there are multiple output arguments, the number of rows is ## assigned to the first, and the number of columns to the second, etc. ## ## If given a second argument, @code{size} will return the size of the ## corresponding dimension. ## @seealso{@@infsup/length, @@infsup/numel, @@infsup/rows, @@infsup/columns} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-29 function varargout = size (a, dim) if (nargin == 0 || nargin > 2) print_usage (); return endif if (nargin == 1) if (nargout <= 1) varargout {1} = size (a.inf); else varargout = mat2cell (size (a.inf) (1 : nargout)', ones (nargout, 1)); endif else varargout {1} = size (a.inf, dim); endif endfunction %!test; %! assert (size (infsup (zeros (3, 4))), [3 4]); interval-1.4.1/inst/@infsup/smig.m0000644000000000000000000000307112657475772015214 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} smig (@var{X}) ## ## Get the signed mignitude of numbers in interval @var{X}, that is the unique ## number closest to zero for each element. ## ## If @var{X} is empty, @code{smig (@var{X})} is NaN. ## ## Accuracy: The result is exact. ## ## @example ## @group ## smig (infsup (-2, -1)) ## @result{} ans = -1 ## @end group ## @end example ## @seealso{@@infsup/mig, @@infsup/mag, @@infsup/inf, @@infsup/sup} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-06-13 function result = smig (x) if (nargin ~= 1) print_usage (); return endif result = zeros (size (x.inf)); result (x.inf > 0) = x.inf; result (x.sup < 0) = x.sup; result (isempty (x)) = nan (); endfunction %!assert (smig (infsup (-1, 2)), 0); %!assert (smig (infsup (-42, -23)), -23); %!assert (smig (infsup (23, 42)), 23); interval-1.4.1/inst/@infsup/sqr.m0000644000000000000000000000275312657475772015070 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} sqr (@var{X}) ## ## Compute the square for each entry in @var{X}. ## ## THIS FUNCTION IS DEPRECATED AND WILL BE REMOVED IN A FUTURE RELEASE OF THIS ## SOFTWARE. PLEASE USE @code{@var{X} .^ 2} INSTEAD. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## sqr (infsup (-2, 1)) @c doctest: +SKIP ## @result{} ans = [0, 4] ## @end group ## @end example ## @seealso{@@infsup/realsqrt, @@infsup/pown, @@infsup/pow} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-30 function result = sqr (x) if (nargin ~= 1) print_usage (); return endif warning ("interval:deprecated", ... "sqr: This function is deprecated, please use x .^ 2 instead") result = power (x, 2); endfunction interval-1.4.1/inst/@infsup/sqrrev.m0000644000000000000000000000326212657475772015601 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {@var{X} =} sqrrev (@var{C}, @var{X}) ## @deftypemethodx {@@infsup} {@var{X} =} sqrrev (@var{C}) ## ## Compute the reverse square function. ## ## That is, an enclosure of all @code{x ∈ @var{X}} where ## @code{sqr (x) ∈ @var{C}}. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## sqrrev (infsup (-2, 1)) ## @result{} ans = [-1, +1] ## @end group ## @end example ## @seealso{@@infsup/sqr} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = sqrrev (c, x) if (nargin > 2) print_usage (); return endif if (nargin < 2) x = infsup (-inf, inf); endif if (not (isa (c, "infsup"))) c = infsup (c); endif if (not (isa (x, "infsup"))) x = infsup (x); endif p = sqrt (c); n = - p; result = union (intersect (p, x), intersect (n, x)); endfunction %!test "from the documentation string"; %! assert (sqrrev (infsup (-2, 1)) == infsup (-1, 1)); interval-1.4.1/inst/@infsup/sqrt.m0000644000000000000000000000271112657475772015246 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} sqrt (@var{X}) ## ## Compute the square root (for all non-negative numbers). ## ## Since intervals are only defined for real numbers, this function and ## @code{realsqrt} are equivalent. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## sqrt (infsup (-6, 4)) ## @result{} ans = [0, 2] ## @end group ## @end example ## @seealso{@@infsup/sqr, @@infsup/pow, @@infsup/nthroot, @@infsup/cbrt} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-03-15 function result = sqrt (x) if (nargin ~= 1) print_usage (); return endif result = realsqrt (x); endfunction %!test "from the documentation string"; %! assert (sqrt (infsup (-6, 4)) == infsup (0, 2)); interval-1.4.1/inst/@infsup/strictprecedes.m0000644000000000000000000000317512657475772017305 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} strictprecedes (@var{A}, @var{B}) ## ## Evaluate strict precedes comparison on intervals. ## ## True, if @var{A} is strictly left of @var{B}. The intervals may not touch. ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## @seealso{@@infsup/eq, @@infsup/le, @@infsup/lt, @@infsup/gt, @@infsup/precedes, @@infsup/subset, @@infsup/interior, @@infsup/disjoint} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-07 function result = strictprecedes (a, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (a, "infsup"))) a = infsup (a); endif if (not (isa (b, "infsup"))) b = infsup (b); endif result = (a.sup < b.inf); result (isempty (a) | isempty (b)) = true (); endfunction %!assert (strictprecedes (infsup (1, 1.9), infsup (2.1, 3))); %!assert (not (strictprecedes (infsup (1, 2), infsup (2, 3)))); interval-1.4.1/inst/@infsup/subsasgn.m0000644000000000000000000000367412657475772016113 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} subsasgn (@var{A}, @var{IDX}, @var{RHS}) ## @defopx Operator {@@infsup} {@var{A}(@var{SUBS}) = @var{RHS}} ## ## Perform the subscripted assignment operation according to the subscript ## specified by @var{IDX}. ## ## The subscript @var{IDX} is expected to be a structure array with fields ## @code{type} and @code{subs}. Only valid value for @var{type} is ## @code{"()"}. The @code{subs} field may be either @code{":"} or a cell array ## of index values. ## @seealso{@@infsup/subsref} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-29 function result = subsasgn (A, S, B) if (nargin ~= 3) print_usage (); return endif if (not (isa (A, "infsup"))) A = infsup (A); endif if (not (isa (B, "infsup"))) B = infsup (B); elseif (isa (B, "infsupdec")) ## Workaround for bug #42735 result = subsasgn (A, S, B); return endif assert (strcmp (S.type, "()"), "only subscripts with parenthesis allowed"); l = subsasgn (A.inf, S, B.inf); u = subsasgn (A.sup, S, B.sup); result = infsup (l, u); endfunction %!test %! A = infsup (magic (3)); %! A (4, 4) = 42; %! assert (inf (A), [magic(3),[0;0;0];0,0,0,42]); %! assert (sup (A), [magic(3),[0;0;0];0,0,0,42]); interval-1.4.1/inst/@infsup/subset.m0000644000000000000000000000275712657475772015574 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} subset (@var{A}, @var{B}) ## ## Evaluate subset comparison on intervals. ## ## True, if all numbers from @var{A} are also contained in @var{B}. ## False, if @var{A} contains a number which is not a member in @var{B}. ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## @seealso{@@infsup/eq, @@infsup/interior, @@infsup/disjoint} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-30 function result = subset (a, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (a, "infsup"))) a = infsup (a); endif if (not (isa (b, "infsup"))) b = infsup (b); endif result = (b.inf <= a.inf & a.sup <= b.sup); endfunction %!assert (subset (infsup (1, 2), infsup (1, 3))); interval-1.4.1/inst/@infsup/subsref.m0000644000000000000000000000541012657475772015725 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} subsref (@var{A}, @var{IDX}) ## @defopx Operator {@@infsup} {@var{A}(@var{I})} ## @defopx Operator {@@infsup} {@var{A}(@var{I1}, @var{I2})} ## @defopx Operator {@@infsup} {@var{A}.@var{P}} ## ## Select property @var{P} or elements @var{I} from interval matrix @var{A}. ## ## The index @var{I} may be either @code{:} or an index matrix. ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## The property @var{P} may correspond to any unary method of the interval's ## class, but usually is either @code{inf} or @code{sup}. ## ## @example ## @group ## x = infsup (magic (3), magic (3) + 1); ## x (1) ## @result{} ans = [8, 9] ## x (:, 2) ## @result{} ans = 3×1 interval vector ## [1, 2] ## [5, 6] ## [9, 10] ## x.inf ## @result{} ans = ## 8 1 6 ## 3 5 7 ## 4 9 2 ## @end group ## @end example ## @seealso{@@infsup/subsasgn} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-29 function result = subsref (A, S) if (nargin ~= 2) print_usage (); return endif switch (S (1).type) case "()" A.inf = subsref (A.inf, S (1)); A.sup = subsref (A.sup, S (1)); result = A; case "{}" error ("interval cannot be indexed with {}") case "." if (not (any (strcmp (S(1).subs, methods (A))))) error (["interval property ‘", S(1).subs, "’ is unknown"]) endif functionname = ["@infsup", filesep(), S(1).subs]; if (nargin (functionname) ~= 1) error (["‘", S(1).subs, "’ is not a valid interval property"]) endif result = feval (S (1).subs, A); otherwise error ("invalid subscript type") endswitch if (numel (S) > 1) result = subsref (result, S (2:end)); endif endfunction %!assert (infsup (magic (3)) ([1, 2, 3]) == magic (3) ([1, 2, 3])); %!test "from the documentation string"; %! x = infsup (magic (3), magic (3) + 1); %! assert (x (1) == infsup (8, 9)); %! assert (x (:, 2) == infsup ([1; 5; 9], [2; 6; 10])); %! assert (x.inf, magic (3)); interval-1.4.1/inst/@infsup/sum.m0000644000000000000000000000513412657475772015063 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} sum (@var{X}) ## @defmethodx {@@infsup} sum (@var{X}, @var{DIM}) ## ## Sum of elements along dimension @var{DIM}. If @var{DIM} is omitted, it ## defaults to the first non-singleton dimension. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## sum ([infsup(1), pow2(-1074), -1]) ## @result{} ans ⊂ [4.9406e-324, 4.9407e-324] ## infsup (1) + pow2 (-1074) - 1 ## @result{} ans ⊂ [0, 2.2205e-16] ## @end group ## @end example ## @seealso{@@infsup/plus, @@infsup/prod} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-26 function result = sum (x, dim) if (nargin > 2) print_usage (); return endif if (nargin < 2) ## Try to find non-singleton dimension dim = find (size (x.inf) > 1, 1); if (isempty (dim)) dim = 1; endif endif ## Short-circuit if (size (x.inf, dim) == 1) result = x; return endif if (dim == 1) resultsize = [1, max(1, size (x.inf, 2))]; elseif (dim == 2) resultsize = [max(1, size (x.inf, 1)), 1]; else error ("interval:InvalidOperand", "sum: DIM must be a valid dimension") endif l = u = zeros (resultsize); for n = 1 : size (x.inf, 3 - dim) idx.type = "()"; idx.subs = cell (1, 2); idx.subs {dim} = ":"; idx.subs {3 - dim} = n; ## Select current vector in matrix if (size (x.inf, 3 - dim) == 1) vector.x = x; else vector.x = subsref (x, idx); endif if (any (isempty (vector.x))) ## One of the intervals is empty l (n) = inf; u (n) = -inf; else l (n) = mpfr_vector_sum_d (-inf, vector.x.inf); u (n) = mpfr_vector_sum_d (+inf, vector.x.sup); endif endfor result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (sum ([infsup(1), pow2(-1074), -1]) == infsup (pow2 (-1074))); %!assert (sum (infsup ([])) == 0); interval-1.4.1/inst/@infsup/sumabs.m0000644000000000000000000000314312657475772015547 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} sumabs (@var{X}) ## @defmethodx {@@infsup} sumabs (@var{X}, @var{DIM}) ## ## Sum of absolute values along dimension @var{DIM}. If @var{DIM} is omitted, ## it defaults to the first non-singleton dimension. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## sumabs ([infsup(1), pow2(-1074), -1]) ## @result{} ans ⊂ [2, 2.0001] ## @end group ## @end example ## @seealso{@@infsup/sum, @@infsup/plus, @@infsup/abs} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-26 function result = sumabs (x, dim) if (nargin > 2) print_usage (); return endif if (nargin < 2) result = sum (abs (x)); else result = sum (abs (x), dim); endif endfunction %!test "from the documentation string"; %! assert (sumabs ([infsup(1), pow2(-1074), -1]) == infsup (2, 2+eps*2)); %!assert (sumabs (infsup ([])) == 0);interval-1.4.1/inst/@infsup/sumsq.m0000644000000000000000000000336312657475772015431 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} sumsq (@var{X}) ## @defmethodx {@@infsup} sumsq (@var{X}, @var{DIM}) ## ## Sum of squares along dimension @var{DIM}. If @var{DIM} is omitted, ## it defaults to the first non-singleton dimension. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## sumsq ([infsup(1), pow2(-1074), -1]) ## @result{} ans ⊂ [2, 2.0001] ## @end group ## @end example ## @seealso{@@infsup/plus, @@infsup/sum, @@infsup/sumabs} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-26 function result = sumsq (x, dim) if (nargin > 2) print_usage (); return endif if (isempty (x.inf)) if (isa (x, 'infsupdec')) result = infsupdec (0); else result = infsup (0); endif return endif x = abs (x); if (nargin < 2) result = dot (x, x); else result = dot (x, x, dim); endif endfunction %!test "from the documentation string"; %! assert (sumsq ([infsup(1), pow2(-1074), -1]) == infsup (2, 2+eps*2)); %!assert (sumsq (infsup ([])) == 0);interval-1.4.1/inst/@infsup/sup.m0000644000000000000000000000311312657475772015061 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} sup (@var{X}) ## ## Get the (least) upper boundary for all numbers of interval @var{X}. ## ## If @var{X} is empty, @code{sup (@var{X})} is negative infinity. ## ## Accuracy: The result is exact. ## ## @example ## @group ## sup (infsup (2.5, 3.5)) ## @result{} ans = 3.5000 ## @end group ## @end example ## @seealso{@@infsup/inf, @@infsup/mid} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-27 function result = sup (x) if (nargin ~= 1) print_usage (); return endif if (isa (x, "infsupdec")) ## We cannot override this function in infsupdec, because that would create ## an infinite loop. if (isnai (x)) error ("interval:NaI", "NaI has no supremum") endif endif result = x.sup; endfunction %!test "from the documentation string"; %! assert (sup (infsup (2.5, 3.5)), 3.5); interval-1.4.1/inst/@infsup/tan.m0000644000000000000000000000421212657475772015035 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} tan (@var{X}) ## ## Compute the tangent in radians. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## tan (infsup (1)) ## @result{} ans ⊂ [1.5574, 1.5575] ## @end group ## @end example ## @seealso{@@infsup/atan, @@infsup/tanh} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-06 function result = tan (x) if (nargin ~= 1) print_usage (); return endif l = u = zeros (size (x)); ## Check, if wid (x) is certainly greater than pi. This may save computation of ## some tangent values. width = mpfr_function_d ('minus', -inf, x.sup, x.inf); pi.sup = 0x6487ED5 * pow2 (-25) + 0x442D190 * pow2 (-55); certainlyfullperiod = width >= pi.sup; possiblynotfullperiod = not (certainlyfullperiod); l (possiblynotfullperiod) = mpfr_function_d ('tan', -inf, x.inf (possiblynotfullperiod)); u (possiblynotfullperiod) = mpfr_function_d ('tan', inf, x.sup (possiblynotfullperiod)); singularity = certainlyfullperiod | ... l > u | (... width > 2 & (... sign (l) == sign (u) | ... max (abs (l), abs (u)) < 1)); l (singularity) = -inf; u (singularity) = inf; emptyresult = isempty (x); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (tan (infsup (1)) == "[0x1.8EB245CBEE3A5, 0x1.8EB245CBEE3A6]"); interval-1.4.1/inst/@infsup/tanh.m0000644000000000000000000000311412657475772015205 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} tanh (@var{X}) ## ## Compute the hyperbolic tangent. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## tanh (infsup (1)) ## @result{} ans ⊂ [0.76159, 0.7616] ## @end group ## @end example ## @seealso{@@infsup/atanh, @@infsup/coth, @@infsup/sinh, @@infsup/cosh} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-07 function result = tanh (x) if (nargin ~= 1) print_usage (); return endif ## tanh is monotonically increasing from (-inf, -1) to (inf, 1) l = mpfr_function_d ('tanh', -inf, x.inf); u = mpfr_function_d ('tanh', +inf, x.sup); emptyresult = isempty (x); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (tanh (infsup (1)) == "[0x1.85EFAB514F394p-1, 0x1.85EFAB514F395p-1]"); interval-1.4.1/inst/@infsup/tanrev.m0000644000000000000000000001065212657475772015557 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsup} {@var{X} =} tanrev (@var{C}, @var{X}) ## @deftypemethodx {@@infsup} {@var{X} =} tanrev (@var{C}) ## ## Compute the reverse tangent function. ## ## That is, an enclosure of all @code{x ∈ @var{X}} where ## @code{tan (x) ∈ @var{C}}. ## ## Accuracy: The result is a valid enclosure. ## ## @example ## @group ## tanrev (infsup (0), infsup (2, 4)) ## @result{} ans ⊂ [3.1415, 3.1416] ## @end group ## @end example ## @seealso{@@infsup/tan} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-19 function result = tanrev (c, x) if (nargin > 2) print_usage (); return endif if (nargin < 2) x = infsup (-inf, inf); endif if (not (isa (c, "infsup"))) c = infsup (c); endif if (not (isa (x, "infsup"))) x = infsup (x); endif arctangent = atan (c); result = x; ## Resize, if scalar × matrix if (isscalar (arctangent.inf) ~= isscalar (result.inf)) arctangent.inf = ones (size (result.inf)) .* arctangent.inf; arctangent.sup = ones (size (result.inf)) .* arctangent.sup; result.inf = ones (size (arctangent.inf)) .* result.inf; result.sup = ones (size (arctangent.inf)) .* result.sup; endif result.inf (isempty (arctangent)) = inf; result.sup (isempty (arctangent)) = -inf; idx.type = '()'; pi = infsup ("pi"); select = not (isempty (result)) ... & not (subset (infsup (-pi.sup / 2, pi.sup / 2), arctangent)); if (any (any (select))) ## Find a smaller upper bound for x, if the restriction from c allows it u = inf (size (result.inf)); select_u = select & result.sup < inf; ## Find n, such that result.sup is within a distance of pi/2 around n * pi. n = result.sup; n (select_u) = ceil (floor (sup (n (select_u) ./ (pi ./ 2))) ./ 2); arctangentshifted = arctangent; idx.subs = {select_u}; arctangentshifted = subsasgn (arctangentshifted, idx, ... subsref (arctangentshifted, idx) + n (select_u) .* pi); overlapping = not (isempty (intersect (result, arctangentshifted))); u (select_u & overlapping) = ... min (result.sup (select_u & overlapping), ... arctangentshifted.sup (select_u & overlapping)); n (select_u & ~overlapping) = ... mpfr_function_d ('minus', +inf, n (select_u & ~overlapping), 1); idx.subs = {(select_u & ~overlapping)}; u (idx.subs {1}) = ... sup (subsref (arctangent, idx) + subsref (n, idx) .* pi); ## Find a larger lower bound for x, if the restriction from c allows it l = -inf (size (result.inf)); select_l = select & result.inf > -inf; ## Find n, such that result.inf is within a distance of pi/2 around n * pi. n = result.inf; n (select_l) = floor (ceil (inf (n (select_l) ./ (pi ./ 2))) ./ 2); arctangentshifted = arctangent; idx.subs = {select_l}; arctangentshifted = subsasgn (arctangentshifted, idx, ... subsref (arctangentshifted, idx) + n (select_l) .* pi); overlapping = not (isempty (intersect (result, arctangentshifted))); l (select_l & overlapping) = ... max (result.inf (select_l & overlapping), ... arctangentshifted.inf (select_l & overlapping)); n (select_l & ~overlapping) = ... mpfr_function_d ('plus', -inf, n (select_l & ~overlapping), 1); idx.subs = {(select_l & ~overlapping)}; l (idx.subs {1}) = ... inf (subsref (arctangent, idx) + subsref (n, idx) .* pi); result.inf (select) = max (l (select), result.inf (select)); result.sup (select) = min (u (select), result.sup (select)); result.inf (result.inf > result.sup) = inf; result.sup (result.inf > result.sup) = -inf; endif endfunction %!test "from the documentation string"; %! assert (tanrev (infsup (0), infsup (2, 4)) == infsup ("pi")); interval-1.4.1/inst/@infsup/times.m0000644000000000000000000000603112657475772015375 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} times (@var{X}, @var{Y}) ## @defopx Operator {@@infsup} {@var{X} .* @var{Y}} ## ## Multiply all numbers of interval @var{X} by all numbers of @var{Y}. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## x = infsup (2, 3); ## y = infsup (1, 2); ## x .* y ## @result{} ans = [2, 6] ## @end group ## @end example ## @seealso{@@infsup/rdivide} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-30 function result = times (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsup"))) x = infsup (x); endif if (not (isa (y, "infsup"))) y = infsup (y); elseif (isa (y, "infsupdec")) ## Workaround for bug #42735 result = times (x, y); return endif ## At least one case of interval multiplication is complicated: when zero is an ## inner point of both interval factors. In all other cases it would suffice ## to compute a single product for each product boundary. ## ## It is not significandly faster to do a case by case analysis in order to ## save some calls to the times function with directed rounding. Therefore, we ## simply compute the product for each pair of boundaries where the min/max ## could be located. l = min (min (min (... mpfr_function_d ('times', -inf, x.inf, y.inf), ... mpfr_function_d ('times', -inf, x.inf, y.sup)), ... mpfr_function_d ('times', -inf, x.sup, y.inf)), ... mpfr_function_d ('times', -inf, x.sup, y.sup)); u = max (max (max (... mpfr_function_d ('times', +inf, x.inf, y.inf), ... mpfr_function_d ('times', +inf, x.inf, y.sup)), ... mpfr_function_d ('times', +inf, x.sup, y.inf)), ... mpfr_function_d ('times', +inf, x.sup, y.sup)); ## [0] × anything = [0] × [0] ## [Entire] × anything but [0] = [Entire] × [Entire] ## This prevents the cases where 0 × inf would produce NaNs. entireproduct = isentire (x) | isentire (y); l (entireproduct) = -inf; u (entireproduct) = inf; zeroproduct = (x.inf == 0 & x.sup == 0) | (y.inf == 0 & y.sup == 0); l (zeroproduct) = 0; u (zeroproduct) = 0; emptyresult = isempty (x) | isempty (y); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (infsup (2, 3) .* infsup (1, 2) == infsup (2, 6)); interval-1.4.1/inst/@infsup/transpose.m0000644000000000000000000000304412657475772016273 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} transpose (@var{X}) ## @defopx Operator {@@infsup} {@var{X}.'} ## ## Return the transpose of interval matrix or vector @var{X}. ## ## @example ## @group ## infsup (zeros (1, 3), ones (1, 3)) .' ## @result{} ans = 3×1 interval vector ## [0, 1] ## [0, 1] ## [0, 1] ## @end group ## @end example ## @seealso{@@infsup/ctranspose} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-29 function result = transpose (x) if (nargin ~= 1) print_usage (); return endif l = transpose (x.inf); u = transpose (x.sup); result = infsup (l, u); endfunction %!assert (transpose (infsup (magic (3))) == infsup (magic (3).')); %!test "from the documentation string"; %! assert (transpose (infsup (zeros (1, 3), ones (1, 3))) == infsup (zeros (3, 1), ones (3, 1))); interval-1.4.1/inst/@infsup/uminus.m0000644000000000000000000000260512657475772015577 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} uminus (@var{X}) ## @defopx Operator {@@infsup} {-@var{X}} ## ## Negate all numbers in the interval. ## ## Accuracy: The result is exact. ## ## @example ## @group ## x = infsup (2, 3); ## -x ## @result{} ans = [-3, -2] ## @end group ## @end example ## @seealso{@@infsup/uplus} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-30 function result = uminus (x) if (nargin ~= 1) print_usage (); return endif ## This also works for empty / entire intervals l = -x.sup; u = -x.inf; result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (-infsup (2, 3) == infsup (-3, -2)); interval-1.4.1/inst/@infsup/union.m0000644000000000000000000000423612657475772015411 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} union (@var{A}) ## @defmethodx {@@infsup} union (@var{A}, @var{B}) ## @defmethodx {@@infsup} union (@var{A}, [], @var{DIM}) ## ## Build the interval hull of the union of intervals. ## ## With two arguments the union is built pair-wise. Otherwise the union is ## computed for all interval members along dimension @var{DIM}, which defaults ## to the first non-singleton dimension. ## ## Accuracy: The result is exact. ## ## @example ## @group ## x = infsup (1, 3); ## y = infsup (2, 4); ## union (x, y) ## @result{} ans = [1, 4] ## @end group ## @end example ## @seealso{@@infsup/intersect, @@infsup/setdiff, @@infsup/setxor} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-02 function result = union (a, b, dim) if (not (isa (a, "infsup"))) a = infsup (a); endif switch (nargin) case 1 l = min (a.inf); u = max (a.sup); case 2 if (not (isa (b, "infsup"))) b = infsup (b); endif l = min (a.inf, b.inf); u = max (a.sup, b.sup); case 3 if (not (builtin ("isempty", b))) warning ("union: second argument is ignored"); endif l = min (a.inf, [], dim); u = max (a.sup, [], dim); otherwise print_usage (); return endswitch result = infsup (l, u); endfunction %!test "from the documentation string"; %! assert (union (infsup (1, 3), infsup (2, 4)) == infsup (1, 4)); interval-1.4.1/inst/@infsup/uplus.m0000644000000000000000000000242212657475772015424 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} uplus (@var{X}) ## @defopx Operator {@@infsup} {+@var{X}} ## ## Return the interval itself. ## ## Accuracy: The result is exact. ## ## @example ## @group ## x = infsup (2, 3); ## + x ## @result{} ans = [2, 3] ## @end group ## @end example ## @seealso{@@infsup/uminus} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-30 function x = uplus (x) if (nargin ~= 1) print_usage (); return endif endfunction %!test "from the documentation string"; %! assert (+infsup (2, 3) == infsup (2, 3)); interval-1.4.1/inst/@infsup/vertcat.m0000644000000000000000000000364712657475772015736 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} vertcat (@var{ARRAY1}, @var{ARRAY2}, @dots{}) ## @defopx Operator {@@infsup} {[@var{ARRAY1}; @var{ARRAY2}; @dots{}]} ## ## Return the vertical concatenation of interval array objects along ## dimension 1. ## ## @example ## @group ## a = infsup (2, 5); ## [a; a; a] ## @result{} ans = 3×1 interval vector ## [2, 5] ## [2, 5] ## [2, 5] ## @end group ## @end example ## @seealso{@@infsup/horzcat} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-29 function result = vertcat (varargin) varargin = transpose (varargin); ## Conversion to interval intervals = cellfun ("isclass", varargin, "infsup"); to_convert = not (intervals); varargin (to_convert) = cellfun (@infsup, varargin (to_convert), ... "UniformOutput", false ()); l = cell2mat (cellfun (@(x) x.inf, varargin, "UniformOutput", false ())); u = cell2mat (cellfun (@(x) x.sup, varargin, "UniformOutput", false ())); result = infsup (l, u); endfunction %!assert (vertcat (infsup (1), infsup (2)) == infsup (vertcat (1, 2))); %!test "from the documentation string"; %! a = infsup (2, 5); %! assert (vertcat (a, a, a) == infsup ([2; 2; 2], [5; 5; 5])); interval-1.4.1/inst/@infsup/wid.m0000644000000000000000000000303712657475772015042 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} wid (@var{X}) ## ## Get the width of interval @var{X}. ## ## If @var{X} is empty, @code{wid (@var{X})} is NaN. ## If @var{X} is unbounded in one or both directions, @code{wid (@var{X})} is ## positive infinity. ## ## Accuracy: The result is a tight enclosure of the interval's actual width. ## ## @example ## @group ## wid (infsup (2.5, 3.5)) ## @result{} ans = 1 ## @end group ## @end example ## @seealso{@@infsup/inf, @@infsup/sup, @@infsup/rad} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-05 function result = wid (x) if (nargin ~= 1) print_usage (); return endif result = mpfr_function_d ('minus', +inf, x.sup, x.inf); result (isempty (x)) = nan (); endfunction %!test "from the documentation string"; %! assert (wid (infsup (2.5, 3.5)), 1); interval-1.4.1/inst/@infsupdec/abs.m0000644000000000000000000000601112657475772015473 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} abs (@var{X}) ## ## Compute the absolute value of numbers. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## abs (infsupdec (2.5, 3.5)) ## @result{} ans = [2.5, 3.5]_com ## abs (infsupdec (-0.5, 5.5)) ## @result{} ans = [0, 5.5]_com ## @end group ## @end example ## @seealso{@@infsupdec/mag, @@infsupdec/mig} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = abs (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (abs (intervalpart (x))); ## abs is defined and continuous everywhere result.dec = min (result.dec, x.dec); endfunction %!test "Empty interval"; %! assert (isequal (abs (infsupdec ()), infsupdec ())); %!test "Singleton intervals"; %! assert (isequal (abs (infsupdec (1)), infsupdec (1))); %! assert (isequal (abs (infsupdec (0)), infsupdec (0))); %! assert (isequal (abs (infsupdec (-1)), infsupdec (1))); %! assert (isequal (abs (infsupdec (realmax)), infsupdec (realmax))); %! assert (isequal (abs (infsupdec (realmin)), infsupdec (realmin))); %! assert (isequal (abs (infsupdec (-realmin)), infsupdec (realmin))); %! assert (isequal (abs (infsupdec (-realmax)), infsupdec (realmax))); %!test "Bounded intervals"; %! assert (isequal (abs (infsupdec (1, 2)), infsupdec (1, 2))); %! assert (isequal (abs (infsupdec (0, 1)), infsupdec (0, 1))); %! assert (isequal (abs (infsupdec (-1, 1)), infsupdec (0, 1))); %! assert (isequal (abs (infsupdec (-1, 0)), infsupdec (0, 1))); %! assert (isequal (abs (infsupdec (-2, -1)), infsupdec (1, 2))); %!test "Unbounded intervals"; %! assert (isequal (abs (infsupdec (0, inf)), infsupdec (0, inf))); %! assert (isequal (abs (infsupdec (-inf, inf)), infsupdec (0, inf))); %! assert (isequal (abs (infsupdec (-inf, 0)), infsupdec (0, inf))); %! assert (isequal (abs (infsupdec (1, inf)), infsupdec (1, inf))); %! assert (isequal (abs (infsupdec (-1, inf)), infsupdec (0, inf))); %! assert (isequal (abs (infsupdec (-inf, -1)), infsupdec (1, inf))); %! assert (isequal (abs (infsupdec (-inf, 1)), infsupdec (0, inf))); %!test "from the documentation string"; %! assert (isequal (abs (infsupdec (2.5, 3.5)), infsupdec (2.5, 3.5))); %! assert (isequal (abs (infsupdec (-0.5, 5.5)), infsupdec (0, 5.5))); interval-1.4.1/inst/@infsupdec/absrev.m0000644000000000000000000000771112657475772016220 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsupdec} {@var{X} =} absrev (@var{C}, @var{X}) ## @deftypemethodx {@@infsupdec} {@var{X} =} absrev (@var{C}) ## ## Compute the reverse absolute value function. ## ## That is, an enclosure of all @code{x ∈ @var{X}} where ## @code{abs (x) ∈ @var{C}}. ## ## Accuracy: The result is a tight enclosure. ## ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## No one way of decorating this operations gives useful information in all ## contexts. Therefore, the result will carry a @code{trv} decoration at best. ## ## @example ## @group ## absrev (infsupdec (-2, 1)) ## @result{} ans = [-1, +1]_trv ## @end group ## @end example ## @seealso{@@infsupdec/abs} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-19 function result = absrev (c, x) if (nargin > 2) print_usage (); return endif if (nargin < 2) x = infsupdec (-inf, inf); endif if (not (isa (c, "infsupdec"))) c = infsupdec (c); endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (isnai (c)) result = c; return endif if (isnai (x)) result = x; return endif result = infsupdec (absrev (intervalpart (c), intervalpart (x)), "trv"); endfunction %!test "Empty interval"; %! assert (isequal (absrev (infsupdec ()), infsupdec ())); %! assert (isequal (absrev (infsupdec (0, 1), infsupdec ()), infsupdec ())); %! assert (isequal (absrev (infsupdec (0, 1), infsupdec (7, 9)), infsupdec ())); %! assert (isequal (absrev (infsupdec (), infsupdec (0, 1)), infsupdec ())); %! assert (isequal (absrev (infsupdec (-2, -1)), infsupdec ())); %!test "Singleton intervals"; %! assert (isequal (absrev (infsupdec (1)), infsupdec (-1, 1, "trv"))); %! assert (isequal (absrev (infsupdec (0)), infsupdec (0, "trv"))); %! assert (isequal (absrev (infsupdec (-1)), infsupdec ())); %! assert (isequal (absrev (infsupdec (realmax)), infsupdec (-realmax, realmax, "trv"))); %! assert (isequal (absrev (infsupdec (realmin)), infsupdec (-realmin, realmin, "trv"))); %! assert (isequal (absrev (infsupdec (-realmin)), infsupdec ())); %! assert (isequal (absrev (infsupdec (-realmax)), infsupdec ())); %!test "Bound intervals"; %! assert (isequal (absrev (infsupdec (1, 2)), infsupdec (-2, 2, "trv"))); %! assert (isequal (absrev (infsupdec (1, 2), infsupdec (0, 2)), infsupdec (1, 2, "trv"))); %! assert (isequal (absrev (infsupdec (0, 1), infsupdec (-0.5, 2)), infsupdec (-0.5, 1, "trv"))); %! assert (isequal (absrev (infsupdec (-1, 1)), infsupdec (-1, 1, "trv"))); %! assert (isequal (absrev (infsupdec (-1, 0)), infsupdec (0, "trv"))); %!test "Unbound intervals"; %! assert (isequal (absrev (infsupdec (0, inf)), infsupdec (-inf, inf, "trv"))); %! assert (isequal (absrev (infsupdec (-inf, inf)), infsupdec (-inf, inf, "trv"))); %! assert (isequal (absrev (infsupdec (-inf, 0)), infsupdec (0, "trv"))); %! assert (isequal (absrev (infsupdec (1, inf), infsupdec (-inf, 0)), infsupdec (-inf, -1, "trv"))); %! assert (isequal (absrev (infsupdec (-1, inf)), infsupdec (-inf, inf, "trv"))); %! assert (isequal (absrev (infsupdec (-inf, -1)), infsupdec ())); %! assert (isequal (absrev (infsupdec (-inf, 1)), infsupdec (-1, 1, "trv"))); %!test "from the documentation string"; %! assert (isequal (absrev (infsupdec (-2, 1)), infsupdec (-1, 1, "trv"))); interval-1.4.1/inst/@infsupdec/acos.m0000644000000000000000000000312212657475772015653 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} acos (@var{X}) ## ## Compute the inverse cosine in radians (arccosine). ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## acos (infsupdec (.5)) ## @result{} ans ⊂ [1.0471, 1.0472]_com ## @end group ## @end example ## @seealso{@@infsupdec/cos} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = acos (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (acos (intervalpart (x))); result.dec = min (result.dec, x.dec); ## acos is continuous everywhere, but defined for [-1, 1] only result.dec (not (subset (x, infsupdec (-1, 1)))) = _trv (); endfunction %!test "from the documentation string"; %! assert (isequal (acos (infsupdec (.5)), infsupdec ("[0x1.0C152382D7365, 0x1.0C152382D7366]"))); interval-1.4.1/inst/@infsupdec/acosh.m0000644000000000000000000000311412657475772016024 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} acosh (@var{X}) ## ## Compute the inverse hyperbolic cosine. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## acosh (infsupdec (2)) ## @result{} ans ⊂ [1.3169, 1.317]_com ## @end group ## @end example ## @seealso{@@infsupdec/cosh} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = acosh (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (acosh (intervalpart (x))); result.dec = min (result.dec, x.dec); ## acosh is continuous everywhere, but defined for [1, Inf] only result.dec (not (subset (x, infsupdec (1, inf)))) = _trv (); endfunction %!test "from the documentation string"; %! assert (isequal (acosh (infsupdec (2)), infsupdec ("[0x1.5124271980434, 0x1.5124271980435]"))); interval-1.4.1/inst/@infsupdec/asin.m0000644000000000000000000000312512657475772015663 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} asin (@var{X}) ## ## Compute the inverse sine in radians (arcsine). ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## asin (infsupdec (.5)) ## @result{} ans ⊂ [0.52359, 0.5236]_com ## @end group ## @end example ## @seealso{@@infsupdec/sin} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = asin (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (asin (intervalpart (x))); result.dec = min (result.dec, x.dec); ## asin is continuous everywhere, but defined for [-1, 1] only result.dec (not (subset (x, infsupdec (-1, 1)))) = _trv (); endfunction %!test "from the documentation string"; %! assert (isequal (asin (infsupdec (.5)), infsupdec ("[0x1.0C152382D7365p-1, 0x1.0C152382D7366p-1]"))); interval-1.4.1/inst/@infsupdec/asinh.m0000644000000000000000000000300312657475772016026 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} asinh (@var{X}) ## ## Compute the inverse hyperbolic sine. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## asinh (infsupdec (1)) ## @result{} ans ⊂ [0.88137, 0.88138]_com ## @end group ## @end example ## @seealso{@@infsupdec/sinh} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = asinh (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (asinh (intervalpart (x))); ## asinh is defined and continuous everywhere result.dec = min (result.dec, x.dec); endfunction %!test "from the documentation string"; %! assert (isequal (asinh (infsupdec (1)), infsupdec ("[0x1.C34366179D426p-1, 0x1.C34366179D427p-1]"))); interval-1.4.1/inst/@infsupdec/atan.m0000644000000000000000000000302112657475772015647 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} atan (@var{X}) ## ## Compute the inverse tangent in radians. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## atan (infsupdec (1)) ## @result{} ans ⊂ [0.78539, 0.7854]_com ## @end group ## @end example ## @seealso{@@infsupdec/tan, @@infsupdec/atan2} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = atan (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (atan (intervalpart (x))); ## atan is defined and continuous everywhere result.dec = min (result.dec, x.dec); endfunction %!test "from the documentation string"; %! assert (isequal (atan (infsupdec (1)), infsupdec ("[0x1.921FB54442D18p-1, 0x1.921FB54442D19p-1]"))); interval-1.4.1/inst/@infsupdec/atan2.m0000644000000000000000000000433112657475772015736 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} atan2 (@var{Y}, @var{X}) ## ## Compute the inverse tangent with two arguments. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## atan2 (infsupdec (1), infsupdec (-1)) ## @result{} ans ⊂ [2.3561, 2.3562]_com ## @end group ## @end example ## @seealso{@@infsupdec/tan} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = atan2 (y, x) if (nargin ~= 2) print_usage (); return endif if (not (isa (y, "infsupdec"))) y = infsupdec (y); endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (isnai (x)) result = x; return endif if (isnai (y)) result = y; return endif result = newdec (atan2 (intervalpart (y), intervalpart (x))); result.dec = min (result.dec, min (y.dec, x.dec)); ## The function is discontinuous for x <= 0 and y == 0 discontinuos = inf (y) < 0 & sup (y) >= 0 & inf (x) < 0; result.dec (discontinuos) = min (result.dec (discontinuos), _def ()); ## For y = [0, y.sup] the function is discontinuous, but its restriction is not onlyrestrictioncontinuous = inf (y) == 0 & inf (x) < 0; result.dec (onlyrestrictioncontinuous) = ... min (result.dec (onlyrestrictioncontinuous), _dac ()); ## The only undefined input is <0,0> result.dec (ismember (0, y) & ismember (0, x)) = _trv (); endfunction %!test "from the documentation string"; %! assert (isequal (atan2 (infsupdec (1), infsupdec (-1)), infsupdec ("[0x1.2D97C7F3321D2p1, 0x1.2D97C7F3321D3p1]"))); interval-1.4.1/inst/@infsupdec/atan2rev1.m0000644000000000000000000000463112657475772016537 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsupdec} {@var{Y} =} atan2rev1 (@var{B}, @var{C}, @var{Y}) ## @deftypemethodx {@@infsupdec} {@var{Y} =} atan2rev1 (@var{B}, @var{C}) ## ## Compute the reverse atan2 function for the first parameter. ## ## That is, an enclosure of all @code{y ∈ @var{Y}} where ## @code{atan2 (y, b) ∈ @var{C}} for any @code{b ∈ @var{B}}. ## ## Accuracy: The result is a valid enclosure. ## ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## No one way of decorating this operations gives useful information in all ## contexts. Therefore, the result will carry a @code{trv} decoration at best. ## ## @example ## @group ## atan2rev1 (infsupdec (1, 2), infsupdec ("pi") / 4) ## @result{} ans ⊂ [0.99999, 2.0001]_trv ## @end group ## @end example ## @seealso{@@infsupdec/atan2} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-19 function result = atan2rev1 (b, c, y) if (nargin < 2 || nargin > 3) print_usage (); return endif if (nargin < 3) y = infsupdec (-inf, inf); endif if (not (isa (b, "infsupdec"))) b = infsupdec (b); endif if (not (isa (c, "infsupdec"))) c = infsupdec (c); endif if (not (isa (y, "infsupdec"))) y = infsupdec (y); endif if (isnai (y)) result = y; return endif if (isnai (b)) result = b; return endif if (isnai (c)) result = c; return endif result = atan2rev1 (intervalpart (b), intervalpart (c), intervalpart (y)); ## inverse atan2 is not a point function result = infsupdec (result, "trv"); endfunction %!test "from the documentation string"; %! assert (isequal (atan2rev1 (infsupdec (1, 2), infsupdec ("pi") / 4), infsupdec ("[0x1.FFFFFFFFFFFFFp-1, 0x1.0000000000001p1]_trv"))); interval-1.4.1/inst/@infsupdec/atan2rev2.m0000644000000000000000000000463212657475772016541 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsupdec} {@var{X} =} atan2rev2 (@var{A}, @var{C}, @var{X}) ## @deftypemethodx {@@infsupdec} {@var{X} =} atan2rev2 (@var{A}, @var{C}) ## ## Compute the reverse atan2 function for the second parameter. ## ## That is, an enclosure of all @code{x ∈ @var{X}} where ## @code{atan2 (a, x) ∈ @var{C}} for any @code{a ∈ @var{A}}. ## ## Accuracy: The result is a valid enclosure. ## ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## No one way of decorating this operations gives useful information in all ## contexts. Therefore, the result will carry a @code{trv} decoration at best. ## ## @example ## @group ## atan2rev2 (infsupdec (1, 2), infsupdec ("pi") / 4) ## @result{} ans ⊂ [0.99999, 2.0001]_trv ## @end group ## @end example ## @seealso{@@infsupdec/atan2} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-19 function result = atan2rev2 (a, c, x) if (nargin < 2 || nargin > 3) print_usage (); return endif if (nargin < 3) x = infsupdec (-inf, inf); endif if (not (isa (a, "infsupdec"))) a = infsupdec (a); endif if (not (isa (c, "infsupdec"))) c = infsupdec (c); endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (isnai (x)) result = x; return endif if (isnai (a)) result = b; return endif if (isnai (c)) result = c; return endif result = atan2rev2 (intervalpart (a), intervalpart (c), intervalpart (x)); ## inverse atan2 is not a point function result = infsupdec (result, "trv"); endfunction %!test "from the documentation string"; %! assert (isequal (atan2rev2 (infsupdec (1, 2), infsupdec ("pi") / 4), infsupdec ("[0x1.FFFFFFFFFFFFEp-1, 0x1.0000000000001p1]_trv"))); interval-1.4.1/inst/@infsupdec/atanh.m0000644000000000000000000000312712657475772016026 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} atanh (@var{X}) ## ## Compute the inverse hyperbolic tangent. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## atanh (infsupdec (.5)) ## @result{} ans ⊂ [0.5493, 0.54931]_com ## @end group ## @end example ## @seealso{@@infsupdec/tanh} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = atanh (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (atanh (intervalpart (x))); result.dec = min (result.dec, x.dec); ## atanh is continuous everywhere, but defined for ]-1, 1[ only result.dec (not (interior (x, infsupdec (-1, 1)))) = _trv (); endfunction %!test "from the documentation string"; %! assert (isequal (atanh (infsupdec (.5)), infsupdec ("[0x1.193EA7AAD030Ap-1, 0x1.193EA7AAD030Bp-1]"))); interval-1.4.1/inst/@infsupdec/bisect.m0000644000000000000000000000445412657475772016210 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsupdec} {[@var{A}, @var{B}] =} bisect (@var{X}) ## ## Bisect an interval into two intervals, which contain half the amount of ## binary64 numbers each. ## ## Instead of bisecting the values of numbers in the interval at ## @code{mid (@var{X})}, this function bisects a function that counts them. In ## a bisect method this eliminates exactly half of the solutions and avoids ## slow convergence speeds in extreme cases. ## ## If all numbers in interval @var{X} are of equal sign, the pivot element used ## for bisection is @code{pow2 (mid (log2 (abs (@var{X}))))}. If @var{X} is no ## empty interval, the intervals @var{A} and @var{B} are non-empty and satisfy ## @code{@var{A}.sup == @var{B}.inf}. ## ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## The function is a set operation and the result carries the @code{trv} ## decoration at best. ## ## @example ## @group ## [a, b] = bisect (infsupdec (2, 32)) ## @result{} ## a = [2, 8]_trv ## b = [8, 32]_trv ## @end group ## @end example ## @seealso{@@infsupdec/nextout} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-05-25 function [a, b] = bisect (x) if (nargin > 1) print_usage (); return endif if (isnai (x)) a = x; b = x; return endif ## bisect must not retain any useful decoration [a, b] = bisect (intervalpart (x)); a = infsupdec (a, "trv"); b = infsupdec (b, "trv"); endfunction %!test "from the documentation string"; %! [a, b] = bisect (infsupdec (2, 32)); %! assert (a == infsupdec (2, 8, "trv")); %! assert (b == infsupdec (8, 32, "trv")); interval-1.4.1/inst/@infsupdec/bitunpack.m0000644000000000000000000000512212657475772016710 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} bitunpack (@var{X}) ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## ## Encode decorated interval @var{X} in interchange format. ## ## The result is a raw bit pattern of length 136 that derive from two binary64 ## numbers plus 8 bit for the decoration. Bits are in increasing order. ## Byte order depends on the system's endianness. First 8 bytes come from the ## lower interval boundary, next 8 bytes come from the upper interval boundary, ## last byte comes from the decoration. ## ## The result is a row vector if @var{X} is a row vector; otherwise, it is a ## column vector. ## ## For all scalar intervals the following equation holds: ## @code{@var{X} == interval_bitpack (bitunpack (@var{X}))}. ## ## @seealso{interval_bitpack} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-12-23 function result = bitunpack (x) if (nargin ~= 1) print_usage (); return endif ## The exchange representation of [NaI] is (NaN, NaN, ill). if (isnai (x)) result = [bitunpack(zeros (1, 'uint8')), bitunpack(nan (1, 2))]; return endif bare = bitunpack (intervalpart (x)); d = bitunpack (x.dec); ## Initialize result vector result = zeros (1, length (bare) + length (d), 'logical'); if (not (isrow (bare))) result = result'; endif ## Merge alternating 128 bit blocks from bare and 8 bit blocks from d together ## into result. target_bare = reshape (1 : length (result), 8, length (result) / 8); target_d = target_bare (:, 17 : 17 : size (target_bare, 2)); target_bare (:, 17 : 17 : size (target_bare, 2)) = []; result (target_bare) = bare; result (target_d) = d; endfunction %!test; %! littleendian = bitunpack (uint16 (1))(1); %! b = zeros (1, 136); %! if (littleendian) %! b([52, 63, 117, 127, 133]) = 1; %! else %! b([7, 12, 71, 77, 133]) = 1; %! endif %! assert (bitunpack (infsupdec (3, 4)), logical (b)); interval-1.4.1/inst/@infsupdec/cancelminus.m0000644000000000000000000000402412657475772017231 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsupdec} {@var{Z} =} cancelminus (@var{X}, @var{Y}) ## ## Recover interval @var{Z} from intervals @var{X} and @var{Y}, given that one ## knows @var{X} was obtained as the sum @var{Y} + @var{Z}. ## ## Accuracy: The result is a tight enclosure. ## ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## No one way of decorating this operations gives useful information in all ## contexts. Therefore, the result will carry a @code{trv} decoration at best. ## ## @example ## @group ## cancelminus (infsupdec (2, 3), infsupdec (1, 1.5)) ## @result{} ans = [1, 1.5]_trv ## @end group ## @end example ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-19 function result = cancelminus (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (not (isa (y, "infsupdec"))) y = infsupdec (y); endif if (isnai (x)) result = x; return endif if (isnai (y)) result = y; return; endif result = cancelminus (intervalpart (x), intervalpart (y)); ## cancelMinus must not retain any useful decoration result = infsupdec (result, "trv"); endfunction %!test "from the documentation string"; %! assert (isequal (cancelminus (infsupdec (2, 3), infsupdec (1, 1.5)), infsupdec (1, 1.5, "trv"))); interval-1.4.1/inst/@infsupdec/cbrt.m0000644000000000000000000000266212657475772015670 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} cbrt (@var{X}) ## ## Compute the cube root. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## cbrt (infsupdec (-27, 27)) ## @result{} ans = [-3, +3]_com ## @end group ## @end example ## @seealso{@@infsupdec/realsqrt, @@infsupdec/nthroot} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-03-15 function result = cbrt (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (cbrt (intervalpart (x))); result.dec = min (result.dec, x.dec); endfunction %!test "from the documentation string"; %! assert (isequal (cbrt (infsupdec (-27, 27)), infsupdec (-3, 3))); interval-1.4.1/inst/@infsupdec/ceil.m0000644000000000000000000000375712657475772015660 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} ceil (@var{X}) ## ## Round each number in interval @var{X} towards +Inf. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## ceil (infsupdec (2.5, 3.5)) ## @result{} ans = [3, 4]_def ## ceil (infsupdec (-0.5, 5)) ## @result{} ans = [0, 5]_def ## @end group ## @end example ## @seealso{@@infsupdec/floor, @@infsupdec/round, @@infsupdec/roundb, @@infsupdec/fix} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = ceil (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (ceil (intervalpart (x))); result.dec = min (result.dec, x.dec); ## Between two integral numbers the function is constant, thus continuous discontinuos = not (issingleton (result)); result.dec (discontinuos) = min (result.dec (discontinuos), _def ()); onlyrestrictioncontinuous = issingleton (result) & fix (sup (x)) == sup (x); result.dec (onlyrestrictioncontinuous) = ... min (result.dec (onlyrestrictioncontinuous), _dac ()); endfunction %!test "from the documentation string"; %! assert (isequal (ceil (infsupdec (2.5, 3.5)), infsupdec (3, 4, "def"))); %! assert (isequal (ceil (infsupdec (-.5, 5)), infsupdec (0, 5, "def"))); interval-1.4.1/inst/@infsupdec/cos.m0000644000000000000000000000302312657475772015512 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} cos (@var{X}) ## ## Compute the cosine in radians. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## cos (infsupdec (1)) ## @result{} ans ⊂ [0.5403, 0.54031]_com ## @end group ## @end example ## @seealso{@@infsupdec/acos, @@infsupdec/sec, @@infsupdec/cosh} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = cos (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (cos (intervalpart (x))); ## cos is defined and continuous everywhere result.dec = min (result.dec, x.dec); endfunction %!test "from the documentation string"; %! assert (isequal (cos (infsupdec (1)), infsupdec ("[0x1.14A280FB5068Bp-1, 0x1.14A280FB5068Cp-1]"))); interval-1.4.1/inst/@infsupdec/cosh.m0000644000000000000000000000304412657475772015665 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} cosh (@var{X}) ## ## Compute the hyperbolic cosine. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## cosh (infsupdec (1)) ## @result{} ans ⊂ [1.543, 1.5431]_com ## @end group ## @end example ## @seealso{@@infsupdec/acosh, @@infsupdec/sech, @@infsupdec/sinh, @@infsupdec/tanh} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = cosh (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (cosh (intervalpart (x))); ## cosh is defined and continuous everywhere result.dec = min (result.dec, x.dec); endfunction %!test "from the documentation string"; %! assert (isequal (cosh (infsupdec (1)), infsupdec ("[0x1.8B07551D9F55, 0x1.8B07551D9F551]"))); interval-1.4.1/inst/@infsupdec/coshrev.m0000644000000000000000000000404012657475772016377 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsupdec} {@var{X} =} coshrev (@var{C}, @var{X}) ## @deftypemethodx {@@infsupdec} {@var{X} =} coshrev (@var{C}) ## ## Compute the reverse hyperbolic cosine function. ## ## That is, an enclosure of all @code{x ∈ @var{X}} where ## @code{cosh (x) ∈ @var{C}}. ## ## Accuracy: The result is a tight enclosure. ## ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## No one way of decorating this operations gives useful information in all ## contexts. Therefore, the result will carry a @code{trv} decoration at best. ## ## @example ## @group ## coshrev (infsupdec (-2, 1)) ## @result{} ans = [0]_trv ## @end group ## @end example ## @seealso{@@infsupdec/cosh} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-19 function result = coshrev (c, x) if (nargin > 2) print_usage (); return endif if (nargin < 2) x = infsupdec (-inf, inf); endif if (not (isa (c, "infsupdec"))) c = infsupdec (c); endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (isnai (c)) result = c; return endif if (isnai (x)) result = x; return endif result = infsupdec (coshrev (intervalpart (c), intervalpart (x)), "trv"); endfunction %!test "from the documentation string"; %! assert (isequal (coshrev (infsupdec (-2, 1)), infsupdec (0, "trv"))); interval-1.4.1/inst/@infsupdec/cosrev.m0000644000000000000000000000412312657475772016231 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsupdec} {@var{X} =} cosrev (@var{C}, @var{X}) ## @deftypemethodx {@@infsupdec} {@var{X} =} cosrev (@var{C}) ## ## Compute the reverse cosine function. ## ## That is, an enclosure of all @code{x ∈ @var{X}} where ## @code{cos (x) ∈ @var{C}}. ## ## Accuracy: The result is a valid enclosure. ## ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## No one way of decorating this operations gives useful information in all ## contexts. Therefore, the result will carry a @code{trv} decoration at best. ## ## @example ## @group ## cosrev (infsupdec (0), infsupdec (6, 9)) ## @result{} ans ⊂ [7.8539, 7.854]_trv ## @end group ## @end example ## @seealso{@@infsupdec/cos} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-19 function result = cosrev (c, x) if (nargin > 2) print_usage (); return endif if (nargin < 2) x = infsupdec (-inf, inf); endif if (not (isa (c, "infsupdec"))) c = infsupdec (c); endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (isnai (c)) result = c; return endif if (isnai (x)) result = x; return endif result = infsupdec (cosrev (intervalpart (c), intervalpart (x)), "trv"); endfunction %!test "from the documentation string"; %! assert (isequal (cosrev (0, infsupdec (6, 9)), infsupdec ("[0x1.F6A7A2955385Ep2, 0x1.F6A7A2955386p2]_trv"))); interval-1.4.1/inst/@infsupdec/cot.m0000644000000000000000000000336312657475772015522 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} cot (@var{X}) ## ## Compute the cotangent in radians, that is the reciprocal tangent. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## cot (infsupdec (1)) ## @result{} ans ⊂ [0.64209, 0.6421]_com ## @end group ## @end example ## @seealso{@@infsupdec/tan, @@infsupdec/csc, @@infsupdec/sec} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-03-15 function result = cot (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (cot (intervalpart (x))); result.dec = min (result.dec, x.dec); ## Because tan (nextdown (pi)) < realmax, we can simple check for ## a singularity by comparing the result with entire for x ~= 0. domain = not (isentire (result)) | (inf (x) <= 0 & sup (x) >= 0); result.dec (not (domain)) = _trv (); endfunction %!test "from the documentation string"; %! assert (isequal (cot (infsupdec (1)), infsupdec ("[0x1.48C05D04E1CFDp-1, 0x1.48C05D04E1CFEp-1]"))); interval-1.4.1/inst/@infsupdec/coth.m0000644000000000000000000000317012657475772015666 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} coth (@var{X}) ## ## Compute the hyperbolic cotangent, that is the reciprocal hyperbolic tangent. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## coth (infsupdec (1)) ## @result{} ans ⊂ [1.313, 1.3131]_com ## @end group ## @end example ## @seealso{@@infsupdec/tanh, @@infsupdec/csch, @@infsupdec/sech} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-03-15 function result = coth (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (coth (intervalpart (x))); ## coth is defined and continuous for x ~= 0 result.dec = min (result.dec, x.dec); result.dec (inf (x) <= 0 & sup (x) >= 0) = _trv (); endfunction %!test "from the documentation string"; %! assert (isequal (coth (infsupdec (1)), infsupdec ("[0x1.50231499B6B1D, 0x1.50231499B6B1E]_com"))); interval-1.4.1/inst/@infsupdec/csc.m0000644000000000000000000000335412657475772015505 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} csc (@var{X}) ## ## Compute the cosecant in radians, that is the reciprocal sine. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## csc (infsupdec (1)) ## @result{} ans ⊂ [1.1883, 1.1884]_com ## @end group ## @end example ## @seealso{@@infsupdec/sin, @@infsupdec/sec, @@infsupdec/cot} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-03-15 function result = csc (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (csc (intervalpart (x))); result.dec = min (result.dec, x.dec); ## Because csc (nextdown (pi)) < realmax, we can simple check for ## a singularity by comparing the result with entire for x ~= 0. domain = not (isentire (result)) | (inf (x) <= 0 & sup (x) >= 0); result.dec (not (domain)) = _trv (); endfunction %!test "from the documentation string"; %! assert (isequal (csc (infsupdec (1)), infsupdec ("[0x1.303AA9620B223, 0x1.303AA9620B224]_com"))); interval-1.4.1/inst/@infsupdec/csch.m0000644000000000000000000000317412657475772015655 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} csch (@var{X}) ## ## Compute the hyperbolic cosecant, that is the reciprocal hyperbolic sine. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## csch (infsupdec (1)) ## @result{} ans ⊂ [0.85091, 0.85092]_com ## @end group ## @end example ## @seealso{@@infsupdec/sinh, @@infsupdec/sech, @@infsupdec/coth} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-03-15 function result = csch (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (csch (intervalpart (x))); ## csch is defined and continuous for x ~= 0 result.dec = min (result.dec, x.dec); result.dec (inf (x) <= 0 & sup (x) >= 0) = _trv (); endfunction %!test "from the documentation string"; %! assert (isequal (csch (infsupdec (1)), infsupdec ("[0x1.B3AB8A78B90Cp-1, 0x1.B3AB8A78B90C1p-1]_com"))); interval-1.4.1/inst/@infsupdec/decorationpart.m0000644000000000000000000000540212657475772017747 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} decorationpart (@var{X}) ## @defmethodx {@@infsupdec} decorationpart (@var{X}, @var{TYPE}) ## ## Return the decoration of the decorated interval @var{X}. ## ## The returned value depends on the requested @var{TYPE}. ## @table @asis ## @item @option{char} (default) ## The decoration is a cell array of character strings and its size equals the ## size of its interval part. Possible values: @option{ill}, @option{trv}, ## @option{def}, @option{dac}, @option{com}. ## @item @option{uint8} ## The decoration is a matrix of uint8 numbers and its size equals the size of ## its interval part. Possible values: @option{0}, @option{4}, @option{8}, ## @option{12}, @option{16} as defined by IEEE Std 1788-2015, 14.4 Interchange ## representations and encodings. ## @end table ## ## @example ## @group ## x = infsupdec ("[0, 1] [1, inf] [-1, 1]_def [empty]"); ## decorationpart (x) ## @result{} ans = ## @{ ## [1,1] = com ## [1,2] = dac ## [1,3] = def ## [1,4] = trv ## @} ## decorationpart (x, "uint8") ## @result{} ans = ## ## 16 12 8 4 ## ## @end group ## @end example ## @seealso{@@infsupdec/intervalpart} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-12 function dec = decorationpart (x, type) if (nargin > 2) print_usage (); return endif if (nargin < 2) type = "char"; endif switch (type) case "char" # see below case "uint8" dec = x.dec; return otherwise error ("decorationpart: illegal value for parameter TYPE") endswitch persistent dec_translation = {... # 0 = ill "ill", [], [], [], ... # 4 = trv "trv", [], [], [], ... # 8 = def "def", [], [], [], ... # 12 = dac "dac", [], [], [], ... # 16 = com "com"}; dec = cell (size (x.dec)); dec (:) = dec_translation (x.dec (:) + 1); endfunction %!assert (decorationpart (infsupdec (3, 4)), {"com"}); %!assert (decorationpart (infsupdec (3, inf)), {"dac"}); %!assert (decorationpart (infsupdec ()), {"trv"}); interval-1.4.1/inst/@infsupdec/det.m0000644000000000000000000000305312657475772015505 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} det (@var{A}) ## ## Compute the determinant of matrix @var{A}. ## ## The determinant for matrices of size 3×3 or greater is computed via L-U ## decomposition and may be affected by overestimation due to the dependency ## problem. ## ## Accuracy: The result is a valid enclosure. ## ## @example ## @group ## det (infsupdec (magic (3))) ## @result{} ans = [-360]_com ## @end group ## @end example ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-10-24 function result = det (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (det (intervalpart (x))); result.dec = min (result.dec, min (min (x.dec))); endfunction %!test "from the documentation string"; %! assert (det (infsupdec (magic (3))) == -360); interval-1.4.1/inst/@infsupdec/diag.m0000644000000000000000000000502312657475772015634 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsupdec} {M =} diag (@var{V}) ## @deftypemethodx {@@infsupdec} {V =} diag (@var{M}) ## @deftypemethodx {@@infsupdec} {M =} diag (@var{V}, @var{K}) ## @deftypemethodx {@@infsupdec} {M =} diag (@var{V}, @var{M}, @var{N}) ## @deftypemethodx {@@infsupdec} {V =} diag (@var{M}, @var{K}) ## ## Create a diagonal matrix @var{M} with vector @var{V} on diagonal @var{K} or ## extract a vector @var{V} from the @var{K}-th diagonal of matrix @var{M}. ## ## With three arguments, create a matrix of size @var{M}×@var{N}. ## ## @example ## @group ## diag (infsupdec (1 : 3)) ## @result{} ans = 3×3 interval matrix ## ## [1]_com [0]_com [0]_com ## [0]_com [2]_com [0]_com ## [0]_com [0]_com [3]_com ## @end group ## @end example ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-10-24 function result = diag (x, m, n) if (not (isa (x, 'infsupdec'))) error ('diag: invalid argument; only the first may be an interval'); endif if (isnai (x)) result = x; return endif switch (nargin) case 1 result = newdec (diag (intervalpart (x))); result.dec = diag (x.dec); case 2 result = newdec (diag (intervalpart (x), m)); result.dec = diag (x.dec, m); case 3 result = newdec (diag (intervalpart (x), m, n)); result.dec = diag (x.dec, m, n); otherwise print_usage (); endswitch result.dec (result.dec == 0) = _com (); # any new elements are [0]_com endfunction %!assert (diag (infsupdec (-inf, inf)) == "[Entire]"); %!assert (diag (infsupdec ()) == "[Empty]"); %!assert (numel (diag (infsupdec ([]))), 0); %!xtest assert (isequal (diag (infsupdec (magic (3))), infsupdec ([8; 5; 2]))); %!xtest assert (isequal (diag (infsupdec ([8 5 3])), infsupdec ([8 0 0; 0 5 0; 0 0 3]))); interval-1.4.1/inst/@infsupdec/dilog.m0000644000000000000000000000363312657475772016033 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} dilog (@var{X}) ## ## Compute the real part of the dilogarithm function. ## ## @tex ## $$ ## {\rm dilog} (x) = -\Re \int_0^x {{\log (1-t)} \over t} dt ## $$ ## @end tex ## @ifnottex ## @group ## @verbatim ## x ## / log (1 - t) ## dilog (x) = - Re | ------------- dt ## / t ## 0 ## @end verbatim ## @end group ## @end ifnottex ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## dilog (infsupdec (1)) ## @result{} ans ⊂ [1.6449, 1.645]_com ## @end group ## @end example ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-29 function result = dilog (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (dilog (intervalpart (x))); ## dilog is defined and continuous everywhere result.dec = min (result.dec, x.dec); endfunction %!assert (isequal (dilog (infsupdec (-inf, inf)), infsupdec ("[-Inf, +0x1.3BD3CC9BE45DFp1]_dac"))); %!test "from the documentation string"; %! assert (isequal (dilog (infsupdec (1)), infsupdec ("[0x1.A51A6625307D3, 0x1.A51A6625307D4]_com"))); interval-1.4.1/inst/@infsupdec/disjoint.m0000644000000000000000000000325612657475772016561 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} disjoint (@var{A}, @var{B}) ## ## Evaluate disjoint comparison on intervals. ## ## True, if all numbers from @var{A} are not contained in @var{B} and vice ## versa. False, if @var{A} and @var{B} have at least one element in common. ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## @seealso{@@infsupdec/eq, @@infsupdec/subset, @@infsupdec/interior} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = disjoint (a, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (a, "infsupdec"))) a = infsupdec (a); endif if (not (isa (b, "infsupdec"))) b = infsupdec (b); endif if (isnai (a) || isnai (b)) result = false (); else result = disjoint (intervalpart (a), intervalpart (b)); endif endfunction %!assert (disjoint (infsupdec (3, 4), infsupdec (5, 6))); %!assert (not (disjoint (infsupdec (3, 4), infsupdec (4, 5)))); interval-1.4.1/inst/@infsupdec/dot.m0000644000000000000000000000620512657475772015521 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} dot (@var{X}, @var{Y}) ## @defmethodx {@@infsupdec} dot (@var{X}, @var{Y}, @var{DIM}) ## ## Compute the dot product of two interval vectors. ## ## If @var{X} and @var{Y} are matrices, calculate the dot products along the ## first non-singleton dimension. If the optional argument @var{DIM} is given, ## calculate the dot products along this dimension. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## dot ([infsupdec(1), 2, 3], [infsupdec(2), 3, 4]) ## @result{} ans = [20]_com ## @end group ## @group ## dot (infsupdec ([realmax; realmin; realmax]), [1; -1; -1], 1) ## @result{} ans ⊂ [-2.2251e-308, -2.225e-308]_com ## @end group ## @end example ## @seealso{@@infsupdec/plus, @@infsupdec/sum, @@infsupdec/times} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-01-31 function result = dot (x, y, dim) if (nargin < 2 || nargin > 3) print_usage (); return endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (not (isa (y, "infsupdec"))) y = infsupdec (y); endif if (nargin < 3) if (isvector (x.dec) && isvector (y.dec)) ## Align vectors along common dimension dim = 1; x = vec (x, dim); y = vec (y, dim); else ## Try to find non-singleton dimension dim = find (any (size (x.dec), size (y.dec)) > 1, 1); if (isempty (dim)) dim = 1; endif endif endif ## null matrix input -> null matrix output if (isempty (x.dec) || isempty (y.dec)) result = infsupdec (zeros (min (size (x.dec), size (y.dec)))); return endif ## Only the sizes of non-singleton dimensions must agree. Singleton dimensions ## do broadcast (independent of parameter dim). if ((min (size (x.dec, 1), size (y.dec, 1)) > 1 && ... size (x.dec, 1) ~= size (y.dec, 1)) || ... (min (size (x.dec, 2), size (y.dec, 2)) > 1 && ... size (x.dec, 2) ~= size (y.dec, 2))) error ("interval:InvalidOperand", "dot: sizes of X and Y must match") endif result = newdec (dot (intervalpart (x), intervalpart (y), dim)); result.dec = min (result.dec, ... min (min (x.dec, [], dim), min (y.dec, [], dim))); endfunction %!test "from the documentation string"; %! assert (isequal (dot ([infsupdec(1), 2, 3], [infsupdec(2), 3, 4]), infsupdec (20))); %! assert (isequal (dot (infsupdec ([realmax; realmin; realmax]), [1; -1; -1], 1), infsupdec (-realmin))); interval-1.4.1/inst/@infsupdec/ei.m0000644000000000000000000000410612657475772015326 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} ei (@var{X}) ## ## Compute the exponential integral for positive arguments. ## ## @tex ## $$ ## {\rm ei} (x) = \int_{-\infty}^x {{\exp t} \over t} dt ## $$ ## @end tex ## @ifnottex ## @group ## @verbatim ## x ## / exp (t) ## ei (x) = | --------- dt ## / t ## -∞ ## @end verbatim ## @end group ## @end ifnottex ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## ei (infsupdec (1)) ## @result{} ans ⊂ [1.8951, 1.8952]_com ## @end group ## @end example ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-29 function result = ei (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (ei (intervalpart (x))); result.dec = min (result.dec, x.dec); ## ei is continuous everywhere, but defined for x > 0 only result.dec (not (interior (x, infsupdec (0, inf)))) = _trv (); endfunction %!assert (isempty (ei (infsupdec (0)))); %!assert (isempty (ei (infsupdec (-inf, -2)))); %!assert (isequal (ei (infsupdec (0, inf)), infsupdec ("[Entire]_trv"))); %!assert (isequal (ei (infsupdec (1, inf)), infsupdec ("[0x1.E52670F350D08, Inf]_dac"))); %!test "from the documentation string"; %! assert (isequal (ei (infsupdec (1)), infsupdec ("[0x1.E52670F350D08, 0x1.E52670F350D09]_com"))); interval-1.4.1/inst/@infsupdec/eq.m0000644000000000000000000000541012657475772015335 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsupdec} eq (@var{A}, @var{B}) ## @defopx Operator {@@infsupdec} {@var{A} == @var{B}} ## ## Compare intervals @var{A} and @var{B} for equality. ## ## True, if all numbers from @var{A} are also contained in @var{B} and vice ## versa. False, if @var{A} contains a number which is not a member in @var{B} ## or vice versa. ## ## @example ## @group ## x = infsupdec (2, 3); ## y = infsupdec (1, 2); ## x == y ## @result{} ans = 0 ## @end group ## @end example ## @seealso{@@infsupdec/subset, @@infsupdec/interior, @@infsupdec/disjoint} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = eq (a, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (a, "infsupdec"))) a = infsupdec (a); endif if (not (isa (b, "infsupdec"))) b = infsupdec (b); endif if (isnai (a) || isnai (b)) result = false (); else result = eq (intervalpart (a), intervalpart (b)); endif endfunction %!test "Empty interval"; %! assert (eq (infsupdec (), infsupdec ()) == true); %! assert (eq (infsupdec (), infsupdec (1)) == false); %! assert (eq (infsupdec (0), infsupdec ()) == false); %! assert (eq (infsupdec (-inf, inf), infsupdec ()) == false); %!test "Singleton intervals"; %! assert (eq (infsupdec (0), infsupdec (1)) == false); %! assert (eq (infsupdec (0), infsupdec (0)) == true); %!test "Bounded intervals"; %! assert (eq (infsupdec (1, 2), infsupdec (3, 4)) == false); %! assert (eq (infsupdec (1, 2), infsupdec (2, 3)) == false); %! assert (eq (infsupdec (1, 2), infsupdec (1.5, 2.5)) == false); %! assert (eq (infsupdec (1, 2), infsupdec (1, 2)) == true); %!test "Unbounded intervals"; %! assert (eq (infsupdec (0, inf), infsupdec (-inf, 0)) == false); %! assert (eq (infsupdec (0, inf), infsupdec (0, inf)) == true); %! assert (eq (infsupdec (-inf, 0), infsupdec (-inf, 0)) == true); %! assert (eq (infsupdec (-inf, inf), infsupdec (42)) == false); %! assert (eq (infsupdec (-inf, 0), infsupdec (-inf, inf)) == false); %! assert (eq (infsupdec (-inf, inf), infsupdec (-inf, inf)) == true); interval-1.4.1/inst/@infsupdec/erf.m0000644000000000000000000000341212657475772015504 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} erf (@var{X}) ## ## Compute the error function. ## ## @tex ## $$ ## {\rm erf} (x) = {2 \over \sqrt{\pi}}\int_0^x \exp (-t^2) dt ## $$ ## @end tex ## @ifnottex ## @group ## @verbatim ## x ## 2 / ## erf (x) = ----- | exp (-t²) dt ## √π / ## 0 ## @end verbatim ## @end group ## @end ifnottex ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## erf (infsupdec (1)) ## @result{} ans ⊂ [0.8427, 0.84271]_com ## @end group ## @end example ## @seealso{@@infsupdec/erfc} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-28 function result = erf (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (erf (intervalpart (x))); ## erf is defined and continuous everywhere result.dec = min (result.dec, x.dec); endfunction %!test "from the documentation string"; %! assert (erf (infsupdec (1)) == "[0x1.AF767A741088Ap-1, 0x1.AF767A741088Bp-1]"); interval-1.4.1/inst/@infsupdec/erfc.m0000644000000000000000000000344712657475772015657 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} erfc (@var{X}) ## ## Compute the complementary error function. ## ## @tex ## $$ ## {\rm erfc} (x) = {2 \over \sqrt{\pi}}\int_x^\infty \exp (-t^2) dt ## $$ ## @end tex ## @ifnottex ## @group ## @verbatim ## ∞ ## 2 / ## erfc (x) = ----- | exp (-t²) dt ## √π / ## x ## @end verbatim ## @end group ## @end ifnottex ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## erfc (infsupdec (1)) ## @result{} ans ⊂ [0.15729, 0.1573]_com ## @end group ## @end example ## @seealso{@@infsup/erf} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-28 function result = erfc (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (erfc (intervalpart (x))); ## erfc is defined and continuous everywhere result.dec = min (result.dec, x.dec); endfunction %!test "from the documentation string"; %! assert (erfc (infsupdec (1)) == "[0x1.4226162FBDDD4p-3, 0x1.4226162FBDDD5p-3]"); interval-1.4.1/inst/@infsupdec/exp.m0000644000000000000000000000272712657475772015534 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} exp (@var{X}) ## ## Compute the exponential function. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## exp (infsupdec (1)) ## @result{} ans ⊂ [2.7182, 2.7183]_com ## @end group ## @end example ## @seealso{@@infsupdec/log, @@infsupdec/pow} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = exp (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (exp (intervalpart (x))); ## exp is defined and continuous everywhere result.dec = min (result.dec, x.dec); endfunction %!test "from the documentation string"; %! assert (isequal (exp (infsupdec (1)), infsupdec ("e"))); interval-1.4.1/inst/@infsupdec/expm1.m0000644000000000000000000000306112657475772015762 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} expm1 (@var{X}) ## ## Compute @code{exp (@var{X} - 1)} accurately in the neighborhood of zero. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## expm1 (infsupdec (eps)) ## @result{} ans ⊂ [2.2204e-16, 2.2205e-16]_com ## @end group ## @end example ## @seealso{@@infsup/exp, @@infsup/log1p} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-20 function result = expm1 (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (expm1 (intervalpart (x))); ## expm1 is defined and continuous everywhere result.dec = min (result.dec, x.dec); endfunction %!test "from the documentation string"; %! assert (isequal (expm1 (infsupdec (eps)), infsupdec ("[0x1p-52, 0x1.0000000000001p-52]"))); interval-1.4.1/inst/@infsupdec/factorial.m0000644000000000000000000000502512657475772016676 0ustar 00000000000000## Copyright 2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsup} factorial (@var{N}) ## ## Compute the factorial of @var{N} where @var{N} is a real non-negative ## integer. ## ## If @var{N} is a scalar, this is equivalent to ## @display ## factorial (@var{N}) = 1 * 2 * @dots{} * @var{N}. ## @end display ## For vector or matrix arguments, return the factorial of each element in the ## array. ## ## For non-integers see the generalized factorial function @command{gamma}. ## Not that the factorial function grows large quite quickly, and the result ## cannot be represented exactly in binary64 for @var{N} ≥ 23 and will overflow ## for @var{N} ≥ 171. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## factorial (infsupdec (6)) ## @result{} ans = [720]_dac ## @end group ## @end example ## @seealso{@@infsupdec/prod, @@infsupdec/gamma, @@infsupdec/gammaln} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2016-01-31 function result = factorial (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif ## The function is not continuous, since it is defined for non-negative ## integrals only. Thus the best possible decoration can be “dac”. result = infsupdec (factorial (intervalpart (x)), "dac"); result.dec = min (result.dec, x.dec); ## The function is defined for non-negative integrals only defined = issingleton (x) & fix (sup (x)) == sup (x); result.dec (not (defined)) = _trv (); endfunction %!test "from the documentation string"; %! assert (factorial (infsupdec (6)) == infsupdec (720, "dac")); %!assert (factorial (infsupdec (0)) == infsupdec (1, "dac")); %!assert (factorial (infsupdec ("[0, 1.99]")) == infsupdec (1, "trv")); %!assert (factorial (infsupdec ("[0, 2]")) == "[1, 2]_trv"); %!assert (factorial (infsupdec ("[1.4, 1.6]")) == "[Empty]_trv"); interval-1.4.1/inst/@infsupdec/fix.m0000644000000000000000000000424112657475772015517 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} fix (@var{X}) ## ## Truncate fractional portion of each number in interval @var{X}. This is ## equivalent to rounding towards zero. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## fix (infsupdec (2.5, 3.5)) ## @result{} ans = [2, 3]_def ## fix (infsupdec (-0.5, 5)) ## @result{} ans = [0, 5]_def ## @end group ## @end example ## @seealso{@@infsupdec/floor, @@infsupdec/ceil, @@infsupdec/round, @@infsupdec/roundb} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = fix (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (fix (intervalpart (x))); result.dec = min (result.dec, x.dec); ## Between two integral numbers the function is constant, thus continuous ## At x == 0 the function is continuous. discontinuous = not (issingleton (result)); result.dec (discontinuous) = min (result.dec (discontinuous), _def ()); onlyrestrictioncontinuous = issingleton (result) & ... ((sup (x) < 0 & fix (sup (x)) == sup (x)) | ... (inf (x) > 0 & fix (inf (x)) == inf (x))); result.dec (onlyrestrictioncontinuous) = ... min (result.dec (onlyrestrictioncontinuous), _dac ()); endfunction %!test "from the documentation string"; %! assert (isequal (fix (infsupdec (2.5, 3.5)), infsupdec (2, 3, "def"))); %! assert (isequal (fix (infsupdec (-0.5, 5)), infsupdec (0, 5, "def"))); interval-1.4.1/inst/@infsupdec/floor.m0000644000000000000000000000377412657475772016064 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} floor (@var{X}) ## ## Round each number in interval @var{X} towards -Inf. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## floor (infsupdec (2.5, 3.5)) ## @result{} ans = [2, 3]_def ## floor (infsupdec (-0.5, 5)) ## @result{} ans = [-1, +5]_def ## @end group ## @end example ## @seealso{@@infsupdec/ceil, @@infsupdec/round, @@infsupdec/roundb, @@infsupdec/fix} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = floor (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (floor (intervalpart (x))); result.dec = min (result.dec, x.dec); ## Between two integral numbers the function is constant, thus continuous discontinuous = not (issingleton (result)); result.dec (discontinuous) = min (result.dec (discontinuous), _def ()); onlyrestrictioncontinuous = issingleton (result) & fix (inf (x)) == inf (x); result.dec (onlyrestrictioncontinuous) = ... min (result.dec (onlyrestrictioncontinuous), _dac ()); endfunction %!test "from the documentation string"; %! assert (isequal (floor (infsupdec (2.5, 3.5)), infsupdec (2, 3, "def"))); %! assert (isequal (floor (infsupdec (-0.5, 5)), infsupdec (-1, 5, "def"))); interval-1.4.1/inst/@infsupdec/fma.m0000644000000000000000000000445712657475772015505 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} fma (@var{X}, @var{Y}, @var{Z}) ## ## Fused multiply and add @code{@var{X} * @var{Y} + @var{Z}}. ## ## This function is semantically equivalent to evaluating multiplication and ## addition separately, but in addition guarantees a tight enclosure of the ## result. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## output_precision (16, 'local') ## fma (infsupdec (1+eps), infsupdec (7), infsupdec ("0.1")) ## @result{} ans ⊂ [7.100000000000001, 7.100000000000003]_com ## infsupdec (1+eps) * infsupdec (7) + infsupdec ("0.1") ## @result{} ans ⊂ [7.1, 7.100000000000003]_com ## @end group ## @end example ## @seealso{@@infsupdec/plus, @@infsupdec/mtimes} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = fma (x, y, z) if (nargin ~= 3) print_usage (); return endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (not (isa (y, "infsupdec"))) y = infsupdec (y); endif if (not (isa (z, "infsupdec"))) z = infsupdec (z); endif if (isnai (x)) result = x; return endif if (isnai (y)) result = y; return endif if (isnai (z)) result = z; return endif result = newdec (... fma (intervalpart (x), intervalpart (y), intervalpart (z))); ## fma is defined and continuous everywhere result.dec = min (result.dec, min (x.dec, min (y.dec, z.dec))); endfunction %!test "from the documentation string"; %! assert (isequal (fma (infsupdec (1+eps), infsupdec (7), infsupdec ("0.1")), infsupdec ("[0x1.C666666666668p2, 0x1.C666666666669p2]"))); interval-1.4.1/inst/@infsupdec/gamma.m0000644000000000000000000000416312657475772016016 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} gamma (@var{X}) ## ## Compute the gamma function. ## ## @tex ## $$ ## {\rm gamma} (x) = \int_0^\infty t^(x-1) \exp (-t) dt ## $$ ## @end tex ## @ifnottex ## @group ## @verbatim ## ∞ ## / ## gamma (x) = | t^(x - 1) * exp (-t) dt ## / ## 0 ## @end verbatim ## @end group ## @end ifnottex ## ## Accuracy: The result is a valid enclosure. The result is tightest for ## @var{X} >= -10. ## ## @example ## @group ## gamma (infsupdec (1.5)) ## @result{} ans ⊂ [0.88622, 0.88623]_com ## @end group ## @end example ## @seealso{@@infsupdec/psi, @@infsupdec/gammaln, @@infsupdec/factorial} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-03-01 function result = gamma (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (gamma (intervalpart (x))); ## gamma is continuous where it is defined result.dec = min (result.dec, x.dec); undefined = (inf (x) <= 0 & fix (inf (x)) == inf (x)) | ... (sup (x) <= 0 & fix (sup (x)) == sup (x)) | ... (inf (x) < 0 & ceil (inf (x)) <= floor (sup (x))); result.dec (undefined) = min (result.dec (undefined), _trv ()); endfunction %!test "from the documentation string"; %! assert (isequal (gamma (infsupdec (1.5)), infsupdec ("[0x1.C5BF891B4EF6Ap-1, 0x1.C5BF891B4EF6Bp-1]_com"))); interval-1.4.1/inst/@infsupdec/gammaln.m0000644000000000000000000000413212657475772016344 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} gammaln (@var{X}) ## ## Compute the logarithm of the gamma function for positive arguments. ## ## @tex ## $$ ## {\rm gammaln} (x) = \log \int_0^\infty t^{x-1} \exp (-t) dt ## $$ ## @end tex ## @ifnottex ## @group ## @verbatim ## ∞ ## / ## gammaln (x) = log | t^(x-1) exp (-t) dt ## / ## 0 ## @end verbatim ## @end group ## @end ifnottex ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## gammaln (infsupdec (1.5)) ## @result{} ans ⊂ [-0.12079, -0.12078]_com ## @end group ## @end example ## @seealso{@@infsupdec/psi, @@infsupdec/gamma, @@infsupdec/factorial} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-28 function result = gammaln (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (gammaln (intervalpart (x))); result.dec = min (result.dec, x.dec); ## gammaln is continuous everywhere, but defined for x > 0 only result.dec (not (interior (x, infsupdec (0, inf)))) = _trv (); endfunction %!assert (isequal (gammaln (infsupdec (-inf, inf)), infsupdec ("[-0x1.F19B9BCC38A42p-4, +Inf]_trv"))); %!test "from the documentation string"; %! assert (isequal (gammaln (infsupdec (1.5)), infsupdec ("[-0x1.EEB95B094C192p-4, -0x1.EEB95B094C191p-4]_com"))); interval-1.4.1/inst/@infsupdec/gauss.m0000644000000000000000000000421212657475772016051 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsupdec} {@var{x} =} gauss (@var{A}, @var{b}) ## ## Solve a linear interval system @var{A} * @var{x} = @var{b} using Gaussian ## elimination. ## ## The found enclosure is improved with the help of the Gauß-Seidel-method. ## ## Note: This algorithm is very inaccurate and slow for matrices of a dimension ## greater than 3. A better solver is provided by @code{mldivide}. The ## inaccuracy mainly comes from the dependency problem of interval arithmetic ## during back-substitution of the solution's enclosure. ## ## Accuracy: The result is a valid enclosure. ## ## @example ## @group ## gauss (infsupdec ([1, 0; 0, 2]), [2, 0; 0, 4]) ## @result{} ans = 2×2 interval matrix ## [2]_trv [0]_trv ## [0]_trv [2]_trv ## @end group ## @end example ## @seealso{@@infsupdec/mldivide} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-18 function result = gauss (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (not (isa (y, "infsupdec"))) y = infsupdec (y); endif if (isnai (x)) result = x; return endif if (isnai (y)) result = y; return endif result = infsupdec (gauss (intervalpart (x), intervalpart (y)), "trv"); endfunction %!xtest "from the documentation string"; %! assert (isequal (gauss (infsupdec ([1, 0; 0, 2]), [2, 0; 0, 4]), infsupdec ([2, 0; 0, 2], "trv"))); interval-1.4.1/inst/@infsupdec/horzcat.m0000644000000000000000000000426412657475772016410 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsupdec} horzcat (@var{ARRAY1}, @var{ARRAY2}, @dots{}) ## @defopx Operator {@@infsupdec} {[@var{ARRAY1}, @var{ARRAY2}, @dots{}]} ## ## Return the horizontal concatenation of interval array objects along ## dimension 2. ## ## @example ## @group ## a = infsupdec (2, 5); ## [a, a, a] ## @result{} ans = 1×3 interval vector ## [2, 5]_com [2, 5]_com [2, 5]_com ## @end group ## @end example ## @seealso{@@infsupdec/vertcat} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-11-02 function result = horzcat (varargin) ## Conversion to interval decoratedintervals = cellfun ("isclass", varargin, "infsupdec"); to_convert = not (decoratedintervals); varargin (to_convert) = cellfun (@infsupdec, varargin (to_convert), ... "UniformOutput", false ()); nais = cellfun (@isnai, varargin); if (any (nais)) ## Simply return first NaI result = varargin {find (nais, 1)}; return endif l = cell2mat (cellfun (@inf, varargin, "UniformOutput", false ())); u = cell2mat (cellfun (@sup, varargin, "UniformOutput", false ())); d = cell2mat (cellfun (@(x) x.dec, varargin, "UniformOutput", false ())); result = newdec (infsup (l, u)); result.dec = d; endfunction %!xtest assert (isequal (horzcat (infsupdec (1), infsupdec (2)), infsupdec (horzcat (1, 2)))); %!xtest "from the documentation string"; %! a = infsupdec (2, 5); %! assert (isequal (horzcat (a, a, a), infsupdec ([2, 2, 2], [5, 5, 5]))); interval-1.4.1/inst/@infsupdec/hypot.m0000644000000000000000000000346012657475772016076 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} hypot (@var{X}, @var{Y}) ## ## Compute the euclidean norm. ## ## @code{hypot (@var{x}, @var{y}) = sqrt (@var{x}^2 + @var{y}^2)} ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## x = infsupdec (2, 3); ## y = infsupdec (1, 2); ## hypot (x, y) ## @result{} ans ⊂ [2.236, 3.6056]_com ## @end group ## @end example ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-20 function result = hypot (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (not (isa (y, "infsupdec"))) y = infsupdec (y); endif if (isnai (x)) result = x; return endif if (isnai (y)) result = y; return endif result = newdec (hypot (intervalpart (x), intervalpart (y))); ## hypot is continuous and defined everywhere result.dec = min (result.dec, min (x.dec, y.dec)); endfunction %!test "from the documentation string"; %! assert (isequal (hypot (infsupdec (2, 3), infsupdec (1, 2)), infsupdec ("[0x1.1E3779B97F4A7p1, 0x1.CD82B446159F4p1]"))); interval-1.4.1/inst/@infsupdec/infsupdec.m0000644000000000000000000004035512657475772016717 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypeop Constructor {@@infsupdec} {[@var{X}, @var{ISEXACT}] =} infsupdec () ## @deftypeopx Constructor {@@infsupdec} {[@var{X}, @var{ISEXACT}] =} infsupdec (@var{M}) ## @deftypeopx Constructor {@@infsupdec} {[@var{X}, @var{ISEXACT}] =} infsupdec (@var{M}, @var{D}) ## @deftypeopx Constructor {@@infsupdec} {[@var{X}, @var{ISEXACT}] =} infsupdec (@var{S}) ## @deftypeopx Constructor {@@infsupdec} {[@var{X}, @var{ISEXACT}] =} infsupdec (@var{L}, @var{U}) ## @deftypeopx Constructor {@@infsupdec} {[@var{X}, @var{ISEXACT}] =} infsupdec (@var{L}, @var{U}, @var{D}) ## @deftypeopx Constructor {@@infsupdec} {[@var{X}, @var{ISEXACT}] =} infsupdec (@var{I}, @var{D}) ## ## Create a decorated interval from boundaries. Convert boundaries to double ## precision. ## ## The syntax without parameters creates an (exact) empty interval. The syntax ## with a single parameter @code{infsupdec (@var{M})} equals ## @code{infsupdec (@var{M}, @var{M})}. The syntax ## @code{infsupdec (@var{M}, @var{D})} equals ## @code{infsupdec (@var{M}, @var{M}, @var{D})}. The syntax ## @code{infsupdec (@var{S})} parses a possibly decorated interval literal in ## inf-sup form or as a special value, where @code{infsupdec ("[S1, S2]")} is ## equivalent to @code{infsupdec ("S1", "S2")} and, if [S1, S2]_D is a valid ## interval literal, ## @code{infsupdec ("[S1, S2]_D")} is equivalent to ## @code{infsupdec ("S1", "S2", "D")}. The syntax ## @code{infsupdec (@var{I}, @var{D})} overrides an interval @var{I}'s ## decoration with a new decoration @var{D}. A second, logical output ## @var{ISEXACT} indicates if @var{X}'s boundaries both have been converted ## without precision loss and without changes to the optional, desired ## decoration. ## ## If construction fails, the special value NaI, “not an interval,” will be ## returned and a warning message will be raised. NaI is equivalent to ## [Empty] together with an ill-formed decoration. ## ## Each boundary can be provided in the following formats: literal constants ## [+-]inf[inity], e, pi; scalar real numeric data types, i. e., double, ## single, [u]int[8,16,32,64]; or decimal numbers as strings of the form ## [+-]d[,.]d[[eE][+-]d]; or hexadecimal numbers as string of the form ## [+-]0xh[,.]h[[pP][+-]d]; or decimal numbers in rational form ## [+-]d/d. ## ## Also it is possible, to construct intervals from the uncertain form in the ## form @code{m?ruE}, where @code{m} is a decimal mantissa, ## @code{r} is empty (= half ULP) or a decimal integer ULP count or a ## second @code{?} character for unbounded intervals, @code{u} is ## empty or a direction character (u: up, d: down), and @code{E} is an ## exponential field. ## ## If decimal or hexadecimal numbers are no binary64 floating point numbers, a ## tight enclosure will be computed. int64 and uint64 numbers of high ## magnitude (> 2^53) can also be affected from precision loss. ## ## The decoration @var{D} must be any of @code{com}, @code{dac}, @code{def}, ## @code{trv}, or @code{ill}. Illegal decorations within interval literals ## will produce NaIs, whereas illegal decorations provided as an additional ## function parameter will be automatically adjusted. ## ## For the creation of interval matrices, arguments may be provided as (1) cell ## arrays with arbitrary/mixed types, (2) numeric matrices, or (3) strings. ## Scalar values do broadcast. ## ## Non-standard behavior: This class constructor is not described by IEEE Std ## 1788-2015, however it implements the standard functions setDec, ## numsToInterval, and textToInterval. ## ## @example ## @group ## v = infsupdec () ## @result{} v = [Empty]_trv ## w = infsupdec (1) ## @result{} w = [1]_com ## x = infsupdec (2, 3) ## @result{} x = [2, 3]_com ## y = infsupdec ("0.1") ## @result{} y ⊂ [0.099999, 0.10001]_com ## z = infsupdec ("0.1", "0.2") ## @result{} z ⊂ [0.099999, 0.20001]_com ## @end group ## @end example ## @seealso{exacttointerval, hull, midrad, @@infsup/newdec} ## @end deftypeop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-12 function [x, isexact] = infsupdec (varargin) ## The decorated version must return NaI instead of an error if interval ## construction failed, so we use a try & catch block. try if (nargin >= 1 && ischar (varargin {end})) varargin {end} = __split_interval_literals__ (varargin {end}); endif ## The setDec function, as described by IEEE Std 1788-2015, ## may fix decorations fix_illegal_decorations = true (); if (nargin >= 1 && ... iscellstr (varargin {end}) && ... not (isempty (varargin {end})) && ... any (strcmpi (varargin {end} {1}, ... {"com", "dac", "def", "trv", "ill"}))) ## The decoration information has been passed as the last parameter decstr = varargin {end}; switch nargin case 1 [bare, isexact] = infsup (); case 2 if (isa (varargin {1}, "infsup")) bare = infsup (inf (varargin {1}), sup (varargin {1})); isexact = true (); else [bare, isexact] = infsup (varargin {1}); endif case 3 [bare, isexact] = infsup (varargin {1}, varargin {2}); otherwise print_usage (); return endswitch elseif (nargin == 1 && iscell (varargin {1})) ## Parse possibly decorated interval literals chars = cellfun ("ischar", varargin {1}); varargin {1} (chars) = cellfun (@strsplit, ... varargin {1} (chars), ... {"_"}, ... "UniformOutput", false); if (any (any (cellfun ("size", varargin {1} (chars), 2) > 2))) ## More than 2 underscores in any literal error ("interval:InvalidOperand", ... "illegal decorated interval literal") endif ## Extract decoration decstr = cell (size (varargin {1})); hasdec = false (size (varargin {1})); hasdec (chars) = cellfun ("size", varargin {1} (chars), 2) == 2; decstr (hasdec) = cellfun (@(x) x {2}, varargin {1} (hasdec), ... "UniformOutput", false); varargin {1} (chars) = cellfun (@(x) x {1}, varargin {1} (chars), ... "UniformOutput", false); ## Note: The representation of NaI, will trigger an error in the infsup ## constructor [bare, isexact, overflow] = infsup (varargin {1}); ## Silently fix decorated interval literals when overflow occurred decstr (overflow & strcmpi (decstr, "com")) = "dac"; ## Interval literals must not carry illegal decorations fix_illegal_decorations = false (); else ## Undecorated interval boundaries decstr = {""}; switch nargin case 0 [bare, isexact] = infsup (); case 1 if (isa (varargin {1}, "infsupdec")) x = varargin {1}; isexact = true (); return elseif (isa (varargin {1}, "infsup")) bare = varargin {1}; isexact = true (); if (not (all (all (isempty (bare))))) warning ("interval:ImplicitPromote", ... ["Implicitly decorated bare interval; ", ... "resulting decoration may be wrong"]); endif else [bare, isexact] = infsup (varargin {1}); endif case 2 [bare, isexact] = infsup (varargin {1}, varargin {2}); otherwise print_usage (); endswitch endif assert (isa (bare, "infsup")); assert (iscell (decstr)); ## Convert decoration strings into decoration matrix. ## Initialize the matrix with the ill decoration, which is not allowed to ## be used explicitly as a parameter to this function. dec = _ill () (ones (size (decstr))); ## Missing decorations will later be assigned their final value missingdecoration_value = uint8 (1); # magic value, not used otherwise dec (cellfun ("isempty", decstr)) = missingdecoration_value; dec (strcmpi (decstr, "com")) = _com (); dec (strcmpi (decstr, "dac")) = _dac (); dec (strcmpi (decstr, "def")) = _def (); dec (strcmpi (decstr, "trv")) = _trv (); if (any (any (dec == _ill ()))) error ("interval:InvalidOperand", "illegal decoration"); endif ## Broadcast decoration if (isscalar (dec) && not (isscalar (bare))) dec = dec (ones (size (bare))); elseif (not (all (size (dec) == size (bare)))) error ("interval:InvalidOperand", "decoration size mismatch") endif ## Add missing decoration missingdecoration = dec == missingdecoration_value; dec (missingdecoration) = _dac (); dec (missingdecoration & isempty (bare)) = _trv (); dec (missingdecoration & iscommoninterval (bare)) = _com (); ## Check decoration empty_not_trv = isempty (bare) & dec ~= _trv (); if (any (any (empty_not_trv))) if (not (fix_illegal_decorations)) error ("interval:InvalidOperand", ... "illegal decorated interval literal") endif isexact = false (); dec (empty_not_trv) = _trv (); endif uncommon_com = not (iscommoninterval (bare)) & dec == _com (); if (any (any (uncommon_com))) if (not (fix_illegal_decorations)) error ("interval:InvalidOperand", ... "illegal decorated interval literal") endif isexact = false (); dec (uncommon_com) = _dac (); endif catch switch lasterror.identifier case "Octave:invalid-fun-call" print_usage (); case "interval:NaI" ## The bare inverval:NaI error can only occur, if the interval ## literal [NaI] is observed. In that particular case, we must not ## issue a warning. case {"interval:PossiblyUndefined", ... "interval:ImplicitPromote"} ## The user has set these warnings to error, which we must respect rethrow (lasterror) otherwise warning ("interval:NaI", lasterror.message); endswitch ## NaI representation is unique. bare = infsup (); dec = _ill (); isexact = false (); end_try_catch x.dec = dec; x = class (x, "infsupdec", bare); ## Enable all mixed mode functions to use decorated variants with implicit ## conversion from bare to decorated intervals. ## ## There is bug #42735 in GNU Octave core, which makes this a little ## complicated: When [infsup] [operator] [infsupdec] syntax is used, the ## decoration from the second argument would be lost, because the bare ## implementation for the operator is evaluated. However, sufficient runtime ## checks have been placed in the overloaded class operator implementations of ## the infsup class as a workaround. ## ## The workaround is necessary, because otherwise this could lead to wrong ## results, which is catastrophic for a verified computation package. superiorto ("infsup"); endfunction %!# [NaI]s %! assert (isnai (infsupdec ("[nai]"))); # quiet [NaI] %!warning assert (isnai (infsupdec (3, 2))); %!warning assert (isnai (infsupdec ("Flugeldufel"))); %!warning assert (isnai (infsupdec ("[1, Inf]_com"))); %!warning assert (isnai (infsupdec ("[Empty]_def"))); %!test "decoration adjustments, setDec function"; %! assert (inf (infsupdec (42, inf, "com")), 42); %! assert (sup (infsupdec (42, inf, "com")), inf); %! assert (strcmp (decorationpart (infsupdec (42, inf, "com")), "dac")); %! assert (inf (infsupdec (-inf, inf, "com")), -inf); %! assert (sup (infsupdec (-inf, inf, "com")), inf); %! assert (strcmp (decorationpart (infsupdec (-inf, inf, "com")), "dac")); %! assert (inf (infsupdec (inf, -inf, "def")), inf); %! assert (sup (infsupdec (inf, -inf, "def")), -inf); %! assert (strcmp (decorationpart (infsupdec (inf, -inf, "def")), "trv")); %!test "overflow"; %! assert (inf (infsupdec ("[1, 1e999]_com")), 1); %! assert (sup (infsupdec ("[1, 1e999]_com")), inf); %! assert (strcmp (decorationpart (infsupdec ("[1, 1e999]_com")), "dac")); %!test "decorated interval literal"; %! assert (inf (infsupdec ("[2, 3]_def")), 2); %! assert (sup (infsupdec ("[2, 3]_def")), 3); %! assert (strcmp (decorationpart (infsupdec ("[2, 3]_def")), "def")); %! assert (inf (infsupdec ("trv")), inf); %! assert (sup (infsupdec ("trv")), -inf); %! assert (strcmp (decorationpart (infsupdec ("trv")), "trv")); %!test "automatic decoration"; %! assert (inf (infsupdec ("[2, 3]")), 2); %! assert (sup (infsupdec ("[2, 3]")), 3); %! assert (strcmp (decorationpart (infsupdec ("[2, 3]")), "com")); %! assert (inf (infsupdec ("[Empty]")), inf); %! assert (sup (infsupdec ("[Empty]")), -inf); %! assert (strcmp (decorationpart (infsupdec ("[Empty]")), "trv")); %! assert (inf (infsupdec ("[Entire]")), -inf); %! assert (sup (infsupdec ("[Entire]")), inf); %! assert (strcmp (decorationpart (infsupdec ("[Entire]")), "dac")); %! assert (inf (infsupdec ("")), -inf); %! assert (sup (infsupdec ("")), +inf); %! assert (strcmp (decorationpart (infsupdec ("")), "dac")); %!test "separate decoration information"; %! assert (inf (infsupdec ("[2, 3]", "def")), 2); %! assert (sup (infsupdec ("[2, 3]", "def")), 3); %! assert (strcmp (decorationpart (infsupdec ("[2, 3]", "def")), "def")); %!test "cell array with decorated intervals"; %! assert (inf (infsupdec ({"[2, 3]_def", "[4, 5]_dac"})), [2, 4]); %! assert (sup (infsupdec ({"[2, 3]_def", "[4, 5]_dac"})), [3, 5]); %! assert (all (strcmp (decorationpart (infsupdec ({"[2, 3]_def", "[4, 5]_dac"})), {"def", "dac"}))); %!test "cell array with separate decoration cell array"; %! assert (inf (infsupdec ({"[2, 3]", "[4, 5]"}, {"def", "dac"})), [2, 4]); %! assert (sup (infsupdec ({"[2, 3]", "[4, 5]"}, {"def", "dac"})), [3, 5]); %! assert (all (strcmp (decorationpart (infsupdec ({"[2, 3]", "[4, 5]"}, {"def", "dac"})), {"def", "dac"}))); %!test "cell array with separate decoration vector"; %! assert (inf (infsupdec ({"[2, 3]"; "[4, 5]"}, ["def"; "dac"])), [2; 4]); %! assert (sup (infsupdec ({"[2, 3]"; "[4, 5]"}, ["def"; "dac"])), [3; 5]); %! assert (all (strcmp (decorationpart (infsupdec ({"[2, 3]"; "[4, 5]"}, ["def"; "dac"])), {"def"; "dac"}))); %!test "cell array with broadcasting decoration"; %! assert (inf (infsupdec ({"[2, 3]", "[4, 5]"}, "def")), [2, 4]); %! assert (sup (infsupdec ({"[2, 3]", "[4, 5]"}, "def")), [3, 5]); %! assert (all (strcmp (decorationpart (infsupdec ({"[2, 3]", "[4, 5]"}, "def")), {"def", "def"}))); %!test "separate boundaries with decoration"; %! assert (inf (infsupdec (2, 3, "def")), 2); %! assert (sup (infsupdec (2, 3, "def")), 3); %! assert (strcmp (decorationpart (infsupdec (2, 3, "def")), "def")); %!test "matrix boundaries with decoration"; %! assert (inf (infsupdec ([3, 16], {"def", "trv"})), [3, 16]); %! assert (sup (infsupdec ([3, 16], {"def", "trv"})), [3, 16]); %! assert (all ( strcmp (decorationpart (infsupdec ([3, 16], {"def", "trv"})), {"def", "trv"}))); %!test "separate matrix boundaries with broadcasting decoration"; %! assert (inf (infsupdec (magic (3), magic (3) + 1, "def")), magic (3)); %! assert (sup (infsupdec (magic (3), magic (3) + 1, "def")), magic (3) + 1); %! assert (all ( all (strcmp (decorationpart (infsupdec (magic (3), magic (3) + 1, "def")), {"def", "def", "def"; "def", "def", "def"; "def", "def", "def"})))); interval-1.4.1/inst/@infsupdec/interior.m0000644000000000000000000000325212657475772016565 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} interior (@var{A}, @var{B}) ## ## Evaluate interior comparison on intervals. ## ## True, if all numbers from @var{A} are also contained in @var{B}, but are no ## boundaries of @var{B}. False, if @var{A} contains a number which is not a ## member in @var{B} or which is a boundary of @var{B}. ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## @seealso{@@infsupdec/eq, @@infsupdec/subset, @@infsupdec/disjoint} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = interior (a, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (a, "infsupdec"))) a = infsupdec (a); endif if (not (isa (b, "infsupdec"))) b = infsupdec (b); endif if (isnai (a) || isnai (b)) result = false (); else result = interior (intervalpart (a), intervalpart (b)); endif endfunction %!assert (interior (infsupdec (1, 2), infsupdec (0, 3))); interval-1.4.1/inst/@infsupdec/intersect.m0000644000000000000000000000506612657475772016737 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} intersect (@var{A}) ## @defmethodx {@@infsupdec} intersect (@var{A}, @var{B}) ## @defmethodx {@@infsupdec} intersect (@var{A}, [], @var{DIM}) ## ## Intersect intervals. ## ## With two arguments the intersection is built pair-wise. Otherwise the ## intersection is computed for all interval members along dimension @var{DIM}, ## which defaults to the first non-singleton dimension. ## ## Accuracy: The result is a tight enclosure. ## ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## The function is a set operation and the result carries the @code{trv} ## decoration at best. ## ## @example ## @group ## x = infsupdec (1, 3); ## y = infsupdec (2, 4); ## intersect (x, y) ## @result{} ans = [2, 3]_trv ## @end group ## @end example ## @seealso{@@infsupdec/union, @@infsupdec/setdiff, @@infsupdec/setxor} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = intersect (a, b, dim) if (not (isa (a, "infsupdec"))) a = infsupdec (a); endif if (isnai (a)) result = a; return endif switch (nargin) case 1 bare = intersect (intervalpart (a)); case 2 if (not (isa (b, "infsupdec"))) b = infsupdec (b); endif if (isnai (b)) result = b; return endif bare = intersect (intervalpart (a), intervalpart (b)); case 3 if (not (builtin ("isempty", b))) warning ("intersect: second argument is ignored"); endif bare = intersect (intervalpart (a), [], dim); otherwise print_usage (); return endswitch ## intersection must not retain any useful decoration result = infsupdec (bare, "trv"); endfunction %!test "from the documentation string"; %! assert (isequal (intersect (infsupdec (1, 3), infsupdec (2, 4)), infsupdec (2, 3, "trv"))); interval-1.4.1/inst/@infsupdec/intervalpart.m0000644000000000000000000000250612657475772017446 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsupdec} {@var{S} =} intervalpart (@var{X}) ## ## Return the bare interval for the decorated interval @var{X}. ## ## @seealso{@@infsupdec/decorationpart} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-12 function bare = intervalpart (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) error ("interval:IntvlPartOfNaI", "intervalpart: NaI has no interval part") endif ## This also works for the empty interval bare = infsup (inf (x), sup (x)); endfunction %!assert (intervalpart (infsupdec (2, 3)) == infsup (2, 3)); interval-1.4.1/inst/@infsupdec/intervaltotext.m0000644000000000000000000000476212657475772020035 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsupdec} {@var{S} =} intervaltotext (@var{X}) ## @deftypemethodx {@@infsupdec} {@var{S} =} intervaltotext (@var{X}, @var{FORMAT}) ## ## Build an approximate representation of the interval @var{X}. ## ## Output @var{S} is a simple string for scalar intervals, and a cell array of ## strings for interval matrices. ## ## The interval boundaries are stored in binary floating point format and are ## converted to decimal or hexadecimal format with possible precision loss. If ## output is not exact, the boundaries are rounded accordingly (e. g. the upper ## boundary is rounded towards infinite for output representation). ## ## The exact decimal format may produce a lot of digits. ## ## Possible values for @var{FORMAT} are: @code{decimal} (default), ## @code{exact decimal}, @code{exact hexadecimal}, @code{auto} ## ## Accuracy: For all intervals @var{X} is an accurate subset of ## @code{infsupdec (intervaltotext (@var{X}))}. ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-12 function [s, isexact] = intervaltotext (x, format) if (nargin > 2) print_usage (); return endif if (nargin < 2) format = "decimal"; endif if (isnai (x)) s = "[NaI]"; isexact = true (); return endif [s, isexact] = intervaltotext (intervalpart (x), format); s = strcat (s, {"_"}, decorationpart (x)); if (isscalar (s)) s = s {1}; endif endfunction %!assert (intervaltotext (infsupdec (1 + eps), "exact decimal"), "[1.0000000000000002220446049250313080847263336181640625]_com"); %!assert (intervaltotext (infsupdec (1 + eps), "exact hexadecimal"), "[0X1.0000000000001P+0]_com"); %!assert (intervaltotext (infsupdec (1 + eps)), "[1.0000000000000002, 1.000000000000001]_com"); %!assert (intervaltotext (infsupdec (1)), "[1]_com"); interval-1.4.1/inst/@infsupdec/isempty.m0000644000000000000000000000265612657475772016433 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} isempty (@var{X}) ## ## Check if the interval represents the empty set. ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## Warning: This function is not compatible with the builtin @code{isempty} ## function. ## ## @seealso{@@infsupdec/eq, @@infsupdec/isentire, @@infsupdec/issingleton} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = isempty (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = false (); else result = isempty (intervalpart (x)); endif endfunction %!assert (isempty (infsupdec (inf, -inf))); %!assert (not (isempty (infsupdec (1, 2)))); interval-1.4.1/inst/@infsupdec/isnai.m0000644000000000000000000000253412657475772016037 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} isnai (@var{X}) ## ## Check if the interval is the result of a failed interval construction. ## ## @seealso{@@infsupdec/eq, @@infsupdec/isentire, @@infsupdec/issingleton, @@infsupdec/isempty} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = isnai (interval) if (nargin ~= 1) print_usage (); return endif ## NaI is internally stored as a scalar empty interval with ill decoration. result = isscalar (interval.dec) && interval.dec == _ill (); endfunction %!assert (isnai (infsupdec ("[nai]"))); %!assert (not (isnai (infsupdec (2, 3)))); interval-1.4.1/inst/@infsupdec/le.m0000644000000000000000000000334512657475772015335 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsupdec} le (@var{A}, @var{B}) ## @defopx Operator {@@infsupdec} {@var{A} <= @var{B}} ## ## Compare intervals @var{A} and @var{B} for weakly less. ## ## True, if all numbers from @var{A} are weakly less than any number in ## @var{B}. False, if @var{A} contains a number which is strictly greater than ## all numbers in @var{B}. ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## @seealso{@@infsupdec/eq, @@infsupdec/lt, @@infsupdec/ge, @@infsupdec/subset, @@infsupdec/interior, @@infsupdec/disjoint} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = le (a, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (a, "infsupdec"))) a = infsupdec (a); endif if (not (isa (b, "infsupdec"))) b = infsupdec (b); endif if (isnai (a) || isnai (b)) result = false (); else result = le (intervalpart (a), intervalpart (b)); endif endfunction %!assert (le (infsupdec (1, 3), infsupdec (3))); interval-1.4.1/inst/@infsupdec/linspace.m0000644000000000000000000000445112657475772016532 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} linspace (@var{BASE}, @var{LIMIT}) ## @defmethodx {@@infsupdec} linspace (@var{BASE}, @var{LIMIT}, @var{N}) ## ## Return a row vector of @var{N} linearly spaced members between @var{BASE} ## and @var{LIMIT}. ## ## If @var{BASE} is greater than @var{LIMIT}, members are returned in ## decreasing order. The default value for @var{N} is 100. ## ## If either @var{BASE} or @var{LIMIT} is not a scalar, the result is a matrix. ## ## Accuracy: The result is an accurate enclosure. ## ## @example ## @group ## transpose (linspace (infsupdec (0), infsupdec (10), 4)) ## @result{} ans ⊂ 4×1 interval vector ## ## [0]_com ## [3.3333, 3.3334]_com ## [6.6666, 6.6667]_com ## [10]_com ## @end group ## @end example ## @seealso{linspace} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-07-19 function result = linspace (base, limit, n) if (nargin < 2 || nargin > 3) print_usage (); return endif if (not (isa (base, "infsupdec"))) base = infsupdec (base); endif if (not (isa (limit, "infsupdec"))) limit = infsupdec (limit); endif if (nargin < 3) n = 100; endif if (isnai (base)) result = base; return endif if (isnai (limit)) result = limit; return endif result = newdec (linspace (intervalpart (base), intervalpart (limit), n)); ## linspace is defined and continuous everywhere result.dec = min (result.dec, min (base.dec, limit.dec)); endfunction %!xtest assert (isequal (linspace (infsupdec (0), infsupdec (10), 9), infsupdec (linspace (0, 10, 9)))); interval-1.4.1/inst/@infsupdec/log.m0000644000000000000000000000324212657475772015512 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} log (@var{X}) ## ## Compute the natural logarithm. ## ## The function is only defined where @var{X} is positive. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## log (infsupdec (2)) ## @result{} ans ⊂ [0.69314, 0.69315]_com ## @end group ## @end example ## @seealso{@@infsupdec/exp, @@infsupdec/log2, @@infsupdec/log10} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = log (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (log (intervalpart (x))); result.dec = min (result.dec, x.dec); ## log is continuous everywhere, but defined for x > 0 only result.dec (not (interior (x, infsupdec (0, inf)))) = _trv (); endfunction %!test "from the documentation string"; %! assert (isequal (log (infsupdec (2)), infsupdec ("[0x1.62E42FEFA39EFp-1, 0x1.62E42FEFA39Fp-1]"))); interval-1.4.1/inst/@infsupdec/log10.m0000644000000000000000000000327112657475772015655 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} log10 (@var{X}) ## ## Compute the decimal (base-10) logarithm. ## ## The function is only defined where @var{X} is positive. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## log10 (infsupdec (2)) ## @result{} ans ⊂ [0.30102, 0.30103]_com ## @end group ## @end example ## @seealso{@@infsupdec/pow10, @@infsupdec/log, @@infsupdec/log2} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = log10 (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (log10 (intervalpart (x))); result.dec = min (result.dec, x.dec); ## log10 is continuous everywhere, but defined for x > 0 only result.dec (not (interior (x, infsupdec (0, inf)))) = _trv (); endfunction %!test "from the documentation string"; %! assert (isequal (log10 (infsupdec (2)), infsupdec ("[0x1.34413509F79FEp-2, 0x1.34413509F79FFp-2]"))); interval-1.4.1/inst/@infsupdec/log1p.m0000644000000000000000000000330612657475772015754 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} log1p (@var{X}) ## ## Compute @code{log (1 + @var{X})} accurately in the neighborhood of zero. ## ## The function is only defined where @var{X} is greater than -1. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## log1p (infsupdec (eps)) ## @result{} ans ⊂ [2.2204e-16, 2.2205e-16]_com ## @end group ## @end example ## @seealso{@@infsup/exp, @@infsup/log} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-20 function result = log1p (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (log1p (intervalpart (x))); result.dec = min (result.dec, x.dec); ## log1p is continuous everywhere, but defined for x > -1 only result.dec (not (interior (x, infsupdec (-1, inf)))) = _trv (); endfunction %!test "from the documentation string"; %! assert (isequal (log1p (infsupdec (eps)), infsupdec ("[0x1.FFFFFFFFFFFFFp-53, 0x1p-52]"))); interval-1.4.1/inst/@infsupdec/log2.m0000644000000000000000000000316312657475772015576 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} log2 (@var{X}) ## ## Compute the binary (base-2) logarithm. ## ## The function is only defined where @var{X} is positive. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## log2 (infsupdec (2)) ## @result{} ans = [1]_com ## @end group ## @end example ## @seealso{@@infsupdec/pow2, @@infsupdec/log, @@infsupdec/log10} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-04 function result = log2 (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (log2 (intervalpart (x))); result.dec = min (result.dec, x.dec); ## log2 is continuous everywhere, but defined for x > 0 only result.dec (not (interior (x, infsupdec (0, inf)))) = _trv (); endfunction %!test "from the documentation string"; %! assert (isequal (log2 (infsupdec (2)), infsupdec (1))); interval-1.4.1/inst/@infsupdec/lt.m0000644000000000000000000000351512657475772015353 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsupdec} lt (@var{A}, @var{B}) ## @defopx Operator {@@infsupdec} {@var{A} < @var{B}} ## ## Compare intervals @var{A} and @var{B} for strictly less. ## ## True, if all numbers from @var{A} are strict less than at least one number ## in @var{B}. False, if @var{A} contains a number which is greater than all ## numbers in @var{B} or is equal to the greatest number of @var{B}. ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## @seealso{@@infsupdec/eq, @@infsupdec/le, @@infsupdec/gt, @@infsupdec/subset, @@infsupdec/interior, @@infsupdec/disjoint} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = lt (a, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (a, "infsupdec"))) a = infsupdec (a); endif if (not (isa (b, "infsupdec"))) b = infsupdec (b); endif if (isnai (a) || isnai (b)) result = false (); else result = lt (intervalpart (a), intervalpart (b)); endif endfunction %!assert (not (lt (infsupdec (1, 3), infsupdec (3)))); %!assert (lt (infsupdec (1, 3), infsupdec (3.1))); interval-1.4.1/inst/@infsupdec/lu.m0000644000000000000000000000445012657475772015353 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsupdec} {[@var{L}, @var{U}] = } lu (@var{A}) ## @deftypemethodx {@@infsupdec} {[@var{L}, @var{U}, @var{P}] = } lu (@var{A}) ## ## Compute the LU decomposition of @var{A}. ## ## @var{A} will be a subset of @var{L} * @var{U}. ## ## The result is returned in a permuted form, according to the optional return ## value @var{P}. ## ## Accuracy: The result is a valid enclosure. ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-18 function [L, U, P] = lu (x) if (nargin ~= 1) print_usage (); return endif P = eye (size (x.dec)); if (isnai (x)) L = U = x; return endif if (nargout >= 3) [L, U, P] = lu (intervalpart (x)); else [L, U] = lu (intervalpart (x)); endif ## Reverse operations should not carry decoration L = infsupdec (L, "trv"); U = infsupdec (U, "trv"); endfunction %!xtest %! [l, u] = lu (infsupdec (magic (3))); %! assert (isequal (l, infsupdec ({1, 0, 0; .375, 1, 0; .5, "68/37", 1}, "trv")));, ... %! assert (subset (u, infsupdec ({8, 1, 6; 0, 4.625, 4.75; 0, 0, "-0x1.3759F2298375Bp3"}, ... %! {8, 1, 6; 0, 4.625, 4.75; 0, 0, "-0x1.3759F22983759p3"}))); %! A = magic (3); %! A ([1, 5, 9]) = 0; %! [l, u, p] = lu (infsupdec (A)); %! assert (p, [0, 0, 1; 1, 0, 0; 0, 1, 0]); %! assert (isequal (l, infsupdec ({1, 0, 0; "4/3", 1, 0; 0, "1/9", 1}, "trv"))); %! assert (subset (u, infsupdec ({3, 0, 7; 0, 9, "-0x1.2AAAAAAAAAAACp3"; 0, 0, "0x1.C25ED097B425Ep2"}, ... %! {3, 0, 7; 0, 9, "-0x1.2AAAAAAAAAAAAp3"; 0, 0, "0x1.C25ED097B426p2"}))); interval-1.4.1/inst/@infsupdec/max.m0000644000000000000000000000540312657475772015517 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} max (@var{X}) ## @defmethodx {@@infsupdec} max (@var{X}, @var{Y}) ## @defmethodx {@@infsupdec} max (@var{X}, [], @var{DIM}) ## ## Compute the maximum value chosen from intervals. ## ## This function does not return the greatest element of the interval (see ## @code{sup}), but returns an interval enclosure of the function: ## @display ## max (@var{x}, @var{y}) = ( (x + y) + abs (x - y) ) / 2 ## @end display ## ## With two arguments the function is applied element-wise. Otherwise the ## maximum is computed for all interval members along dimension @var{DIM}, ## which defaults to the first non-singleton dimension. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## x = infsupdec (2, 3); ## y = infsupdec (1, 2); ## max (x, y) ## @result{} ans = [2, 3]_com ## @end group ## @end example ## @seealso{@@infsupdec/min} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = max (x, y, dim) if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (isnai (x)) result = x; return endif switch (nargin) case 1 bare = max (intervalpart (x)); case 2 if (not (isa (y, "infsupdec"))) y = infsupdec (y); endif if (isnai (y)) result = y; return endif bare = max (intervalpart (x), intervalpart (y)); case 3 if (not (builtin ("isempty", y))) warning ("max: second argument is ignored"); endif bare = max (intervalpart (x), [], dim); otherwise print_usage (); return endswitch result = newdec (bare); ## max is defined and continuous everywhere switch (nargin) case 1 result.dec = min (result.dec, min (x.dec)); case 2 result.dec = min (result.dec, min (x.dec, y.dec)); case 3 result.dec = min (result.dec, min (x.dec, [], dim)); endswitch endfunction %!test "from the documentation string"; %! assert (isequal (max (infsupdec (2, 3), infsupdec (1, 2)), infsupdec (2, 3))); interval-1.4.1/inst/@infsupdec/meshgrid.m0000644000000000000000000000673212657475772016542 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsupdec} {[@var{XX}, @var{YY}] =} meshgrid (@var{X}, @var{Y}) ## @deftypemethodx {@@infsupdec} {[@var{XX}, @var{YY}, @var{ZZ}] =} meshgrid (@var{X}, @var{Y}, @var{Z}) ## @deftypemethodx {@@infsupdec} {[@var{XX}, @var{YY}] =} meshgrid (@var{X}) ## @deftypemethodx {@@infsupdec} {[@var{XX}, @var{YY}, @var{ZZ}] =} meshgrid (@var{X}) ## ## Given vectors of @var{X} and @var{Y} coordinates, return matrices @var{XX} ## and @var{YY} corresponding to a full 2-D grid. ## ## If the optional @var{Z} input is given, or @var{ZZ} is requested, then the ## output will be a full 3-D grid. ## ## Please note that this function does not produce multidimensional arrays in ## the case of 3-D grids like the built-in @code{meshgrid} function. This is ## because interval matrices currently only support two dimensions. The 3-D ## grid is reshaped to fit into two dimensions accordingly. ## ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-07-19 function [xx, yy, zz] = meshgrid (x, y, z) if (nargin > 3) print_usage (); return endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (nargin >= 2 && not (isa (y, "infsupdec"))) y = infsupdec (y); endif if (nargin >= 3 && not (isa (z, "infsupdec"))) z = infsupdec (z); endif if (isnai (x)) xx = yy = zz = x; return endif if (nargin >= 2 && isnai (y)) xx = yy = zz = y; return endif if (nargin >= 3 && isnai (z)) xx = yy = zz = z; return endif switch (nargin) case 1 if (nargout >= 3) [xx, yy, zz] = meshgrid (intervalpart (x)); [dxx, dyy, dzz] = meshgrid (x.dec); else [xx, yy] = meshgrid (intervalpart (x)); [dxx, dyy] = meshgrid (x.dec); endif case 2 if (nargout >= 3) [xx, yy, zz] = meshgrid (intervalpart (x), intervalpart (y)); [dxx, dyy, dzz] = meshgrid (x.dec, y.dec); else [xx, yy] = meshgrid (intervalpart (x), intervalpart (y)); [dxx, dyy] = meshgrid (x.dec, y.dec); endif case 3 [xx, yy, zz] = meshgrid (intervalpart (x), ... intervalpart (y), ... intervalpart (z)); [dxx, dyy, dzz] = meshgrid (x.dec, y.dec, z.dec); endswitch if (nargout >= 3 || nargin >= 3) ## Reshape 3 dimensions into 2 dimensions f = @(A) reshape (A, [size(A,1), prod(size (A)(2 : end))]); dxx = f (dxx); dyy = f (dyy); dzz = f (dzz); endif xx = newdec (xx); xx.dec = min (xx.dec, dxx); yy = newdec (yy); yy.dec = min (yy.dec, dyy); if (nargout >= 3) zz = newdec (zz); zz.dec = min (zz.dec, dzz); endif endfunction %!xtest assert (isequal (meshgrid (infsupdec (0 : 3)), infsupdec (meshgrid (0 : 3)))); interval-1.4.1/inst/@infsupdec/min.m0000644000000000000000000000540012657475772015512 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} min (@var{X}) ## @defmethodx {@@infsupdec} min (@var{X}, @var{Y}) ## @defmethodx {@@infsupdec} min (@var{X}, [], @var{DIM}) ## ## Compute the minimum value chosen from intervals. ## ## This function does not return the least element of the interval (see ## @code{inf}), but returns an interval enclosure of the function: ## @display ## min (@var{x}, @var{y}) = ( (x + y) - abs (x - y) ) / 2 ## @end display ## ## With two arguments the function is applied element-wise. Otherwise the ## minimum is computed for all interval members along dimension @var{DIM}, ## which defaults to the first non-singleton dimension. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## x = infsupdec (2, 3); ## y = infsupdec (1, 2); ## min (x, y) ## @result{} ans = [1, 2]_com ## @end group ## @end example ## @seealso{@@infsupdec/max} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = min (x, y, dim) if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (isnai (x)) result = x; return endif switch (nargin) case 1 bare = min (intervalpart (x)); case 2 if (not (isa (y, "infsupdec"))) y = infsupdec (y); endif if (isnai (y)) result = y; return endif bare = min (intervalpart (x), intervalpart (y)); case 3 if (not (builtin ("isempty", y))) warning ("min: second argument is ignored"); endif bare = min (intervalpart (x), [], dim); otherwise print_usage (); return endswitch result = newdec (bare); ## min is defined and continuous everywhere switch (nargin) case 1 result.dec = min (result.dec, min (x.dec)); case 2 result.dec = min (result.dec, min (x.dec, y.dec)); case 3 result.dec = min (result.dec, min (x.dec, [], dim)); endswitch endfunction %!test "from the documentation string"; %! assert (isequal (min (infsupdec (2, 3), infsupdec (1, 2)), infsupdec (1, 2))); interval-1.4.1/inst/@infsupdec/mince.m0000644000000000000000000000357412657475772016034 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} mince (@var{X}) ## @defmethodx {@@infsupdec} mince (@var{X}, @var{N}) ## ## Mince interval @var{X} into a row vector of @var{N} sub-intervals of equal ## size. ## ## The sub-intervals are returned in ascending order and may overlap due to ## round-off errors. ## ## If @var{X} is not a scalar, the result is a matrix. The default value for ## @var{N} is 100. ## ## Accuracy: The result is an accurate enclosure. ## ## @example ## @group ## mince (infsupdec (0, 10), 4) ## @result{} ans = 1×4 interval vector ## ## [0, 2.5]_trv [2.5, 5]_trv [5, 7.5]_trv [7.5, 10]_trv ## @end group ## @end example ## @seealso{@@infsupdec/linspace, @@infsupdec/bisect} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-07-19 function result = mince (x, n) if (nargin > 2) print_usage (); return endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (nargin < 2) n = 100; endif if (isnai (x)) result = x; return endif result = infsupdec (mince (intervalpart (x), n), "trv"); endfunction %!xtest assert (isequal (mince (infsupdec (0, 10), 10), infsupdec (0 : 9, 1 : 10, "trv"))); interval-1.4.1/inst/@infsupdec/minus.m0000644000000000000000000000344712657475772016073 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsupdec} minus (@var{X}, @var{Y}) ## @defopx Operator {@@infsupdec} {@var{X} - @var{Y}} ## ## Subtract all numbers of interval @var{Y} from all numbers of @var{X}. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## x = infsupdec (2, 3); ## y = infsupdec (1, 2); ## x - y ## @result{} ans = [0, 2]_com ## @end group ## @end example ## @seealso{@@infsupdec/plus} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = minus (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (not (isa (y, "infsupdec"))) y = infsupdec (y); endif if (isnai (x)) result = x; return endif if (isnai (y)) result = y; return endif result = newdec (minus (intervalpart (x), intervalpart (y))); ## minus is defined and continuous everywhere result.dec = min (result.dec, min (x.dec, y.dec)); endfunction %!test "from the documentation string"; %! assert (isequal (infsupdec (2, 3) - infsupdec (1, 2), infsupdec (0, 2))); interval-1.4.1/inst/@infsupdec/mldivide.m0000644000000000000000000000401512657475772016525 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsupdec} mldivide (@var{X}, @var{Y}) ## @defopx Operator {@@infsupdec} {@var{X} \ @var{Y}} ## ## Return the interval matrix left division of @var{X} and @var{Y}. ## ## Accuracy: The result is a valid enclosure. ## ## @example ## @group ## infsupdec ([1, 0; 0, 2]) \ [2, 0; 0, 4] ## @result{} ans = 2×2 interval matrix ## [2]_trv [0]_trv ## [0]_trv [2]_trv ## @end group ## @end example ## @seealso{@@infsupdec/mtimes} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-01-31 function result = mldivide (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (not (isa (y, "infsupdec"))) y = infsupdec (y); endif if (isnai (x)) result = x; return endif if (isnai (y)) result = y; return endif ## Reverse operations should not carry decoration result = infsupdec (mldivide (intervalpart (x), intervalpart (y)), "trv"); endfunction %!xtest "unique solution"; %! assert (isequal (infsupdec ([1, 0; 0, 2]) \ [2, 0; 0, 4], infsupdec ([2, 0; 0 2], "trv"))); %!test "no solution"; %! assert (all (isempty (infsupdec ([1, 0; 2, 0]) \ [3; 0]))); %!xtest "many solutions"; %! assert (isequal (infsupdec ([1, 0; 2, 0]) \ [4; 8], infsupdec ([4; -inf], [4; inf], "trv"))); interval-1.4.1/inst/@infsupdec/mpower.m0000644000000000000000000000505212657475772016243 0ustar 00000000000000## Copyright 2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsup} mpower (@var{X}, @var{Y}) ## @defopx Operator {@@infsup} {@var{X} ^ @var{Y}} ## ## Return the matrix power operation of @var{X} raised to the @var{Y} power. ## ## If @var{X} is a scalar, this function and @code{power} are equivalent. ## Otherwise, @var{X} must be a square matrix and @var{Y} must be a single ## integer. ## ## Warning: This function is not defined by IEEE Std 1788-2015. ## ## Accuracy: The result is a valid enclosure. The result is tightest for ## @var{Y} in @{0, 1, 2@}. ## ## @example ## @group ## infsupdec (magic (3)) ^ 2 ## @result{} ans = 3×3 interval matrix ## [91]_com [67]_com [67]_com ## [67]_com [91]_com [67]_com ## [67]_com [67]_com [91]_com ## @end group ## @end example ## @seealso{@@infsupdec/pow, @@infsupdec/pown, @@infsupdec/pow2, @@infsupdec/pow10, @@infsupdec/exp} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2016-01-24 function result = mpower (x, y) if (nargin != 2) print_usage (); return endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (isscalar (x.dec)) ## Short-circuit for scalars result = power (x, y); return endif if (not (isreal (y)) || fix (y) ~= y) error ("interval:InvalidOperand", ... "mpower: only integral powers can be computed"); endif result = newdec (mpower (intervalpart (x), y)); if (y < 0) result.dec(:) = _trv (); elseif (y < 2) result.dec = x.dec; elseif (y == 2) warning ('off', 'Octave:broadcast', 'local'); result.dec = min (result.dec, min (min (x.dec, [], 1), ... min (x.dec, [], 2))); elseif (y > 2) result.dec = min (result.dec, min (min (x.dec))); endif endfunction %!xtest "from the documentation string"; %! assert (isequal (infsupdec (magic (3)) ^ 2, infsupdec (magic (3) ^ 2))); interval-1.4.1/inst/@infsupdec/mtimes.m0000644000000000000000000000571412657475772016235 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsupdec} mtimes (@var{X}, @var{Y}) ## @defopx Method {@@infsupdec} mtimes (@var{X}, @var{Y}, @var{ACCURACY}) ## @defopx Operator {@@infsupdec} {@var{X} * @var{Y}} ## ## Compute the interval matrix multiplication. ## ## The @var{ACCURACY} can be set to @code{tight} (default) or @code{valid}. ## With @code{valid} accuracy an algorithm for fast matrix multiplication based ## on BLAS routines is used. The latter is published by ## Siegried M. Rump (2012), “Fast interval matrix multiplication,” ## Numerical Algorithms 61(1), 1-34. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## x = infsupdec ([1, 2; 7, 15], [2, 2; 7.5, 15]); ## y = infsupdec ([3, 3; 0, 1], [3, 3.25; 0, 2]); ## x * y ## @result{} ans = 2×2 interval matrix ## [3, 6]_com [5, 10.5]_com ## [21, 22.5]_com [36, 54.375]_com ## @end group ## @end example ## @seealso{@@infsupdec/mrdivide} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-21 function result = mtimes (x, y, accuracy) if (nargin < 2 || nargin > 3 || (nargin == 3 && not (ischar (accuracy)))) print_usage (); return endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (not (isa (y, "infsupdec"))) y = infsupdec (y); endif ## null matrix input -> null matrix output if (isempty (x.dec) || isempty (y.dec)) result = infsupdec (zeros (0)); return endif if (isscalar (x) || isscalar (y)) result = times (x, y); return endif if (nargin == 2) result = newdec (mtimes (intervalpart (x), intervalpart (y))); else result = newdec (mtimes (intervalpart (x), intervalpart (y), accuracy)); endif dec_x = min (x.dec, [], 2); dec_y = min (y.dec, [], 1); warning ('off', 'Octave:broadcast', 'local'); result.dec = min (result.dec, min (dec_x, dec_y)); endfunction %!xtest assert (isequal (infsupdec ([1, 2; 7, 15], [2, 2; 7.5, 15], {"com", "def"; "dac", "com"}) * infsupdec ([3, 3; 0, 1], [3, 3.25; 0, 2]), infsupdec ([3, 5; 21, 36], [6, 10.5; 22.5, 54.375], {"def", "def"; "dac", "dac"}))); %!xtest "from the documentation string"; %! assert (isequal (infsupdec ([1, 2; 7, 15], [2, 2; 7.5, 15]) * infsupdec ([3, 3; 0, 1], [3, 3.25; 0, 2]), infsupdec ([3, 5; 21, 36], [6, 10.5; 22.5, 54.375]))); interval-1.4.1/inst/@infsupdec/mulrev.m0000644000000000000000000000765112657475772016253 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsupdec} {@var{X} =} mulrev (@var{B}, @var{C}, @var{X}) ## @deftypemethodx {@@infsupdec} {@var{X} =} mulrev (@var{B}, @var{C}) ## @deftypemethodx {@@infsupdec} {[@var{U}, @var{V}] =} mulrev (@var{B}, @var{C}) ## @deftypemethodx {@@infsupdec} {[@var{U}, @var{V}] =} mulrev (@var{B}, @var{C}, @var{X}) ## ## Compute the reverse multiplication function or the two-output division. ## ## That is, an enclosure of all @code{x ∈ @var{X}} where ## @code{x .* b ∈ @var{C}} for any @code{b ∈ @var{B}}. ## ## This function is similar to interval division @code{@var{C} ./ @var{B}}. ## However, it treats the case 0/0 as “any real number” instead of “undefined”. ## ## Interval division, considered as a set, can have zero, one or two disjoint ## connected components as a result. If called with two output parameters, ## this function returns the components separately. @var{U} contains the ## negative or unique component, whereas @var{V} contains the positive ## component in cases with two components. ## ## Accuracy: The result is a tight enclosure. ## ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## No one way of decorating this operations gives useful information in all ## contexts. Therefore, the result will carry a @code{trv} decoration at best. ## ## @example ## @group ## c = infsupdec (1); ## b = infsupdec (-inf, inf); ## [u, v] = mulrev (b, c) ## @result{} ## u = [-Inf, 0]_trv ## v = [0, Inf]_trv ## @end group ## @end example ## @seealso{@@infsupdec/times} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-19 function [u, v] = mulrev (b, c, x) if (nargin < 2 || nargin > 3) print_usage (); return endif if (nargin < 3) x = infsupdec (-inf, inf); endif if (not (isa (b, "infsupdec"))) b = infsupdec (b); endif if (not (isa (c, "infsupdec"))) c = infsupdec (c); endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (isnai (x)) u = v = x; return endif if (isnai (b)) u = v = b; return endif if (isnai (c)) u = v = c; return endif if (nargout < 2) u = mulrev (intervalpart (b), intervalpart (c), intervalpart (x)); u = infsupdec (u, "trv"); else [u, v] = mulrev (intervalpart (b), intervalpart (c), intervalpart (x)); u = newdec (u); u.dec = min (u.dec, min (b.dec, c.dec)); u.dec (isempty (b) | isempty (c) | ismember (0, b)) = _trv (); v = infsupdec (v, "trv"); endif endfunction %!test "IEEE Std 1788-2015 mulRevToPair examples"; %! [u, v] = mulrev (infsupdec (0), infsupdec (1, 2)); %! assert (isempty (u) & isempty (v)); %! [u, v] = mulrev (infsupdec (0), infsupdec (0, 1)); %! assert (isentire (u) & isempty (v)); %! [u, v] = mulrev (infsupdec (1), infsupdec (1, 2)); %! assert (isequal (u, infsupdec (1, 2)) & isempty (v)); %! [u, v] = mulrev (infsupdec (1, inf), infsupdec (1)); %! assert (isequal (u, infsupdec (0, 1, "dac")) & isempty (v)); %! [u, v] = mulrev (infsupdec (-1, 1), infsupdec (1, 2)); %! assert (isequal (u, infsupdec (-inf, -1, "trv")) & isequal (v, infsupdec (1, inf, "trv"))); %! [u, v] = mulrev (infsupdec (-inf, inf), infsupdec (1)); %! assert (isequal (u, infsupdec (-inf, 0, "trv")) & isequal (v, infsupdec (0, inf, "trv"))); interval-1.4.1/inst/@infsupdec/nextout.m0000644000000000000000000000325612657475772016444 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} nextout (@var{X}) ## ## Increases the interval's boundaries in each direction to the next number. ## ## This is the equivalent function to IEEE 754's nextDown and nextUp. ## ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## The function is a set operation and the result carries the @code{trv} ## decoration at best. ## ## @example ## @group ## x = infsupdec (1); ## nextout (x) == infsupdec (1 - eps / 2, 1 + eps) ## @result{} ans = 1 ## @end group ## @end example ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-03 function result = nextout (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = infsupdec (nextout (intervalpart (x)), "trv"); endfunction %!test "from the documentation string"; %! x = nextout (infsupdec (1)); %! assert (inf (x), 1 - eps / 2); %! assert (sup (x), 1 + eps); %! assert (decorationpart (x), {"trv"}); interval-1.4.1/inst/@infsupdec/nthroot.m0000644000000000000000000000355712657475772016437 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} nthroot (@var{X}, @var{N}) ## ## Compute the real n-th root of @var{X}. ## ## Accuracy: The result is a valid enclosure. The result is a tight ## enclosure for @var{n} ≥ -2. The result also is a tight enclosure if the ## reciprocal of @var{n} can be computed exactly in double-precision. ## @seealso{@@infsupdec/pown, @@infsupdec/pownrev, @@infsupdec/realsqrt, @@infsupdec/cbrt} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-20 function result = nthroot (x, n) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (isnai (x)) result = x; return endif result = newdec (nthroot (intervalpart (x), n)); result.dec = min (result.dec, x.dec); ## nthroot is continuous everywhere, but not defined everywhere even = mod (n, 2) == 0; defined = (not (even) & (n > 0 | inf (x) > 0 | sup (x) < 0)) ... | (even & ((n > 0 & inf (x) >= 0) ... | (n < 0 & inf (x) > 0))); result.dec (not (defined)) = _trv (); endfunction %!assert (isequal (nthroot (infsupdec (25, 36), 2), infsupdec (5, 6))); interval-1.4.1/inst/@infsupdec/overlap.m0000644000000000000000000000650612657475772016407 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsupdec} {[@var{STATE}, @var{BITMASK}] =} overlap(@var{A}, @var{B}) ## ## Extensively compare the positions of intervals @var{A} and @var{B} on the ## real number line. ## ## Return the @var{STATE} as a string and the @var{BITMASK} of the state as an ## uint16 number, which represents one of the 16 possible states by taking a ## value 2^i (i = 0 … 15). ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## @table @asis ## @item @code{bothEmpty}, 2^0 ## Both intervals are empty ## @item @code{firstEmpty}, 2^1 ## Interval @var{A} is empty and @var{B} is not ## @item @code{secondEmpty}, 2^2 ## Interval @var{A} is not empty, but @var{B} is ## @item @code{before}, 2^3 ## [- - - @var{A} - - -]@ @ @ [- - - @var{B} - - -] ## @item @code{meets}, 2^4 ## [- - - @var{A} - - -][- - - @var{B} - - -] ## @*Interval @var{A}'s upper boundary equals interval @var{B}'s lower boundary ## and neither consists of a single point only. ## @item @code{overlaps}, 2^5 ## [- - - @var{A} - - - [= = =] - - - @var{B} - - -] ## @item @code{starts}, 2^6 ## [[= = = @var{A} = = =] - - - @var{B} - - -] ## @item @code{containedBy}, 2^7 ## [- - - @var{B} - - - [= = = @var{A} = = =] - - -] ## @item @code{finishes}, 2^8 ## [- - - @var{B} - - - [= = = @var{A} = = =]] ## @item @code{equals}, 2^9 ## Both intervals are equal (and not empty) ## @item @code{finishedBy}, 2^10 ## [- - - @var{A} - - - [= = = @var{B} = = =]] ## @item @code{contains}, 2^11 ## [- - - @var{A} - - - [= = = @var{B} = = =] - - -] ## @item @code{startedBy}, 2^12 ## [[= = = @var{B} = = =] - - - @var{A} - - -] ## @item @code{overlappedBy}, 2^13 ## [- - - @var{B} - - - [= = =] - - - @var{A} - - -] ## @item @code{metBy}, 2^14 ## [- - - @var{B} - - -][- - - @var{A} - - -] ## @*Interval @var{A}'s lower boundary equals interval @var{B}'s upper boundary ## and neither consists of a single point only. ## @item @code{after}, 2^15 ## [- - - @var{B} - - -]@ @ @ [- - - @var{A} - - -] ## @end table ## ## @seealso{@@infsupdec/eq, @@infsupdec/subset, @@infsupdec/interior, @@infsupdec/disjoint} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function [state, bitmask] = overlap (a, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (a, "infsupdec"))) a = infsupdec (a); endif if (not (isa (b, "infsupdec"))) b = infsupdec (b); endif if (isnai (a) || isnai (b)) error ("interval:InvalidOperand", "interval comparison with NaI") endif [state, bitmask] = overlap (intervalpart (a), intervalpart (b)); endfunction %!assert (overlap (infsupdec (1, 2), infsupdec (3, 4)), "before"); interval-1.4.1/inst/@infsupdec/plus.m0000644000000000000000000000343512657475772015720 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsupdec} plus (@var{X}, @var{Y}) ## @defopx Operator {@@infsupdec} {@var{X} + @var{Y}} ## ## Add all numbers of interval @var{X} to all numbers of @var{Y}. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## x = infsupdec (2, 3); ## y = infsupdec (1, 2); ## x + y ## @result{} ans = [3, 5]_com ## @end group ## @end example ## @seealso{@@infsupdec/minus} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = plus (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (not (isa (y, "infsupdec"))) y = infsupdec (y); endif if (isnai (x)) result = x; return endif if (isnai (y)) result = y; return endif result = newdec (plus (intervalpart (x), intervalpart (y))); ## plus is continuous and defined everywhere result.dec = min (result.dec, min (x.dec, y.dec)); endfunction %!test "from the documentation string"; %! assert (isequal (infsupdec (2, 3) + infsupdec (1, 2), infsupdec (3, 5))); interval-1.4.1/inst/@infsupdec/polyval.m0000644000000000000000000000416112657475772016420 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} polyval (@var{P}, @var{X}) ## ## Evaluate polynomial @var{P} with argument @var{X}. ## ## Horner's scheme is used to evaluate a first approximation. The result is ## improved with iterative refinement. ## ## Accuracy: The result is a tight enclosure for polynomials of degree 1 or ## less. For polynomials of higher degree the result is a valid enclosure. ## For @var{X} being no singleton interval, the algorithm suffers from the ## dependency problem. ## ## @example ## @group ## output_precision (16, 'local') ## polyval (infsupdec ([3 4 2 1]), 42) # 3x^3 + 4x^2 + 2x^1 + 1 | x = 42 ## @result{} [229405]_com ## polyval (infsupdec ([3 4 2 1]), "42?") # ... | x = 41.5 .. 42.5 ## @result{} [221393.125, 237607.875]_com ## @end group ## @end example ## @seealso{@@infsup/fzero} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-05-30 function result = polyval (p, x) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (not (isa (p, "infsupdec"))) p = infsupdec (p); endif if (isnai (p)) result = p; return endif if (isnai (x)) result = x; return endif result = newdec (polyval (intervalpart (p), intervalpart (x))); result.dec = min (result.dec, min (min (p.dec), x.dec)); endfunction %!assert (isequal (polyval (infsupdec (3, "trv"), 0), infsupdec (3, "trv"))); interval-1.4.1/inst/@infsupdec/postpad.m0000644000000000000000000000505212657475772016404 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} postpad (@var{X}, @var{L}) ## @defmethodx {@@infsupdec} postpad (@var{X}, @var{L}, @var{C}) ## @defmethodx {@@infsupdec} postpad (@var{X}, @var{L}, @var{C}, @var{DIM}) ## ## Append the scalar interval value @var{C} to the interval vector @var{X} ## until it is of length @var{L}. If @var{C} is not given, a value of 0 is ## used. ## ## If @code{length (@var{X}) > L}, elements from the end of @var{X} are removed ## until an interval vector of length @var{L} is obtained. ## ## If @var{X} is an interval matrix, elements are appended or removed from each ## row or column. ## ## If the optional argument DIM is given, operate along this dimension. ## ## @example ## @group ## postpad (infsupdec (1 : 3), 5, 42) ## @result{} ans = 1×5 interval vector ## [1]_com [2]_com [3]_com [42]_com [42]_com ## @end group ## @end example ## @seealso{@@infsupdec/reshape, @@infsup/cat, @@infsupdec/prepad, @@infsupdec/resize} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-19 function result = postpad (x, len, c, dim) if (nargin < 2 || nargin > 4) print_usage (); return endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (nargin < 3) c = infsupdec (0); elseif (not (isa (c, "infsupdec"))) c = infsupdec (c); endif if (nargin < 4) if (isvector (x.dec) && not (isscalar (x.dec))) dim = find (size (x.dec) ~= 1, 1); else dim = 1; endif endif if (isnai (x)) result = x; return endif if (isnai (c)) result = c; return endif result = newdec (postpad (intervalpart (x), len, intervalpart (c), dim)); result.dec = postpad (x.dec, len, c.dec, dim); endfunction %!xtest assert (isequal (postpad (infsupdec (1:3), 4, 4), infsupdec (1:4))); %!xtest assert (isequal (postpad (infsupdec (1:3), 2, 4), infsupdec (1:2))); interval-1.4.1/inst/@infsupdec/pow.m0000644000000000000000000000425712657475772015545 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} pow (@var{X}, @var{Y}) ## ## Compute the simple power function on intervals defined by ## @code{exp (@var{Y} * log (@var{X}))}. ## ## The function is only defined where @var{X} is positive or where @var{X} is ## zero and @var{Y} is positive. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## pow (infsupdec (5, 6), infsupdec (2, 3)) ## @result{} ans = [25, 216]_com ## @end group ## @end example ## @seealso{@@infsupdec/pown, @@infsupdec/pow2, @@infsupdec/pow10, @@infsupdec/exp, @@infsupdec/mpower} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = pow (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (not (isa (y, "infsupdec"))) y = infsupdec (y); endif if (isnai (x)) result = x; return endif if (isnai (y)) result = y; return endif result = newdec (pow (intervalpart (x), intervalpart (y))); result.dec = min (result.dec, min (x.dec, y.dec)); ## pow is continuous everywhere (where it is defined), ## but defined for x > 0 or (x = 0 and y > 0) only nonnegative = infsupdec (0, inf); domain = interior (x, nonnegative) | ... (subset (x, nonnegative) & interior (y, nonnegative)); result.dec (not (domain)) = _trv (); endfunction %!test "from the documentation string"; %! assert (isequal (pow (infsupdec (5, 6), infsupdec (2, 3)), infsupdec (25, 216))); interval-1.4.1/inst/@infsupdec/pow10.m0000644000000000000000000000301612657475772015676 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} pow10 (@var{X}) ## ## Compute @code{10^x} for all numbers in @var{X}. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## pow10 (infsupdec (5)) ## @result{} ans = [1e+05]_com ## @end group ## @end example ## @seealso{@@infsupdec/log10, @@infsupdec/pow, @@infsupdec/pow2, @@infsupdec/exp} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = pow10 (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (pow10 (intervalpart (x))); ## pow10 is defined and continuous everywhere result.dec = min (result.dec, x.dec); endfunction %!test "from the documentation string"; %! assert (isequal (pow10 (infsupdec (5)), infsupdec (100000))); interval-1.4.1/inst/@infsupdec/pow2.m0000644000000000000000000000300012657475772015610 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} pow2 (@var{X}) ## ## Compute @code{2^x} for all numbers in @var{X}. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## pow2 (infsupdec (5)) ## @result{} ans = [32]_com ## @end group ## @end example ## @seealso{@@infsupdec/log2, @@infsupdec/pow, @@infsupdec/pow10, @@infsupdec/exp} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = pow2 (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (pow2 (intervalpart (x))); ## pow2 is defined and continuous everywhere result.dec = min (result.dec, x.dec); endfunction %!test "from the documentation string"; %! assert (isequal (pow2 (infsupdec (5)), infsupdec (32))); interval-1.4.1/inst/@infsupdec/power.m0000644000000000000000000000613612657475772016072 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsupdec} power (@var{X}, @var{Y}) ## @defopx Operator {@@infsupdec} {@var{X} .^ @var{Y}} ## ## Compute the general power function on intervals, which is defined for ## (1) any positive base @var{X}; (2) @code{@var{X} = 0} when @var{Y} is ## positive; (3) negative base @var{X} together with integral exponent @var{Y}. ## ## This definition complies with the common complex valued power function, ## restricted to the domain where results are real, plus limit values where ## @var{X} is zero. The complex power function is defined by ## @code{exp (@var{Y} * log (@var{X}))} with initial branch of complex ## logarithm and complex exponential function. ## ## Warning: This function is not defined by IEEE Std 1788-2015. However, it ## has been published as “pow2” in O. Heimlich, M. Nehmeier, J. Wolff von ## Gudenberg. 2013. “Variants of the general interval power function.” ## Soft Computing. Volume 17, Issue 8, pp 1357–1366. ## Springer Berlin Heidelberg. DOI 10.1007/s00500-013-1008-8. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## infsupdec (-5, 6) .^ infsupdec (2, 3) ## @result{} ans = [-125, +216]_trv ## @end group ## @end example ## @seealso{@@infsupdec/pow, @@infsupdec/pown, @@infsupdec/pow2, @@infsupdec/pow10, @@infsupdec/exp} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-15 function result = power (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (not (isa (y, "infsupdec"))) y = infsupdec (y); endif if (isnai (x)) result = x; return endif if (isnai (y)) result = y; return endif result = newdec (power (intervalpart (x), intervalpart (y))); result.dec = min (result.dec, min (x.dec, y.dec)); ## The general power function is continuous where it is defined domain = not (isempty (result)) & (... inf (x) > 0 | ... # defined for all x > 0 (inf (x) == 0 & inf (y) > 0) | ... # defined for x = 0 if y > 0 # defined for x < 0 only where y is integral (issingleton (y) & fix (inf (y)) == inf (y) & ... (inf (y) > 0 | not (ismember (0, x))))); # not defined for 0^0 result.dec (not (domain)) = _trv (); endfunction %!test "from the documentation string"; %! assert (isequal (infsupdec (-5, 6) .^ infsupdec (2, 3), infsupdec (-125, 216, "trv"))); interval-1.4.1/inst/@infsupdec/pown.m0000644000000000000000000000350012657475772015711 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} pown (@var{X}, @var{P}) ## ## Compute the monomial @code{x^@var{P}} for all numbers in @var{X}. ## ## Monomials are defined for all real numbers and the special monomial ## @code{@var{P} == 0} evaluates to @code{1} everywhere. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## pown (infsupdec (5, 6), 2) ## @result{} ans = [25, 36]_com ## @end group ## @end example ## @seealso{@@infsupdec/pow, @@infsupdec/pow2, @@infsupdec/pow10, @@infsupdec/exp} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = pown (x, p) if (nargin ~= 2) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (pown (intervalpart (x), p)); result.dec = min (result.dec, x.dec); ## x^P is undefined for x == 0 and P < 0 domain = p >= 0 | not (ismember (0, x)); result.dec (not (domain)) = _trv (); endfunction %!test "from the documentation string"; %! assert (isequal (pown (infsupdec (5, 6), 2), infsupdec (25, 36))); %!assert (pown (infsupdec (-2, 1), 2) == infsupdec (0, 4)); interval-1.4.1/inst/@infsupdec/pownrev.m0000644000000000000000000000420612657475772016432 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsupdec} {@var{X} =} pownrev (@var{C}, @var{X}, @var{P}) ## @deftypemethodx {@@infsupdec} {@var{X} =} pownrev (@var{C}, @var{P}) ## ## Compute the reverse monomial @code{x^@var{P}}. ## ## That is, an enclosure of all @code{x ∈ @var{X}} where ## @code{pown (x, @var{P}) ∈ @var{C}}. ## ## Accuracy: The result is a valid enclosure. The result is a tight ## enclosure for @var{P} ≥ -2. The result also is a tight enclosure if the ## reciprocal of @var{P} can be computed exactly in double-precision. ## ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## No one way of decorating this operations gives useful information in all ## contexts. Therefore, the result will carry a @code{trv} decoration at best. ## ## @seealso{@@infsupdec/pown} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = pownrev (c, x, p) if (nargin < 2 || nargin > 3) print_usage (); return endif if (nargin < 3) p = x; x = infsupdec (-inf, inf); endif if (not (isa (c, "infsupdec"))) c = infsupdec (c); endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (isnai (c)) result = c; return endif if (isnai (x)) result = x; return endif result = infsupdec (pownrev (intervalpart (c), intervalpart (x), p), "trv"); endfunction %!assert (isequal (pownrev (infsupdec (25, 36), infsupdec (0, inf), 2), infsupdec (5, 6, "trv"))); interval-1.4.1/inst/@infsupdec/powrev1.m0000644000000000000000000000457212657475772016343 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsupdec} {@var{X} =} powrev1 (@var{B}, @var{C}, @var{X}) ## @deftypemethodx {@@infsupdec} {@var{X} =} powrev1 (@var{B}, @var{C}) ## ## Compute the reverse power function for the first parameter. ## ## That is, an enclosure of all @code{x ∈ @var{X}} where ## @code{pow (x, b) ∈ @var{C}} for any @code{b ∈ @var{B}}. ## ## Accuracy: The result is a valid enclosure. ## ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## No one way of decorating this operations gives useful information in all ## contexts. Therefore, the result will carry a @code{trv} decoration at best. ## ## @example ## @group ## powrev1 (infsupdec (2, 5), infsupdec (3, 6)) ## @result{} ans ⊂ [1.2457, 2.4495]_trv ## @end group ## @end example ## @seealso{@@infsupdec/pow} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-19 function result = powrev1 (b, c, x) if (nargin < 2 || nargin > 3) print_usage (); return endif if (nargin < 3) x = infsupdec (-inf, inf); endif if (not (isa (b, "infsupdec"))) b = infsupdec (b); endif if (not (isa (c, "infsup"))) c = infsupdec (c); endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (isnai (x)) result = x; return endif if (isnai (b)) result = b; return endif if (isnai (c)) result = c; return endif result = powrev1 (intervalpart (b), intervalpart (c), intervalpart (x)); ## inverse power is not a point function result = infsupdec (result, "trv"); endfunction %!test "from the documentation string"; %! assert (isequal (powrev1 (infsupdec (2, 5), infsupdec (3, 6)), infsupdec ("[0x1.3EE8390D43955, 0x1.3988E1409212Fp1]_trv"))); interval-1.4.1/inst/@infsupdec/powrev2.m0000644000000000000000000000460012657475772016334 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsupdec} {@var{Y} =} powrev2 (@var{A}, @var{C}, @var{Y}) ## @deftypemethodx {@@infsupdec} {@var{Y} =} powrev2 (@var{A}, @var{C}) ## ## Compute the reverse power function for the second parameter. ## ## That is, an enclosure of all @code{y ∈ @var{Y}} where ## @code{pow (a, y) ∈ @var{C}} for any @code{a ∈ @var{A}}. ## ## Accuracy: The result is a valid enclosure. ## ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## No one way of decorating this operations gives useful information in all ## contexts. Therefore, the result will carry a @code{trv} decoration at best. ## ## @example ## @group ## powrev2 (infsupdec (2, 5), infsupdec (3, 6)) ## @result{} ans ⊂ [0.6826, 2.585]_trv ## @end group ## @end example ## @seealso{@@infsupdec/pow} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-19 function result = powrev2 (a, c, y) if (nargin < 2 || nargin > 3) print_usage (); return endif if (nargin < 3) y = infsupdec (-inf, inf); endif if (not (isa (a, "infsupdec"))) a = infsupdec (a); endif if (not (isa (c, "infsupdec"))) c = infsupdec (c); endif if (not (isa (y, "infsupdec"))) y = infsupdec (y); endif if (isnai (y)) result = y; return endif if (isnai (a)) result = b; return endif if (isnai (c)) result = c; return endif result = powrev2 (intervalpart (a), intervalpart (c), intervalpart (y)); ## inverse power is not a point function result = infsupdec (result, "trv"); endfunction %!test "from the documentation string"; %! assert (isequal (powrev2 (infsupdec (2, 5), infsupdec (3, 6)), infsupdec ("[0x1.5D7E8F22BA886p-1, 0x1.4AE00D1CFDEB5p1]_trv"))); interval-1.4.1/inst/@infsupdec/precedes.m0000644000000000000000000000327412657475772016530 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} precedes (@var{A}, @var{B}) ## ## Evaluate precedes comparison on intervals. ## ## True, if @var{A} is left of @var{B}. The intervals may touch. ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## @seealso{@@infsupdec/eq, @@infsupdec/le, @@infsupdec/lt, @@infsupdec/gt, @@infsupdec/strictprecedes, @@infsupdec/subset, @@infsupdec/interior, @@infsupdec/disjoint} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = precedes (a, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (a, "infsupdec"))) a = infsupdec (a); endif if (not (isa (b, "infsupdec"))) b = infsupdec (b); endif if (isnai (a) || isnai (b)) result = false (); else result = precedes (intervalpart (a), intervalpart (b)); endif endfunction %!assert (precedes (infsupdec (1, 2), infsupdec (2, 3))); %!assert (not (precedes (infsupdec (1, 2.1), infsupdec (1.9, 3)))); interval-1.4.1/inst/@infsupdec/prepad.m0000644000000000000000000000505212657475772016205 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} prepad (@var{X}, @var{L}) ## @defmethodx {@@infsupdec} prepad (@var{X}, @var{L}, @var{C}) ## @defmethodx {@@infsupdec} prepad (@var{X}, @var{L}, @var{C}, @var{DIM}) ## ## Prepend the scalar interval value @var{C} to the interval vector @var{X} ## until it is of length @var{L}. If @var{C} is not given, a value of 0 is ## used. ## ## If @code{length (@var{X}) > L}, elements from the beginning of @var{X} are ## removed until an interval vector of length @var{L} is obtained. ## ## If @var{X} is an interval matrix, elements are prepended or removed from ## each row or column. ## ## If the optional argument DIM is given, operate along this dimension. ## ## @example ## @group ## prepad (infsupdec (1 : 3), 5, 42) ## @result{} ans = 1×5 interval vector ## [42]_com [42]_com [1]_com [2]_com [3]_com ## @end group ## @end example ## @seealso{@@infsupdec/reshape, @@infsup/cat, @@infsupdec/postpad, @@infsupdec/resize} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-19 function result = prepad (x, len, c, dim) if (nargin < 2 || nargin > 4) print_usage (); return endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (nargin < 3) c = infsupdec (0); elseif (not (isa (c, "infsupdec"))) c = infsupdec (c); endif if (nargin < 4) if (isvector (x.dec) && not (isscalar (x.dec))) dim = find (size (x.dec) ~= 1, 1); else dim = 1; endif endif if (isnai (x)) result = x; return endif if (isnai (c)) result = c; return endif result = newdec (prepad (intervalpart (x), len, intervalpart (c), dim)); result.dec = prepad (x.dec, len, c.dec, dim); endfunction %!xtest assert (isequal (prepad (infsupdec (2:4), 4, 1), infsupdec (1:4))); %!xtest assert (isequal (prepad (infsupdec (0:2), 2, 1), infsupdec (1:2))); interval-1.4.1/inst/@infsupdec/private/_com.m0000644000000000000000000000201512657475772017315 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defvr Constant _com ## Return numeric representation of the common decoration ## @end defvr ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-18 function d = _com () ## See IEEE Std 1788-2015 14.4 Interchange representations and encodings persistent d = uint8 (16); endfunction interval-1.4.1/inst/@infsupdec/private/_dac.m0000644000000000000000000000203512657475772017270 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defvr Constant _dac ## Return numeric representation of the defined-and-continuous decoration ## @end defvr ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-18 function d = _dac () ## See IEEE Std 1788-2015 14.4 Interchange representations and encodings persistent d = uint8 (12); endfunction interval-1.4.1/inst/@infsupdec/private/_def.m0000644000000000000000000000201512657475772017275 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defvr Constant _def ## Return numeric representation of the defined decoration ## @end defvr ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-18 function d = _def () ## See IEEE Std 1788-2015 14.4 Interchange representations and encodings persistent d = uint8 (8); endfunction interval-1.4.1/inst/@infsupdec/private/_ill.m0000644000000000000000000000202012657475772017313 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defvr Constant _ill ## Return numeric representation of the ill-formed decoration ## @end defvr ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-18 function d = _ill () ## See IEEE Std 1788-2015 14.4 Interchange representations and encodings persistent d = uint8 (0); endfunction interval-1.4.1/inst/@infsupdec/private/_trv.m0000644000000000000000000000201512657475772017352 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defvr Constant _trv ## Return numeric representation of the trivial decoration ## @end defvr ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-18 function d = _trv () ## See IEEE Std 1788-2015 14.4 Interchange representations and encodings persistent d = uint8 (4); endfunction interval-1.4.1/inst/@infsupdec/prod.m0000644000000000000000000000327512657475772015703 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} prod (@var{X}) ## @defmethodx {@@infsupdec} prod (@var{X}, @var{DIM}) ## ## Product of elements along dimension @var{DIM}. If @var{DIM} is omitted, it ## defaults to the first non-singleton dimension. ## ## Accuracy: The result is a valid enclosure. ## ## @example ## @group ## prod (infsupdec (1 : 4)) ## @result{} ans = [24]_com ## @end group ## @end example ## @seealso{@@infsupdec/sum} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-10-24 function result = prod (x, dim) if (nargin > 2) print_usage (); return endif if (nargin < 2) ## Try to find non-singleton dimension dim = find (size (x.dec) > 1, 1); if (isempty (dim)) dim = 1; endif endif result = newdec (prod (intervalpart (x), dim)); if (not (isempty (x.dec))) result.dec = min (result.dec, min (x.dec, [], dim)); endif endfunction %!test "from the documentation string"; %! assert (prod (infsupdec (1 : 4)) == 24); interval-1.4.1/inst/@infsupdec/psi.m0000644000000000000000000000560212657475772015526 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} psi (@var{X}) ## ## Compute the digamma function, also known as the psi function. ## ## @tex ## $$ ## {\rm psi} (x) = \int_0^\infty \left( {{\exp(-t)} \over t} - {{\exp (-xt)} \over {1 - \exp (-t)}} \right) dt ## $$ ## @end tex ## @ifnottex ## @group ## @verbatim ## ∞ ## / exp (-t) exp (-xt) ## psi (x) = | ---------- - -------------- dt ## / t 1 - exp (-t) ## 0 ## @end verbatim ## @end group ## @end ifnottex ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## psi (infsupdec (1)) ## @result{} ans ⊂ [-0.57722, -0.57721]_com ## @end group ## @end example ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-28 function result = psi (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (psi (intervalpart (x))); ## psi is continuous where it is defined result.dec = min (result.dec, x.dec); undefined = (inf (x) <= 0 & fix (inf (x)) == inf (x)) | ... (sup (x) <= 0 & fix (sup (x)) == sup (x)) | ... (inf (x) < 0 & ceil (inf (x)) <= floor (sup (x))); result.dec (undefined) = _trv (); endfunction %!assert (isempty (psi (infsupdec (0)))); %!assert (isempty (psi (infsupdec (-1)))); %!assert (isempty (psi (infsupdec (-2)))); %!assert (isempty (psi (infsupdec (-3)))); %!assert (isequal (psi (infsupdec (pow2 (-1074), inf)), infsupdec ("[Entire]_dac"))); %!assert (isequal (psi (infsupdec (0, inf)), infsupdec ("[Entire]_trv"))); %!assert (isequal (psi (infsupdec (-inf, -43.23)), infsupdec ("[Entire]_trv"))); %!assert (isequal (psi (infsupdec (-1, 0)), infsupdec ("[Entire]_trv"))); %!assert (isequal (psi (infsupdec (-2, -1)), infsupdec ("[Entire]_trv"))); %!assert (isequal (psi (infsupdec (-eps, eps)), infsupdec ("[Entire]_trv"))); %!assert (isequal (psi (infsupdec (-1-eps, -1+eps)), infsupdec ("[Entire]_trv"))); %!assert (isequal (psi (infsupdec (-4.1, -3.9)), infsupdec ("[Entire]_trv"))); %!test "from the documentation string"; %! assert (isequal (psi (infsupdec (1)), infsupdec ("[-0x1.2788CFC6FB619p-1, -0x1.2788CFC6FB618p-1]_com"))); interval-1.4.1/inst/@infsupdec/rdivide.m0000644000000000000000000000416212657475772016361 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsupdec} rdivide (@var{X}, @var{Y}) ## @defopx Operator {@@infsupdec} {@var{X} ./ @var{Y}} ## ## Divide all numbers of interval @var{X} by all numbers of @var{Y}. ## ## For @var{X} = 1 compute the reciprocal of @var{Y}. Thus this function can ## compute @code{recip} as defined by IEEE Std 1788-2015. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## x = infsupdec (2, 3); ## y = infsupdec (1, 2); ## x ./ y ## @result{} ans = [1, 3]_com ## @end group ## @end example ## @seealso{@@infsupdec/mtimes} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = rdivide (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (not (isa (y, "infsupdec"))) y = infsupdec (y); endif if (isnai (x)) result = x; return endif if (isnai (y)) result = y; return endif result = newdec (rdivide (intervalpart (x), intervalpart (y))); result.dec = min (result.dec, min (x.dec, y.dec)); divisionbyzero = ismember (0, y); if (isscalar (y) && not (isscalar (x))) divisionbyzero = divisionbyzero (ones (size (x))); endif result.dec (divisionbyzero) = _trv (); endfunction %!test "from the documentation string"; %! assert (isequal (infsupdec (2, 3) ./ infsupdec (1, 2), infsupdec (1, 3))); %!assert (1 ./ infsupdec (1, 4) == infsupdec (0.25, 1));interval-1.4.1/inst/@infsupdec/realsqrt.m0000644000000000000000000000325312657475772016570 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} realsqrt (@var{X}) ## ## Compute the square root (for all non-negative numbers). ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## realsqrt (infsupdec (-6, 4)) ## @result{} ans = [0, 2]_trv ## @end group ## @end example ## @seealso{@@infsupdec/sqr, @@infsupdec/rsqrt, @@infsupdec/pow, @@infsupdec/cbrt, @@infsupdec/nthroot} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = realsqrt (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (realsqrt (intervalpart (x))); result.dec = min (result.dec, x.dec); ## realsqrt is continuous everywhere, but defined for x >= 0 only defined = subset (x, infsupdec (0, inf)); result.dec (not (defined)) = _trv (); endfunction %!test "from the documentation string"; %! assert (isequal (realsqrt (infsupdec (-6, 4)), infsupdec (0, 2, "trv"))); interval-1.4.1/inst/@infsupdec/reshape.m0000644000000000000000000000432512657475772016363 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} reshape (@var{A}, @var{M}, @var{N}) ## @defmethodx {@@infsupdec} reshape (@var{X}, [@var{M} @var{N}]) ## ## Return an interval matrix with the specified dimensions (M, N) whose ## elements are taken from the interval matrix @var{A}. The elements of the ## matrix are accessed in column-major order (like Fortran arrays are stored). ## ## Note that the total number of elements in the original matrix ## (@code{prod (size (@var{A}))}) must match the total number of elements in ## the new matrix (@code{prod ([@var{M} @var{N}])}). ## ## @example ## @group ## reshape (infsupdec (1 : 6), 2, 3) ## @result{} ans = 2×3 interval matrix ## [1]_com [3]_com [5]_com ## [2]_com [4]_com [6]_com ## @end group ## @end example ## @seealso{@@infsupdec/resize, @@infsup/cat, @@infsupdec/postpad, @@infsupdec/prepad} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-19 function result = reshape (x, m, n) if (not (isa (x, "infsupdec"))) print_usage (); return endif if (isnai (x)) result = x; return endif switch nargin case 2 bare = reshape (intervalpart (x), m); dec = reshape (x.dec, m); case 3 bare = reshape (intervalpart (x), m, n); dec = reshape (x.dec, m, n); otherwise print_usage (); return endswitch result = newdec (bare); result.dec = dec; endfunction %!xtest assert (isequal (reshape (infsupdec (1 : 6), 2, 3), infsupdec (reshape (1 : 6, 2, 3)))); interval-1.4.1/inst/@infsupdec/resize.m0000644000000000000000000000512012657475772016227 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} resize (@var{X}, @var{M}) ## @defmethodx {@@infsupdec} resize (@var{X}, @var{M}, @var{N}) ## @defmethodx {@@infsupdec} resize (@var{X}, [@var{M} @var{N}]) ## ## Resize interval matrix @var{X} cutting off elements as necessary. ## ## In the result, element with certain indices is equal to the corresponding ## element of @var{X} if the indices are within the bounds of @var{X}; ## otherwise, the element is set to the empty interval. ## ## If only @var{M} is supplied, and it is a scalar, the dimension of the result ## is @var{M}-by-@var{M}. If @var{M} and @var{N} are all scalars, then the ## dimensions of the result are @var{M}-by-@var{N}. If given a vector as ## input, then the dimensions of the result are given by the elements of that ## vector. ## ## @example ## @group ## resize (infsupdec (magic (3)), 4, 2) ## @result{} ans = 4×2 interval matrix ## [8]_com [1]_com ## [3]_com [5]_com ## [4]_com [9]_com ## [Empty]_trv [Empty]_trv ## @end group ## @end example ## @seealso{@@infsupdec/reshape, @@infsup/cat, @@infsupdec/postpad, @@infsupdec/prepad} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-19 function result = resize (x, m, n) if (not (isa (x, "infsupdec"))) print_usage (); return endif if (isnai (x)) result = x; return endif switch nargin case 2 bare = resize (intervalpart (x), m); dec = resize (x.dec, m); case 3 bare = resize (intervalpart (x), m, n); dec = resize (x.dec, m, n); otherwise print_usage (); return endswitch result = newdec (bare); dec (dec == 0) = _trv (); # any new elements are [Empty]_trv result.dec = dec; endfunction %!xtest assert (isequal (resize (infsupdec (magic (3)), 4, 2), [infsupdec([8, 1; 3, 5; 4, 9]); infsupdec([inf, inf], [-inf, -inf])])); interval-1.4.1/inst/@infsupdec/round.m0000644000000000000000000000677212657475772016073 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} round (@var{X}) ## ## Round each number in interval @var{X} to the nearest integer. Ties are ## rounded away from zero (towards +Inf or -Inf depending on the sign). ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## round (infsupdec (2.5, 3.5)) ## @result{} ans = [3, 4]_def ## round (infsupdec (-0.5, 5)) ## @result{} ans = [-1, +5]_def ## @end group ## @end example ## @seealso{@@infsupdec/floor, @@infsupdec/ceil, @@infsupdec/roundb, @@infsupdec/fix} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = round (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (round (intervalpart (x))); result.dec = min (result.dec, x.dec); ## Round is like a scaled fix function discontinuous = not (issingleton (result)); result.dec (discontinuous) = min (result.dec (discontinuous), _def ()); onlyrestrictioncontinuous = issingleton (result) & not (... (sup (x) >= 0 | ... fix (sup (x)) == sup (x) | fix (sup (x) * 2) / 2 ~= sup (x)) & ... (inf (x) <= 0 | ... fix (inf (x)) == inf (x) | fix (inf (x) * 2) / 2 ~= inf (x))); result.dec (onlyrestrictioncontinuous) = ... min (result.dec (onlyrestrictioncontinuous), _dac ()); endfunction %!test "Empty interval"; %! assert (isequal (round (infsupdec ()), infsupdec ())); %!test "Singleton intervals"; %! assert (isequal (round (infsupdec (0)), infsupdec (0))); %! assert (isequal (round (infsupdec (0.5)), infsupdec (1, "dac"))); %! assert (isequal (round (infsupdec (0.25)), infsupdec (0))); %! assert (isequal (round (infsupdec (0.75)), infsupdec (1))); %! assert (isequal (round (infsupdec (-0.5)), infsupdec (-1, "dac"))); %!test "Bounded intervals"; %! assert (isequal (round (infsupdec (-0.5, 0)), infsupdec (-1, 0, "def"))); %! assert (isequal (round (infsupdec (0, 0.5)), infsupdec (0, 1, "def"))); %! assert (isequal (round (infsupdec (0.25, 0.5)), infsupdec (0, 1, "def"))); %! assert (isequal (round (infsupdec (-1, 0)), infsupdec (-1, 0, "def"))); %! assert (isequal (round (infsupdec (-1, 1)), infsupdec (-1, 1, "def"))); %! assert (isequal (round (infsupdec (-realmin, realmin)), infsupdec (0))); %! assert (isequal (round (infsupdec (-realmax, realmax)), infsupdec (-realmax, realmax, "def"))); %!test "Unbounded intervals"; %! assert (isequal (round (infsupdec (-realmin, inf)), infsupdec (0, inf, "def"))); %! assert (isequal (round (infsupdec (-realmax, inf)), infsupdec (-realmax, inf, "def"))); %! assert (isequal (round (infsupdec (-inf, realmin)), infsupdec (-inf, 0, "def"))); %! assert (isequal (round (infsupdec (-inf, realmax)), infsupdec (-inf, realmax, "def"))); %! assert (isequal (round (infsupdec (-inf, inf)), infsupdec (-inf, inf, "def"))); interval-1.4.1/inst/@infsupdec/roundb.m0000644000000000000000000000710512657475772016224 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} roundb (@var{X}) ## ## Round each number in interval @var{X} to the nearest integer. Ties are ## rounded towards the nearest even integer. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## roundb (infsupdec (2.5, 3.5)) ## @result{} ans = [2, 4]_def ## roundb (infsupdec (-0.5, 5.5)) ## @result{} ans = [0, 6]_def ## @end group ## @end example ## @seealso{@@infsupdec/floor, @@infsupdec/ceil, @@infsupdec/round, @@infsupdec/fix} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = roundb (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (roundb (intervalpart (x))); result.dec = min (result.dec, x.dec); discontinuous = not (issingleton (result)); result.dec (discontinuous) = min (result.dec (discontinuous), _def ()); onlyrestrictioncontinuous = issingleton (result) & not (... (rem (inf (result), 2) ~= 0 | ... ((fix (sup (x)) == sup (x) | fix (sup (x) * 2) / 2 ~= sup (x)) & ... (fix (inf (x)) == inf (x) | fix (inf (x) * 2) / 2 ~= inf (x))))); result.dec (onlyrestrictioncontinuous) = ... min (result.dec (onlyrestrictioncontinuous), _dac ()); endfunction %!test "Empty interval"; %! assert (isequal (roundb (infsupdec ()), infsupdec ())); %!test "Singleton intervals"; %! assert (isequal (roundb (infsupdec (0)), infsupdec (0))); %! assert (isequal (roundb (infsupdec (0.5)), infsupdec (0, "dac"))); %! assert (isequal (roundb (infsupdec (0.25)), infsupdec (0))); %! assert (isequal (roundb (infsupdec (0.75)), infsupdec (1))); %! assert (isequal (roundb (infsupdec (1.5)), infsupdec (2, "dac"))); %! assert (isequal (roundb (infsupdec (-0.5)), infsupdec (0, "dac"))); %! assert (isequal (roundb (infsupdec (-1.5)), infsupdec (-2, "dac"))); %!test "Bounded intervals"; %! assert (isequal (roundb (infsupdec (-0.5, 0)), infsupdec (0, "dac"))); %! assert (isequal (roundb (infsupdec (0, 0.5)), infsupdec (0, "dac"))); %! assert (isequal (roundb (infsupdec (0.25, 0.5)), infsupdec (0, "dac"))); %! assert (isequal (roundb (infsupdec (-1, 0)), infsupdec (-1, 0, "def"))); %! assert (isequal (roundb (infsupdec (-1, 1)), infsupdec (-1, 1, "def"))); %! assert (isequal (roundb (infsupdec (-realmin, realmin)), infsupdec (0))); %! assert (isequal (roundb (infsupdec (-realmax, realmax)), infsupdec (-realmax, realmax, "def"))); %!test "Unbounded intervals"; %! assert (isequal (roundb (infsupdec (-realmin, inf)), infsupdec (0, inf, "def"))); %! assert (isequal (roundb (infsupdec (-realmax, inf)), infsupdec (-realmax, inf, "def"))); %! assert (isequal (roundb (infsupdec (-inf, realmin)), infsupdec (-inf, 0, "def"))); %! assert (isequal (roundb (infsupdec (-inf, realmax)), infsupdec (-inf, realmax, "def"))); %! assert (isequal (roundb (infsupdec (-inf, inf)), infsupdec (-inf, inf, "def"))); interval-1.4.1/inst/@infsupdec/rsqrt.m0000644000000000000000000000311712657475772016105 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} rsqrt (@var{X}) ## ## Compute the reciprocal square root (for all positive numbers). ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## rsqrt (infsupdec (-6, 4)) ## @result{} ans = [0.5, Inf]_trv ## @end group ## @end example ## @seealso{@@infsupdec/realsqrt} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-03-15 function result = rsqrt (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (rsqrt (intervalpart (x))); result.dec = min (result.dec, x.dec); ## rsqrt is continuous everywhere, but defined for x > 0 only result.dec (not (interior (x, infsupdec (0, inf)))) = _trv (); endfunction %!test "from the documentation string"; %! assert (isequal (rsqrt (infsupdec (-6, 4)), infsupdec (.5, inf, "trv"))); interval-1.4.1/inst/@infsupdec/sec.m0000644000000000000000000000330312657475772015501 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} sec (@var{X}) ## ## Compute the secant in radians, that is the reciprocal cosine. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## sec (infsupdec (1)) ## @result{} ans ⊂ [1.8508, 1.8509]_com ## @end group ## @end example ## @seealso{@@infsupdec/cos, @@infsupdec/csc, @@infsupdec/cot} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-03-15 function result = sec (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (sec (intervalpart (x))); result.dec = min (result.dec, x.dec); ## Because sec (nextdown (pi/2)) < realmax, we can simple check for ## a singularity by comparing the result with entire. domain = not (isentire (result)); result.dec (not (domain)) = _trv (); endfunction %!test "from the documentation string"; %! assert (isequal (sec (infsupdec (1)), infsupdec ("[0x1.D9CF0F125CC29, 0x1.D9CF0F125CC2A]_com"))); interval-1.4.1/inst/@infsupdec/sech.m0000644000000000000000000000311112657475772015646 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} sech (@var{X}) ## ## Compute the hyperbolic secant, that is the reciprocal hyperbolic cosine. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## sech (infsupdec (1)) ## @result{} ans ⊂ [0.64805, 0.64806]_com ## @end group ## @end example ## @seealso{@@infsupdec/cosh, @@infsupdec/csch, @@infsupdec/coth} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-03-15 function result = sech (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (sech (intervalpart (x))); ## sech is defined and continuous everywhere result.dec = min (result.dec, x.dec); endfunction %!test "from the documentation string"; %! assert (isequal (sech (infsupdec (1)), infsupdec ("[0x1.4BCDC50ED6BE7p-1, 0x1.4BCDC50ED6BE8p-1]_com"))); interval-1.4.1/inst/@infsupdec/setdiff.m0000644000000000000000000000433112657475772016355 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} setdiff (@var{A}, @var{B}) ## ## Build the relative complement of interval @var{B} in interval @var{A}. ## ## Accuracy: The result is a tight enclosure. ## ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## The function is a set operation and the result carries the @code{trv} ## decoration at best. ## ## @example ## @group ## x = infsupdec (1, 3); ## y = infsupdec (2, 4); ## setdiff (x, y) ## @result{} ans = [1, 2]_trv ## @end group ## @end example ## @seealso{@@infsupdec/intersect, @@infsupdec/union, @@infsupdec/setxor} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-03 function result = setdiff (a, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (a, "infsupdec"))) a = infsupdec (a); endif if (not (isa (b, "infsupdec"))) b = infsupdec (b); endif if (isnai (a)) result = a; return endif if (isnai (b)) result = b; return endif result = infsupdec (setdiff (intervalpart (a), intervalpart (b)), "trv"); endfunction %!assert (isempty (setdiff (infsupdec (), infsupdec (1, 4)))); %!assert (setdiff (infsupdec (1, 3), infsupdec ()) == infsupdec (1, 3)); %!assert (isempty (setdiff (infsupdec (1, 3), infsupdec (-inf, inf)))); %!assert (isempty (setdiff (infsupdec (1, 3), infsupdec (1, 4)))); %!assert (setdiff (infsupdec (-inf, inf), infsupdec (1, 4)) == infsupdec (-inf, inf)); %!test "from the documentation string"; %! assert (setdiff (infsupdec (1, 3), infsupdec (2, 4)) == infsupdec (1, 2)); interval-1.4.1/inst/@infsupdec/setxor.m0000644000000000000000000000637712657475772016271 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsupdec} {} setxor (@var{A}, @var{B}) ## @deftypemethodx {@@infsupdec} {[@var{C}, @var{C1}, @var{C2}] =} setxor (@var{A}, @var{B}) ## ## Build the symmetric difference of intervals @var{A} and @var{B}. ## ## With three output arguments, return intervals @var{C1} and @var{C2} such ## that @var{C1} and @var{C2} are enclosures of disjoint sets whose union is ## enclosed by interval @var{C}. ## ## Accuracy: The result is a tight enclosure. ## ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## The function is a set operation and the result carries the @code{trv} ## decoration at best. ## ## @example ## @group ## x = infsupdec (1, 3); ## y = infsupdec (2, 4); ## [z, z1, z2] = setxor (x, y) ## @result{} ## z = [1, 4]_trv ## z1 = [1, 2]_trv ## z2 = [3, 4]_trv ## @end group ## @end example ## @seealso{@@infsupdec/intersect, @@infsupdec/union, @@infsupdec/setdiff} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-04-03 function [c, c1, c2] = setxor (a, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (a, "infsupdec"))) a = infsupdec (a); endif if (not (isa (b, "infsupdec"))) b = infsupdec (b); endif if (isnai (a)) c = c1 = c2 = a; return endif if (isnai (b)) c = c1 = c2 = b; return endif if (nargout > 1) [c, c1, c2] = setxor (intervalpart (a), intervalpart (b)); c1 = infsupdec (c1, "trv"); c2 = infsupdec (c2, "trv"); else c = setxor (intervalpart (a), intervalpart (b)); endif c = infsupdec (c, "trv"); endfunction %!test %! [z, z1, z2] = setxor (infsupdec (), infsupdec ()); %! assert (isempty (z)); %! assert (isempty (z1)); %! assert (isempty (z2)); %!test %! [z, z1, z2] = setxor (infsupdec (-inf, inf), infsupdec ()); %! assert (isentire (z)); %! assert (isentire (z1)); %! assert (isempty (z2)); %!test %! [z, z1, z2] = setxor (infsupdec (-inf, inf), infsupdec (2)); %! assert (isentire (z)); %! assert (z1 == infsupdec (-inf, 2)); %! assert (z2 == infsupdec (2, inf)); %!test %! [z, z1, z2] = setxor (infsupdec (2, 3), infsupdec (2)); %! assert (z == infsupdec (2, 3)); %! assert (z1 == infsupdec ()); %! assert (z2 == infsupdec (2, 3)); %!test %! [z, z1, z2] = setxor (infsupdec (2, 3), infsupdec (2, 2.5)); %! assert (z == infsupdec (2.5, 3)); %! assert (z1 == infsupdec ()); %! assert (z2 == infsupdec (2.5, 3)); %!test "from the documentation string"; %! [z, z1, z2] = setxor (infsupdec (1, 3), infsupdec (2, 4)); %! assert (z == infsupdec (1, 4)); %! assert (z1 == infsupdec (1, 2)); %! assert (z2 == infsupdec (3, 4)); interval-1.4.1/inst/@infsupdec/sign.m0000644000000000000000000000404012657475772015666 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} sign (@var{X}) ## ## Compute the signum function for each number in interval @var{X}. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## sign (infsupdec (2, 3)) ## @result{} ans = [1]_com ## sign (infsupdec (0, 5)) ## @result{} ans = [0, 1]_def ## sign (infsupdec (-17)) ## @result{} ans = [-1]_com ## @end group ## @end example ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = sign (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (sign (intervalpart (x))); result.dec = min (result.dec, x.dec); ## sign is defined everywhere and continuous for x ~= 0 discontinuous = not (issingleton (result)); result.dec (discontinuous) = min (result.dec (discontinuous), _def ()); onlyrestrictioncontinuous = inf (x) == 0 & sup (x) == 0; result.dec (onlyrestrictioncontinuous) = ... min (result.dec (onlyrestrictioncontinuous), _dac ()); endfunction %!test "from the documentation string"; %! assert (isequal (sign (infsupdec (2, 3)), infsupdec (1))); %! assert (isequal (sign (infsupdec (0)), infsupdec (0, "dac"))); %! assert (isequal (sign (infsupdec (0, 5)), infsupdec (0, 1, "def"))); %! assert (isequal (sign (infsupdec (-17)), infsupdec (-1))); interval-1.4.1/inst/@infsupdec/sin.m0000644000000000000000000000302212657475772015516 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} sin (@var{X}) ## ## Compute the sine in radians. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## sin (infsupdec (1)) ## @result{} ans ⊂ [0.84147, 0.84148]_com ## @end group ## @end example ## @seealso{@@infsupdec/asin, @@infsupdec/csc, @@infsupdec/sinh} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = sin (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (sin (intervalpart (x))); ## sin is defined and continuous everywhere result.dec = min (result.dec, x.dec); endfunction %!test "from the documentation string"; %! assert (isequal (sin (infsupdec (1)), infsupdec ("[0x1.AED548F090CEEp-1, 0x1.AED548F090CEFp-1]"))); interval-1.4.1/inst/@infsupdec/sinh.m0000644000000000000000000000304412657475772015672 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} sinh (@var{X}) ## ## Compute the hyperbolic sine. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## sinh (infsupdec (1)) ## @result{} ans ⊂ [1.1752, 1.1753]_com ## @end group ## @end example ## @seealso{@@infsupdec/asinh, @@infsupdec/csch, @@infsupdec/cosh, @@infsupdec/tanh} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = sinh (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (sinh (intervalpart (x))); ## sinh is defined and continuous everywhere result.dec = min (result.dec, x.dec); endfunction %!test "from the documentation string"; %! assert (isequal (sinh (infsupdec (1)), infsupdec ("[0x1.2CD9FC44EB982, 0x1.2CD9FC44EB983]"))); interval-1.4.1/inst/@infsupdec/sinrev.m0000644000000000000000000000414012657475772016235 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsupdec} {@var{X} =} sinrev (@var{C}, @var{X}) ## @deftypemethodx {@@infsupdec} {@var{X} =} sinrev (@var{C}) ## ## Compute the reverse sine function. ## ## That is, an enclosure of all @code{x ∈ @var{X}} where ## @code{sin (x) ∈ @var{C}}. ## ## Accuracy: The result is a valid enclosure. ## ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## No one way of decorating this operations gives useful information in all ## contexts. Therefore, the result will carry a @code{trv} decoration at best. ## ## @example ## @group ## sinrev (infsupdec (-1), infsupdec (0, 6)) ## @result{} ans ⊂ [4.7123, 4.7124]_trv ## @end group ## @end example ## @seealso{@@infsupdec/sin} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-19 function result = sinrev (c, x) if (nargin > 2) print_usage (); return endif if (nargin < 2) x = infsupdec (-inf, inf); endif if (not (isa (c, "infsupdec"))) c = infsupdec (c); endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (isnai (c)) result = c; return endif if (isnai (x)) result = x; return endif result = infsupdec (sinrev (intervalpart (c), intervalpart (x)), "trv"); endfunction %!test "from the documentation string"; %! assert (isequal (sinrev (infsupdec (-1), infsupdec (0, 6)), infsupdec ("[0x1.2D97C7F3321D2p2, 0x1.2D97C7F3321D3p2]_trv"))); interval-1.4.1/inst/@infsupdec/sqrrev.m0000644000000000000000000000402612657475772016254 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsupdec} {@var{X} =} sqrrev (@var{C}, @var{X}) ## @deftypemethodx {@@infsupdec} {@var{X} =} sqrrev (@var{C}) ## ## Compute the reverse square function. ## ## That is, an enclosure of all @code{x ∈ @var{X}} where ## @code{sqr (x) ∈ @var{C}}. ## ## Accuracy: The result is a tight enclosure. ## ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## No one way of decorating this operations gives useful information in all ## contexts. Therefore, the result will carry a @code{trv} decoration at best. ## ## @example ## @group ## sqrrev (infsupdec (-2, 1)) ## @result{} ans = [-1, +1]_trv ## @end group ## @end example ## @seealso{@@infsupdec/sqr} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-19 function result = sqrrev (c, x) if (nargin > 2) print_usage (); return endif if (nargin < 2) x = infsupdec (-inf, inf); endif if (not (isa (c, "infsupdec"))) c = infsupdec (c); endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (isnai (c)) result = c; return endif if (isnai (x)) result = x; return endif result = infsupdec (sqrrev (intervalpart (c), intervalpart (x)), "trv"); endfunction %!test "from the documentation string"; %! assert (isequal (sqrrev (infsupdec (-2, 1)), infsupdec (-1, 1, "trv"))); interval-1.4.1/inst/@infsupdec/strictprecedes.m0000644000000000000000000000335012657475772017754 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} strictprecedes (@var{A}, @var{B}) ## ## Evaluate strict precedes comparison on intervals. ## ## True, if @var{A} is strictly left of @var{B}. The intervals may not touch. ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## @seealso{@@infsupdec/eq, @@infsupdec/le, @@infsupdec/lt, @@infsupdec/gt, @@infsupdec/precedes, @@infsupdec/subset, @@infsupdec/interior, @@infsupdec/disjoint} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = strictprecedes (a, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (a, "infsupdec"))) a = infsupdec (a); endif if (not (isa (b, "infsupdec"))) b = infsupdec (b); endif if (isnai (a) || isnai (b)) result = false (); else result = strictprecedes (intervalpart (a), intervalpart (b)); endif endfunction %!assert (strictprecedes (infsupdec (1, 1.9), infsupdec (2.1, 3))); %!assert (not (strictprecedes (infsupdec (1, 2), infsupdec (2, 3)))); interval-1.4.1/inst/@infsupdec/subsasgn.m0000644000000000000000000000415212657475772016557 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsupdec} subsasgn (@var{A}, @var{IDX}, @var{RHS}) ## @defopx Operator {@@infsupdec} {@var{A}(@var{SUBS}) = @var{RHS}} ## ## Perform the subscripted assignment operation according to the subscript ## specified by @var{IDX}. ## ## The subscript @var{IDX} is expected to be a structure array with fields ## @code{type} and @code{subs}. Only valid value for @var{type} is ## @code{"()"}. The @code{subs} field may be either @code{":"} or a cell array ## of index values. ## @seealso{@@infsupdec/subsref} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-11-02 function result = subsasgn (A, S, B) if (nargin ~= 3) print_usage (); return endif if (not (isa (A, "infsupdec"))) A = infsupdec (A); endif if (not (isa (B, "infsupdec"))) B = infsupdec (B); endif if (isnai (A)) result = A; return endif if (isnai (B)) result = B; return endif result = newdec (subsasgn (intervalpart (A), S, intervalpart (B))); result.dec = subsasgn (A.dec, S, B.dec); result.dec (result.dec == 0) = _com (); # any new elements are [0]_com endfunction %!test %! A = infsupdec (magic (3)); %! A (4, 4) = 42; %! assert (inf (A), [magic(3),[0;0;0];0,0,0,42]); %! assert (sup (A), [magic(3),[0;0;0];0,0,0,42]); %! assert (decorationpart (A), {"com", "com", "com", "com"; "com", "com", "com", "com"; "com", "com", "com", "com"; "com", "com", "com", "com"}); interval-1.4.1/inst/@infsupdec/subset.m0000644000000000000000000000313212657475772016234 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} subset (@var{A}, @var{B}) ## ## Evaluate subset comparison on intervals. ## ## True, if all numbers from @var{A} are also contained in @var{B}. ## False, if @var{A} contains a number which is not a member in @var{B}. ## ## Evaluated on interval matrices, this functions is applied element-wise. ## ## @seealso{@@infsupdec/eq, @@infsupdec/interior, @@infsupdec/disjoint} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = subset (a, b) if (nargin ~= 2) print_usage (); return endif if (not (isa (a, "infsupdec"))) a = infsupdec (a); endif if (not (isa (b, "infsupdec"))) b = infsupdec (b); endif if (isnai (a) || isnai (b)) result = false (); else result = subset (intervalpart (a), intervalpart (b)); endif endfunction %!assert (subset (infsupdec (1, 2), infsupdec (1, 3))); interval-1.4.1/inst/@infsupdec/subsref.m0000644000000000000000000000600512657475772016402 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsupdec} subsref (@var{A}, @var{IDX}) ## @defopx Operator {@@infsupdec} {@var{A}(@var{I})} ## @defopx Operator {@@infsupdec} {@var{A}(@var{I1}, @var{I2})} ## @defopx Operator {@@infsupdec} {@var{A}.@var{P}} ## ## Select property @var{P} or elements @var{I} from interval matrix @var{A}. ## ## The index @var{I} may be either @code{:} or an index matrix. ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## The property @var{P} may correspond to any unary method of the interval's ## class, but usually is either @code{inf}, @code{sup} or ## @code{decorationpart}. ## ## @example ## @group ## x = infsupdec (magic (3), magic (3) + 1); ## x (1) ## @result{} ans = [8, 9]_com ## x (:, 2) ## @result{} ans = 3×1 interval vector ## [1, 2]_com ## [5, 6]_com ## [9, 10]_com ## x.inf ## @result{} ans = ## 8 1 6 ## 3 5 7 ## 4 9 2 ## @end group ## @end example ## @seealso{@@infsupdec/subsasgn} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-11-02 function result = subsref (A, S) if (nargin ~= 2) print_usage (); return endif switch (S (1).type) case "()" result = newdec (subsref (intervalpart (A), S (1))); result.dec = subsref (A.dec, S (1)); case "{}" error ("interval cannot be indexed with {}") case "." if (any (strcmp (S(1).subs, methods ("infsupdec")))) functionname = ["@infsupdec", filesep(), S(1).subs]; elseif (any (strcmp (S(1).subs, methods ("infsup")))) functionname = ["@infsup", filesep(), S(1).subs]; else error (["interval property ‘", S(1).subs, "’ is unknown"]) endif if (nargin (functionname) ~= 1) error (["‘", S(1).subs, "’ is not a valid interval property"]) endif result = feval (S (1).subs, A); otherwise error ("invalid subscript type") endswitch if (numel (S) > 1) result = subsref (result, S (2:end)); endif endfunction %!xtest assert (isequal (infsupdec (magic (3)) ([1, 2, 3]), infsupdec (magic (3) ([1, 2, 3])))); %!test "from the documentation string"; %! x = infsupdec (magic (3), magic (3) + 1); %! assert (x (1) == infsupdec (8, 9)); %! assert (x (:, 2) == infsupdec ([1; 5; 9], [2; 6; 10])); %! assert (x.inf, magic (3)); interval-1.4.1/inst/@infsupdec/sum.m0000644000000000000000000000352512657475772015541 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} sum (@var{X}) ## @defmethodx {@@infsupdec} sum (@var{X}, @var{DIM}) ## ## Sum of elements along dimension @var{DIM}. If @var{DIM} is omitted, it ## defaults to the first non-singleton dimension. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## sum ([infsupdec(1), pow2(-1074), -1]) ## @result{} ans ⊂ [4.9406e-324, 4.9407e-324]_com ## infsupdec (1) + pow2 (-1074) - 1 ## @result{} ans ⊂ [0, 2.2205e-16]_com ## @end group ## @end example ## @seealso{@@infsupdec/plus} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-01-31 function result = sum (x, dim) if (nargin > 2) print_usage (); return endif if (nargin < 2) ## Try to find non-singleton dimension dim = find (size (x.dec) > 1, 1); if (isempty (dim)) dim = 1; endif endif result = newdec (sum (intervalpart (x), dim)); if (not (isempty (x.dec))) result.dec = min (result.dec, min (x.dec, [], dim)); endif endfunction %!test "from the documentation string"; %! assert (isequal (sum ([infsupdec(1), pow2(-1074), -1]), infsupdec (pow2 (-1074)))); interval-1.4.1/inst/@infsupdec/tan.m0000644000000000000000000000322412657475772015513 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} tan (@var{X}) ## ## Compute the tangent in radians. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## tan (infsupdec (1)) ## @result{} ans ⊂ [1.5574, 1.5575]_com ## @end group ## @end example ## @seealso{@@infsupdec/atan, @@infsupdec/tanh} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = tan (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (tan (intervalpart (x))); result.dec = min (result.dec, x.dec); ## Because tan (nextdown (pi / 2)) < realmax, we can simple check for ## a singularity by comparing the result with entire. domain = not (isentire (result)); result.dec (not (domain)) = _trv (); endfunction %!test "from the documentation string"; %! assert (isequal (tan (infsupdec (1)), infsupdec ("[0x1.8EB245CBEE3A5, 0x1.8EB245CBEE3A6]"))); interval-1.4.1/inst/@infsupdec/tanh.m0000644000000000000000000000305612657475772015666 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} tanh (@var{X}) ## ## Compute the hyperbolic tangent. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## tanh (infsupdec (1)) ## @result{} ans ⊂ [0.76159, 0.7616]_com ## @end group ## @end example ## @seealso{@@infsupdec/atanh, @@infsupdec/coth, @@infsupdec/sinh, @@infsupdec/cosh} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = tanh (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif result = newdec (tanh (intervalpart (x))); ## tanh is defined and continuous everywhere result.dec = min (result.dec, x.dec); endfunction %!test "from the documentation string"; %! assert (isequal (tanh (infsupdec (1)), infsupdec ("[0x1.85EFAB514F394p-1, 0x1.85EFAB514F395p-1]"))); interval-1.4.1/inst/@infsupdec/tanrev.m0000644000000000000000000000407412657475772016234 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @deftypemethod {@@infsupdec} {@var{X} =} tanrev (@var{C}, @var{X}) ## @deftypemethodx {@@infsupdec} {@var{X} =} tanrev (@var{C}) ## ## Compute the reverse tangent function. ## ## That is, an enclosure of all @code{x ∈ @var{X}} where ## @code{tan (x) ∈ @var{C}}. ## ## Accuracy: The result is a valid enclosure. ## ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## No one way of decorating this operations gives useful information in all ## contexts. Therefore, the result will carry a @code{trv} decoration at best. ## ## @example ## @group ## tanrev (infsupdec (0), infsupdec (2, 4)) ## @result{} ans ⊂ [3.1415, 3.1416]_trv ## @end group ## @end example ## @seealso{@@infsupdec/tan} ## @end deftypemethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-19 function result = tanrev (c, x) if (nargin > 2) print_usage (); return endif if (nargin < 2) x = infsupdec (-inf, inf); endif if (not (isa (c, "infsupdec"))) c = infsupdec (c); endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (isnai (c)) result = c; return endif if (isnai (x)) result = x; return endif result = infsupdec (tanrev (intervalpart (c), intervalpart (x)), "trv"); endfunction %!test "from the documentation string"; %! assert (isequal (tanrev (infsupdec (0), infsupdec (2, 4)), infsupdec ("pi", "trv"))); interval-1.4.1/inst/@infsupdec/times.m0000644000000000000000000000345312657475772016056 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsupdec} times (@var{X}, @var{Y}) ## @defopx Operator {@@infsupdec} {@var{X} .* @var{Y}} ## ## Multiply all numbers of interval @var{X} by all numbers of @var{Y}. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## x = infsupdec (2, 3); ## y = infsupdec (1, 2); ## x .* y ## @result{} ans = [2, 6]_com ## @end group ## @end example ## @seealso{@@infsupdec/mrdivide} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = times (x, y) if (nargin ~= 2) print_usage (); return endif if (not (isa (x, "infsupdec"))) x = infsupdec (x); endif if (not (isa (y, "infsupdec"))) y = infsupdec (y); endif if (isnai (x)) result = x; return endif if (isnai (y)) result = y; return endif result = newdec (times (intervalpart (x), intervalpart (y))); ## times is defined and continuous everywhere result.dec = min (result.dec, min (x.dec, y.dec)); endfunction %!test "from the documentation string"; %! assert (isequal (infsupdec (2, 3) .* infsupdec (1, 2), infsupdec (2, 6))); interval-1.4.1/inst/@infsupdec/transpose.m0000644000000000000000000000315012657475772016745 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsupdec} transpose (@var{X}) ## @defopx Operator {@@infsupdec} {@var{X}.'} ## ## Return the transpose of interval matrix or vector @var{X}. ## ## @example ## @group ## infsupdec (zeros (1, 3), ones (1, 3)) .' ## @result{} ans = 3×1 interval vector ## [0, 1]_com ## [0, 1]_com ## [0, 1]_com ## @end group ## @end example ## @seealso{@@infsupdec/ctranspose} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-11-02 function result = transpose (x) if (nargin ~= 1) print_usage (); return endif result = newdec (transpose (intervalpart (x))); result.dec = transpose (x.dec); endfunction %!xtest assert (isequal (transpose (infsupdec (magic (3))), infsupdec (magic (3).'))); %!xtest "from the documentation string"; %! assert (isequal (transpose (infsupdec (zeros (1, 3), ones (1, 3))), infsupdec (zeros (3, 1), ones (3, 1)))); interval-1.4.1/inst/@infsupdec/uminus.m0000644000000000000000000000270412657475772016253 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsupdec} uminus (@var{X}) ## @defopx Operator {@@infsupdec} {-@var{X}} ## ## Negate all numbers in the interval. ## ## Accuracy: The result is exact. ## ## @example ## @group ## x = infsupdec (2, 3); ## -x ## @result{} ans = [-3, -2]_com ## @end group ## @end example ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = uminus (x) if (nargin ~= 1) print_usage (); return endif if (isnai (x)) result = x; return endif ## uminus is defined and continuous everywhere result = newdec (uminus (intervalpart (x))); result.dec = x.dec; endfunction %!test "from the documentation string"; %! assert (isequal (-infsupdec (2, 3), infsupdec (-3, -2))); interval-1.4.1/inst/@infsupdec/union.m0000644000000000000000000000503212657475772016060 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defmethod {@@infsupdec} union (@var{A}) ## @defmethodx {@@infsupdec} union (@var{A}, @var{B}) ## @defmethodx {@@infsupdec} union (@var{A}, [], @var{DIM}) ## ## Build the interval hull of the union of intervals. ## ## With two arguments the union is built pair-wise. Otherwise the union is ## computed for all interval members along dimension @var{DIM}, which defaults ## to the first non-singleton dimension. ## ## Accuracy: The result is exact. ## ## @comment DO NOT SYNCHRONIZE DOCUMENTATION STRING ## The function is a set operation and the result carries the @code{trv} ## decoration at best. ## ## @example ## @group ## x = infsupdec (1, 3); ## y = infsupdec (2, 4); ## union (x, y) ## @result{} ans = [1, 4]_trv ## @end group ## @end example ## @seealso{hull, @@infsupdec/intersect, @@infsupdec/setdiff, @@infsupdec/setxor} ## @end defmethod ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-13 function result = union (a, b, dim) if (not (isa (a, "infsupdec"))) a = infsupdec (a); endif if (isnai (a)) result = a; return endif switch (nargin) case 1 bare = union (intervalpart (a)); case 2 if (not (isa (b, "infsupdec"))) b = infsupdec (b); endif if (isnai (b)) result = b; return endif bare = union (intervalpart (a), intervalpart (b)); case 3 if (not (builtin ("isempty", b))) warning ("union: second argument is ignored"); endif bare = union (intervalpart (a), [], dim); otherwise print_usage (); return endswitch ## convexHull must not retain any useful decoration result = infsupdec (bare, "trv"); endfunction %!test "from the documentation string"; %! assert (isequal (union (infsupdec (1, 3), infsupdec (2, 4)), infsupdec (1, 4, "trv"))); interval-1.4.1/inst/@infsupdec/vertcat.m0000644000000000000000000000434012657475772016401 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defop Method {@@infsupdec} vertcat (@var{ARRAY1}, @var{ARRAY2}, @dots{}) ## @defopx Operator {@@infsupdec} {[@var{ARRAY1}; @var{ARRAY2}; @dots{}]} ## ## Return the vertical concatenation of interval array objects along ## dimension 1. ## ## @example ## @group ## a = infsupdec (2, 5); ## [a; a; a] ## @result{} ans = 3×1 interval vector ## [2, 5]_com ## [2, 5]_com ## [2, 5]_com ## @end group ## @end example ## @seealso{@@infsupdec/horzcat} ## @end defop ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-11-02 function result = vertcat (varargin) varargin = transpose (varargin); ## Conversion to interval decoratedintervals = cellfun ("isclass", varargin, "infsupdec"); to_convert = not (decoratedintervals); varargin (to_convert) = cellfun (@infsupdec, varargin (to_convert), ... "UniformOutput", false ()); nais = cellfun (@isnai, varargin); if (any (nais)) ## Simply return first NaI result = varargin {find (nais, 1)}; return endif l = cell2mat (cellfun (@inf, varargin, "UniformOutput", false ())); u = cell2mat (cellfun (@sup, varargin, "UniformOutput", false ())); d = cell2mat (cellfun (@(x) x.dec, varargin, "UniformOutput", false ())); result = newdec (infsup (l, u)); result.dec = d; endfunction %!xtest assert (isequal (vertcat (infsupdec (1), infsupdec (2)), infsupdec (vertcat (1, 2)))); %!xtest "from the documentation string"; %! a = infsupdec (2, 5); %! assert (isequal (vertcat (a, a, a), infsupdec ([2; 2; 2], [5; 5; 5]))); interval-1.4.1/inst/__print_mesa__.m0000644000000000000000000000756612657475772015623 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defun __print_mesa__ (@var{H}, @var{FILENAME}) ## Render the OpenGL scene into an image file (internal function). ## ## This function can be used as an replacement of the @code{print} function, ## but will generously modify the figure. The figure should be closed after ## calling this function. ## ## Kludge alert: The export of patch objects within figures is somewhat broken, ## especially for 3D plots. This function renders the OpenGL scene without ## using @command{gl2ps}, which basically produces a screen shot of the figure. ## ## This function requires an Octave version of at least 4.0.0. ## @end defun ## Author: Oliver Heimlich ## Keywords: kludge ## Created: 2015-05-20 function __print_mesa__ (h, filename) if (not (exist ('__osmesa_print__'))) warning (['__print_mesa__ requires Octave >= 4.0.0, ' ... 'falling back to builtin print function']) builtin ('print', h, filename); return endif ## hide figure (for __osmesa_print__ to work) set (h, 'visible', 'off'); screensize = get (h, 'position') (3 : 4); ## print exports raster graphics with 150 dpi exportsize = 150 .* get (h, 'paperposition') (3 : 4); ## __osmesa_print__ seems to apply no anti-aliasing. ## Thus, we apply a FXAA filter ourself. Since this would make the image pretty ## small, we have to increase the figure size. rendersize = 2 .* exportsize; set (h, 'position', [0, 0, rendersize]); resizefactor = mean (rendersize ./ screensize); ## The greater figure size together with the FXAA filter effectively increase ## the image's resolution. In order to get readable text and visible lines, ## we must also increase font sizes, line widths and dot sizes. ## ## FIXME The following code might not increase the size of all relevant objects ## in the figure, but works quite well for everything that can be encountered ## in the interval package. a = allchild (h); a = a (strcmp (get (a, 'type'), 'axes')); # axis and legend for obj = a' set (obj, 'fontsize', resizefactor * get (obj, 'fontsize'), ... 'linewidth', resizefactor * get (obj, 'linewidth')); endfor l = allchild (a); if (iscell (l)) l = vertcat (l {:}); endif t = l (strcmp (get (l, 'type'), 'text')); for obj = t' set (obj, 'fontsize', resizefactor * get (obj, 'fontsize')); endfor l = l (strcmp (get (l, 'type'), 'line') | strcmp (get (l, 'type'), 'patch')); for obj = l' set (obj, 'linewidth', resizefactor * get (obj, 'linewidth')); endfor g = allchild (a); if (iscell (g)) g = vercat (g {:}); endif g = g (strcmp (get (g, 'type'), 'hggroup')); # markers from scatter plots p = allchild (g); if (iscell (p)) p = vertcat (p {:}); endif p = p (strcmp (get (p, 'type'), 'patch')); for obj = p' set (obj, 'markersize', resizefactor * get (obj, 'markersize')); endfor ## Capture OpenGL scene (without gl2ps) warning ('off', 'Octave:GraphicsMagic-Quantum-Depth', 'local'); img = __osmesa_print__ (h); ## Apply FXAA img = uint16 (img); img = img (1:2:end, :, :) + img (2:2:end, :, :); img = img (:, 1:2:end, :) + img (:, 2:2:end, :); img = uint8 (img / 4); ## Save to file imwrite (img, filename); endfunction %!# This function cannot be tested -- it would also fail on Octave < 3.8.2 %!assert (1); interval-1.4.1/inst/__split_interval_literals__.m0000644000000000000000000002207612657475772020411 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding utf-8 ## @defun __split_interval_literals__ (@var{S}) ## ## Split string @var{S} into a cell array of interval literals. ## ## This is an internal function of the interval package and should not be used ## directly. ## @end defun ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-06-13 function result = __split_interval_literals__ (s) if (isempty (s)) result = { s }; return endif ## Split into rows, ## using newline characters, semicolon and rows in 2D strings as delimiters row = transpose (ostrsplit (s, ";\n")); ## Normalize delimiters between intervals within the same row row = strrep (row, "\t", ' '); row = strrep (row, '[', "\t["); # start of interval literals row = regexprep (row, '(](_\w*)?)\s*', "$1\t"); # end of interval literals ## Bare numbers “1 2, 3 4” shall be split into columns by spaces or commas [bare_numbers.s, bare_numbers.e] = regexp (row, '(^|\t)[^\t\[]+($|\t)'); for i = 1 : numel (row) for j = 1 : numel (bare_numbers.s {i}) select = bare_numbers.s {i} (j) : bare_numbers.e {i} (j); row {i} (select) = strrep (strrep (row {i} (select), ' ', "\t"), ... ',', "\t"); endfor endfor ## Separate columns within each row row = cellfun (@(s) strsplit (strtrim (s), "\t"), row, "UniformOutput", false); ## Fill short rows with empty columns cols = cellfun ('numel', row); max_cols = max (cols); for i = find (cols < max_cols)' row {i} = horzcat (row {i}, {"[Empty]"} (ones (1, max_cols - cols (i)))); endfor ## Build a 2D cell array from a cell array of cell arrays result = vertcat (row {:}); endfunction %!assert (__split_interval_literals__ (""), {""}); %!assert (__split_interval_literals__ (","), {""}); %!assert (__split_interval_literals__ ("1"), {"1"}); %!assert (__split_interval_literals__ ("1?"), {"1?"}); %!assert (__split_interval_literals__ ("1?u"), {"1?u"}); %!assert (__split_interval_literals__ ("1?u3"), {"1?u3"}); %!assert (__split_interval_literals__ ("[Empty]"), {"[Empty]"}); %!assert (__split_interval_literals__ ("[Entire]"), {"[Entire]"}); %!assert (__split_interval_literals__ ("[]"), {"[]"}); %!assert (__split_interval_literals__ ("[,]"), {"[,]"}); %!assert (__split_interval_literals__ ("[1]"), {"[1]"}); %!assert (__split_interval_literals__ ("[1,2]"), {"[1,2]"}); %!assert (__split_interval_literals__ ("1 2"), {"1", "2"}); %!assert (__split_interval_literals__ ("1, , , , , , ,2"), {"1", "2"}); %!assert (__split_interval_literals__ ("1;;2"), {"1"; ""; "2"}); %!assert (__split_interval_literals__ ("1; ;2"), {"1"; ""; "2"}); %!assert (__split_interval_literals__ ("[1,2] [3,4]"), {"[1,2]", "[3,4]"}); %!assert (__split_interval_literals__ ("[1,2],[3,4]"), {"[1,2]", "[3,4]"}); %!assert (__split_interval_literals__ ("[1,2], [3,4]"), {"[1,2]", "[3,4]"}); %!assert (__split_interval_literals__ ("[1,2]\n[3,4]"), {"[1,2]"; "[3,4]"}); %!assert (__split_interval_literals__ ("[1,2];[3,4]"), {"[1,2]"; "[3,4]"}); %!assert (__split_interval_literals__ ("[1,2]; [3,4]"), {"[1,2]"; "[3,4]"}); %!assert (__split_interval_literals__ (["[1,2]"; "[3,4]"]), {"[1,2]"; "[3,4]"}); %!assert (__split_interval_literals__ ("1 [3,4]"), {"1", "[3,4]"}); %!assert (__split_interval_literals__ ("1,[3,4]"), {"1", "[3,4]"}); %!assert (__split_interval_literals__ ("1, [3,4]"), {"1", "[3,4]"}); %!assert (__split_interval_literals__ ("1\n[3,4]"), {"1"; "[3,4]"}); %!assert (__split_interval_literals__ ("1;[3,4]"), {"1"; "[3,4]"}); %!assert (__split_interval_literals__ ("1; [3,4]"), {"1"; "[3,4]"}); %!assert (__split_interval_literals__ (["1"; "[3,4]"]), {"1"; "[3,4]"}); %!assert (__split_interval_literals__ ("[1,2] 3"), {"[1,2]", "3"}); %!assert (__split_interval_literals__ ("[1,2],3"), {"[1,2]", "3"}); %!assert (__split_interval_literals__ ("[1,2], 3"), {"[1,2]", "3"}); %!assert (__split_interval_literals__ ("[1,2]\n3"), {"[1,2]"; "3"}); %!assert (__split_interval_literals__ ("[1,2];3"), {"[1,2]"; "3"}); %!assert (__split_interval_literals__ ("[1,2]; 3"), {"[1,2]"; "3"}); %!assert (__split_interval_literals__ (["[1,2]"; "3"]), {"[1,2]"; "3"}); %!assert (__split_interval_literals__ ("1 3"), {"1", "3"}); %!assert (__split_interval_literals__ ("1,3"), {"1", "3"}); %!assert (__split_interval_literals__ ("1, 3"), {"1", "3"}); %!assert (__split_interval_literals__ ("1\n3"), {"1"; "3"}); %!assert (__split_interval_literals__ ("1;3"), {"1"; "3"}); %!assert (__split_interval_literals__ ("1; 3"), {"1"; "3"}); %!assert (__split_interval_literals__ (["1"; "3"]), {"1"; "3"}); %!assert (__split_interval_literals__ ("[1,2] [3,4] [5,6]"), {"[1,2]", "[3,4]", "[5,6]"}); %!assert (__split_interval_literals__ ("[1,2],[3,4],[5,6]"), {"[1,2]", "[3,4]", "[5,6]"}); %!assert (__split_interval_literals__ ("[1,2], [3,4], [5,6]"), {"[1,2]", "[3,4]", "[5,6]"}); %!assert (__split_interval_literals__ ("[1,2]\n[3,4];[5,6]"), {"[1,2]"; "[3,4]"; "[5,6]"}); %!assert (__split_interval_literals__ ("[1,2];[3,4] [5,6]"), {"[1,2]", "[Empty]"; "[3,4]", "[5,6]"}); %!assert (__split_interval_literals__ ("[1,2] [3,4];[5,6]"), {"[1,2]", "[3,4]"; "[5,6]", "[Empty]"}); %!assert (__split_interval_literals__ ("1 [3,4] [5,6]"), {"1", "[3,4]", "[5,6]"}); %!assert (__split_interval_literals__ ("1,[3,4],[5,6]"), {"1", "[3,4]", "[5,6]"}); %!assert (__split_interval_literals__ ("1, [3,4], [5,6]"), {"1", "[3,4]", "[5,6]"}); %!assert (__split_interval_literals__ ("1\n[3,4];[5,6]"), {"1"; "[3,4]"; "[5,6]"}); %!assert (__split_interval_literals__ ("1;[3,4] [5,6]"), {"1", "[Empty]"; "[3,4]", "[5,6]"}); %!assert (__split_interval_literals__ ("1 [3,4];[5,6]"), {"1", "[3,4]"; "[5,6]", "[Empty]"}); %!assert (__split_interval_literals__ ("[1,2] 3 [5,6]"), {"[1,2]", "3", "[5,6]"}); %!assert (__split_interval_literals__ ("[1,2],3,[5,6]"), {"[1,2]", "3", "[5,6]"}); %!assert (__split_interval_literals__ ("[1,2], 3, [5,6]"), {"[1,2]", "3", "[5,6]"}); %!assert (__split_interval_literals__ ("[1,2]\n3;[5,6]"), {"[1,2]"; "3"; "[5,6]"}); %!assert (__split_interval_literals__ ("[1,2];3 [5,6]"), {"[1,2]", "[Empty]"; "3", "[5,6]"}); %!assert (__split_interval_literals__ ("[1,2] 3;[5,6]"), {"[1,2]", "3"; "[5,6]", "[Empty]"}); %!assert (__split_interval_literals__ ("[1,2] [3,4] 5"), {"[1,2]", "[3,4]", "5"}); %!assert (__split_interval_literals__ ("[1,2],[3,4],5"), {"[1,2]", "[3,4]", "5"}); %!assert (__split_interval_literals__ ("[1,2], [3,4], 5"), {"[1,2]", "[3,4]", "5"}); %!assert (__split_interval_literals__ ("[1,2]\n[3,4];5"), {"[1,2]"; "[3,4]"; "5"}); %!assert (__split_interval_literals__ ("[1,2];[3,4] 5"), {"[1,2]", "[Empty]"; "[3,4]", "5"}); %!assert (__split_interval_literals__ ("[1,2] [3,4];5"), {"[1,2]", "[3,4]"; "5", "[Empty]"}); %!assert (__split_interval_literals__ ("1 [3,4] 5"), {"1", "[3,4]", "5"}); %!assert (__split_interval_literals__ ("1,[3,4],5"), {"1", "[3,4]", "5"}); %!assert (__split_interval_literals__ ("1, [3,4], 5"), {"1", "[3,4]", "5"}); %!assert (__split_interval_literals__ ("1\n[3,4];5"), {"1"; "[3,4]"; "5"}); %!assert (__split_interval_literals__ ("1;[3,4] 5"), {"1", "[Empty]"; "[3,4]", "5"}); %!assert (__split_interval_literals__ ("1 [3,4];5"), {"1", "[3,4]"; "5", "[Empty]"}); %!assert (__split_interval_literals__ ("1 3 [5,6]"), {"1", "3", "[5,6]"}); %!assert (__split_interval_literals__ ("1,3,[5,6]"), {"1", "3", "[5,6]"}); %!assert (__split_interval_literals__ ("1, 3, [5,6]"), {"1", "3", "[5,6]"}); %!assert (__split_interval_literals__ ("1\n3;[5,6]"), {"1"; "3"; "[5,6]"}); %!assert (__split_interval_literals__ ("1;3 [5,6]"), {"1", "[Empty]"; "3", "[5,6]"}); %!assert (__split_interval_literals__ ("1 3;[5,6]"), {"1", "3"; "[5,6]", "[Empty]"}); %!assert (__split_interval_literals__ ("[1,2] 3 5"), {"[1,2]", "3", "5"}); %!assert (__split_interval_literals__ ("[1,2],3,5"), {"[1,2]", "3", "5"}); %!assert (__split_interval_literals__ ("[1,2], 3, 5"), {"[1,2]", "3", "5"}); %!assert (__split_interval_literals__ ("[1,2]\n3;5"), {"[1,2]"; "3"; "5"}); %!assert (__split_interval_literals__ ("[1,2];3 5"), {"[1,2]", "[Empty]"; "3", "5"}); %!assert (__split_interval_literals__ ("[1,2] 3;5"), {"[1,2]", "3"; "5", "[Empty]"}); %!assert (__split_interval_literals__ ("1 3 5"), {"1", "3", "5"}); %!assert (__split_interval_literals__ ("1,3,5"), {"1", "3", "5"}); %!assert (__split_interval_literals__ ("1, 3, 5"), {"1", "3", "5"}); %!assert (__split_interval_literals__ ("1\n3;5"), {"1"; "3"; "5"}); %!assert (__split_interval_literals__ ("1;3 5"), {"1", "[Empty]"; "3", "5"}); %!assert (__split_interval_literals__ ("1 3;5"), {"1", "3"; "5", "[Empty]"}); interval-1.4.1/inst/ctc_intersect.m0000644000000000000000000000756712657475772015520 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding utf-8 ## @defun ctc_intersect (@var{C1}, @var{Y1}, @var{C2}, @var{Y2}) ## @defunx ctc_intersect (@var{C1}, @var{C2}) ## ## Return a contractor function for the intersection of two sets. ## ## Functions @var{C1} and @var{C2} define two sets @code{S1 = @{@var{x} | ## @var{C1} (@var{x}) ∈ @var{Y1}@}} and @code{S2 = @{@var{x} | ## @var{C2} (@var{x}) ∈ @var{Y2}@}}. The return value is a contractor function ## for the set @code{S1 ∩ S2 = @{@var{x} | @var{C1} (@var{x}) ∈ @var{Y1} and ## @var{C2} (@var{x}) ∈ @var{Y2}@}}. ## ## Parameters @var{C1} and @var{C2} must be function handles and must accept ## the same number of parameters. See @command{@@infsup/fsolve} for how to ## define contractor functions. The user manual also contains an example on ## how to use this function. ## ## Instead of solving @code{@var{C1} (@var{x}) ∈ @var{Y1}} and ## @code{@var{C2} (@var{x}) ∈ @var{Y2}} separately and then compute an ## intersection of the result, you can solve ## @code{ctc_intersect (@var{C1}, @var{Y1}, @var{C2}, @var{Y2}) = 0}. ## ## @seealso{@@infsup/fsolve, ctc_union} ## @end defun ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-12-20 function c = ctc_intersect (ctc1, y1, ctc2, y2) ## Reorder parameters switch (nargin) case 2 ctc2 = y1; y1 = y2 = 0; case 3 if (is_function_handle (y1)) y2 = ctc2; ctc2 = y1; y1 = 0; else y2 = 0; endif case 4 ... otherwise print_usage (); endswitch ## Check parameters if (not (isa (y1, "infsup"))) y1 = infsup (y1); endif if (not (isa (y2, "infsup"))) y2 = infsup (y2); endif if (not (is_function_handle (ctc1)) && not (ischar (ctc1))) error ("interval:InvalidOperand", ... "ctc_intersect: Parameter C1 is no function handle") endif if (not (is_function_handle (ctc2)) && not (ischar (ctc2))) error ("interval:InvalidOperand", ... "ctc_intersect: Parameter C2 is no function handle") endif c = @(varargin) ctc_intersect_eval (ctc1, y1, ctc2, y2, varargin{:}); endfunction function varargout = ctc_intersect_eval (ctc1, y1, ctc2, y2, varargin) y = varargin{1}; x = varargin(2 : end); ## Evaluate each contractor function fval_and_contractions1 = nthargout (1 : nargout, ctc1, y1, x{:}); fval_and_contractions2 = nthargout (1 : nargout, ctc2, y2, x{:}); ## Compute fval = y if either function value is inside of its constraints fval1 = fval_and_contractions1{1}; fval2 = fval_and_contractions2{1}; fval1 = y + y_dist (y1, fval1); fval2 = y + y_dist (y2, fval2); varargout{1} = union (fval1, fval2); ## Both contractors must produce a subset of y. varargout{1}(disjoint (fval1, y) | disjoint (fval2, y)) = infsup (); ## Combine the contractions for i = 2 : nargout varargout{i} = intersect (fval_and_contractions1{i}, ... fval_and_contractions2{i}); endfor endfunction function d = y_dist (y, fval) d = infsup (idist (y, fval), hdist (y, fval)); d(subset (fval, y) & not (isempty (fval))) = 0; if (columns (y) == 1) d = sum (d, 1); elseif (rows (y) == 1) d = sum (d, 2); else d = sum (sum (d)); endif endfunction interval-1.4.1/inst/ctc_union.m0000644000000000000000000001136112657475772014633 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding utf-8 ## @defun ctc_union (@var{C1}, @var{Y1}, @var{C2}, @var{Y2}) ## @defunx ctc_union (@var{C1}, @var{C2}) ## ## Return a contractor function for the union of two sets. ## ## Functions @var{C1} and @var{C2} define two sets @code{S1 = @{@var{x} | ## @var{C1} (@var{x}) ∈ @var{Y1}@}} and @code{S2 = @{@var{x} | ## @var{C2} (@var{x}) ∈ @var{Y2}@}}. The return value is a contractor function ## for the set @code{S1 ∪ S2 = @{@var{x} | @var{C1} (@var{x}) ∈ @var{Y1} or ## @var{C2} (@var{x}) ∈ @var{Y2}@}}. ## ## Parameters @var{C1} and @var{C2} must be function handles and must accept ## the same number of parameters. See @command{@@infsup/fsolve} for how to ## define contractor functions. The user manual also contains an example on ## how to use this function. ## ## Instead of solving @code{@var{C1} (@var{x}) ∈ @var{Y1}} and ## @code{@var{C2} (@var{x}) ∈ @var{Y2}} separately and then compute an union of ## the result, you can solve @code{ctc_union (@var{C1}, @var{Y1}, @var{C2}, ## @var{Y2}) = 0}. ## ## @seealso{@@infsup/fsolve, ctc_intersect} ## @end defun ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-12-20 function c = ctc_union (ctc1, y1, ctc2, y2) ## Reorder parameters switch (nargin) case 2 ctc2 = y1; y1 = y2 = 0; case 3 if (is_function_handle (y1)) y2 = ctc2; ctc2 = y1; y1 = 0; else y2 = 0; endif case 4 ... otherwise print_usage (); endswitch ## Check parameters if (not (isa (y1, "infsup"))) y1 = infsup (y1); endif if (not (isa (y2, "infsup"))) y2 = infsup (y2); endif if (not (is_function_handle (ctc1)) && not (ischar (ctc1))) error ("interval:InvalidOperand", ... "ctc_union: Parameter C1 is no function handle") endif if (not (is_function_handle (ctc2)) && not (ischar (ctc2))) error ("interval:InvalidOperand", ... "ctc_union: Parameter C2 is no function handle") endif c = @(varargin) ctc_union_eval (ctc1, y1, ctc2, y2, varargin{:}); endfunction function varargout = ctc_union_eval (ctc1, y1, ctc2, y2, varargin) y = varargin{1}; x = varargin(2 : end); ## Evaluate each contractor function fval_and_contractions1 = nthargout (1 : nargout, ctc1, y1, x{:}); fval_and_contractions2 = nthargout (1 : nargout, ctc2, y2, x{:}); ## Compute fval = y if either function value is inside of its constraints fval1 = fval_and_contractions1{1}; fval2 = fval_and_contractions2{1}; fval1 = y + y_dist (y1, fval1); fval2 = y + y_dist (y2, fval2); varargout{1} = union (fval1, fval2); ## It suffices, if one contractor is a subset of y. varargout{1}(fval1 == y | fval2 == y) = y; ## Unite the contractions for i = 2 : nargout varargout{i} = union (fval_and_contractions1{i}, ... fval_and_contractions2{i}); endfor endfunction function d = y_dist (y, fval) d = infsup (idist (y, fval), hdist (y, fval)); d(subset (fval, y) & not (isempty (fval))) = 0; if (columns (y) == 1) d = sum (d, 1); elseif (rows (y) == 1) d = sum (d, 2); else d = sum (sum (d)); endif endfunction %!function [fval, cx] = ctc_sin (y, x) %! fval = sin (x); %! y = intersect (y, fval); %! cx = sinrev (y, x); %!endfunction %!function [fval, cx] = ctc_cos (y, x) %! fval = cos (x); %! y = intersect (y, fval); %! cx = cosrev (y, x); %!endfunction %!shared c %! c = ctc_union (@ctc_sin, 0, @ctc_cos, 0); %!test %! x = infsup (0); %! y = infsup (0); %! [fval, cx] = c (y, x); %! assert (fval == 0); %! assert (cx == 0) %!test %! x = infsup ("pi") / 2; %! y = infsup (0); %! [fval, cx] = c (y, x); %! assert (fval == "[0, 1]"); %! assert (cx == x); %!test %! x = infsup ("pi") / 4; %! y = infsup (0); %! [fval, cx] = c (y, x); %! assert (fval > 0); %! assert (isempty (cx)); %!test %! x = infsup (0, eps); %! y = infsup (0); %! [fval, cx] = c (y, x); %! assert (fval == "[0, 1]"); %! assert (cx == 0); %!test %! x = infsup ("[0, pi]") / 2; %! y = infsup (0); %! [fval, cx] = c (y, x); %! assert (fval == "[0, 1]"); %! assert (cx == x); interval-1.4.1/inst/empty.m0000644000000000000000000000466712657475772014023 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defun empty () ## @defunx empty (@var{N}) ## @defunx empty (@var{N}, @var{M}) ## ## Return the empty interval. ## ## With additional parameters, create an interval vector/matrix, which ## comprises empty interval entries. ## ## The empty interval [Empty] contains no real numbers. All interval functions ## return an empty result if the input is either empty or outside of the ## function's domain. ## ## The empty interval carries the trivial @code{trv} decoration, which denotes ## that the empty interval cannot be the result of a function evaluation for ## a nonempty subset of its domain. ## ## Accuracy: The representation of the empty interval is exact. ## ## @example ## @group ## x = empty () ## @result{} x = [Empty]_trv ## inf (x) ## @result{} ans = Inf ## sup (x) ## @result{} ans = -Inf ## @end group ## @end example ## @seealso{@@infsup/isempty, entire} ## @end defun ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-27 function result = empty (varargin) switch nargin case 0 result = infsupdec (); case 1 result = infsupdec (inf (varargin {1}), -inf (varargin {1})); case 2 result = infsupdec (+inf (varargin {1}, varargin {2}), ... -inf (varargin {1}, varargin {2})); otherwise print_usage(); endswitch endfunction %!assert (inf (empty ()), inf); %!assert (sup (empty ()), -inf); %!assert (decorationpart (empty ()), {"trv"}); %!assert (inf (empty (5)), inf (5)); %!assert (sup (empty (5)), -inf (5)); %!assert (strcmp (decorationpart (empty (5)), "trv"), true (5)); %!assert (inf (empty (5, 6)), inf (5, 6)); %!assert (sup (empty (5, 6)), -inf (5, 6)); %!assert (strcmp (decorationpart (empty (5, 6)), "trv"), true (5, 6)); interval-1.4.1/inst/entire.m0000644000000000000000000000534712657475772014147 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defun entire () ## @defunx entire (@var{N}) ## @defunx entire (@var{N}, @var{M}) ## ## Return the entire set of real numbers. ## ## With additional parameters, create an interval vector/matrix, which ## comprises entire interval entries. ## ## The entire set of real numbers [Entire] is a closed interval. If used as ## an enclosure for a certain value, it represents a state of minimum ## constraints. An interval function which evaluates to [Entire] yields no ## information at all if no interval decoration is present. ## ## The special floating-point values -Inf and Inf represent boundaries of the ## entire set of real numbers. However, they are not members of the interval. ## ## The result of this function carries the defined and continuous @code{dac} ## decoration, which denotes that the interval is not bounded and therefore is ## no common interval. ## ## Accuracy: The representation of the entire set of real numbers is exact. ## ## @example ## @group ## x = entire () ## @result{} x = [Entire]_dac ## inf (x) ## @result{} ans = -Inf ## sup (x) ## @result{} ans = Inf ## @end group ## @end example ## @seealso{@@infsup/isentire, empty} ## @end defun ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-09-27 function result = entire (varargin) switch nargin case 0 result = infsupdec (-inf, inf); case 1 result = infsupdec (-inf (varargin {1}), inf (varargin {1})); case 2 result = infsupdec (-inf (varargin {1}, varargin {2}), ... +inf (varargin {1}, varargin {2})); otherwise print_usage(); endswitch endfunction %!assert (inf (entire ()), -inf); %!assert (sup (entire ()), inf); %!assert (decorationpart (entire ()), {"dac"}); %!assert (inf (entire (5)), -inf (5)); %!assert (sup (entire (5)), inf (5)); %!assert (strcmp (decorationpart (entire (5)), "dac"), true (5)); %!assert (inf (entire (5, 6)), -inf (5, 6)); %!assert (sup (entire (5, 6)), inf (5, 6)); %!assert (strcmp (decorationpart (entire (5, 6)), "dac"), true (5, 6)); interval-1.4.1/inst/exacttointerval.m0000644000000000000000000000560512657475772016072 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defun exacttointerval (@var{S}) ## @defunx exacttointerval (@var{L}, @var{U}) ## @defunx exacttointerval (@var{M}) ## ## Create a bare interval. Fail, if the interval cannot exactly represent the ## input. ## ## Typically, this function operates on interval literals @var{S}. It is also ## possible to pass lower and upper boundaries @var{L} and @var{U}, or create a ## point-interval with a midpoint @var{M}. ## ## All valid input formats of the @code{infsup} class constructor are allowed. ## If this function creates an interval matrix, all interval boundaries must be ## representable with binary64 numbers. ## ## Accuracy: The equation ## @code{@var{X} == exacttointerval (intervaltoexact (@var{X}))} holds for all ## intervals. ## ## @example ## @group ## w = exacttointerval ("[ ]") ## @result{} w = [Empty] ## x = exacttointerval ("[2, 3]") ## @result{} x = [2, 3] ## y = exacttointerval ("[,]") ## @result{} y = [Entire] ## z = exacttointerval ("[21e-1]") ## @print{} ??? exacttointerval: interval wouldn't be exact ## @end group ## @end example ## @seealso{@@infsup/intervaltoexact, @@infsup/infsup} ## @end defun ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-10-01 function result = exacttointerval (varargin) switch (nargin) case 0 [result, exactconversion] = infsup (); case 1 [result, exactconversion] = infsup (varargin {1}); case 2 [result, exactconversion] = infsup (varargin {1}, varargin {2}); otherwise print_usage (); return endswitch if (not (exactconversion)) error ("interval:UndefinedOperation", ... "exacttointerval: interval wouldn't be exact") endif endfunction %!assert (isempty (exacttointerval ("[Empty]"))); %!assert (isentire (exacttointerval ("[Entire]"))); %!test "common interval"; %! y = exacttointerval ("[0, 1]"); %! assert (inf (y), 0); %! assert (sup (y), 1); %!test "point interval"; %! y = exacttointerval ("[42]"); %! assert (inf (y), 42); %! assert (sup (y), 42); %!test "unbound interval"; %! y = exacttointerval ("[-4, Infinity]"); %! assert (inf (y), -4); %! assert (sup (y), inf); %!error exacttointerval ("[0, 0.1]"); %!error exacttointerval ("[1, 0]"); interval-1.4.1/inst/hull.m0000644000000000000000000001617612657475772013627 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defun hull (@var{X1}, @var{X2}, …) ## ## Create an interval enclosure for a list of parameters. ## ## Parameters can be simple numbers, intervals or interval literals as strings. ## Scalar values or scalar intervals do broadcast if combined with matrices or ## interval matrices. ## ## NaNs represent missing values and are treated like empty intervals. Inf and ## -Inf can be used to create unbound intervals, but note that these values ## will not be members of the interval. In particular, it is not possible to ## create an interval with @code{hull (inf)}. ## ## The result is equivalent to ## @code{union (infsupdec (@var{X1}), union (infsupdec (@var{X2}), …))}, but ## computed in a more efficient way. In contrast to the union function, this ## function is not considered a set operation and the result carries the best ## possible decoration, which is allowed by the input parameters. ## ## Warning: This function is not defined by IEEE Std 1788-2015 and shall not be ## confused with the standard's convexHull function, which is implemented by ## @code{union}. ## ## Accuracy: The result is a tight enclosure. ## ## @example ## @group ## hull (1, 4, 3, 2) ## @result{} ans = [1, 4]_com ## hull (empty, entire) ## @result{} ans = [Entire]_trv ## hull ("0.1", "pi", "e") ## @result{} ans ⊂ [0.099999, 3.1416]_com ## hull ("[0, 3]", "[4, 7]") ## @result{} ans = [0, 7]_com ## @end group ## @end example ## @seealso{@@infsupdec/union} ## @end defun ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-03-02 function result = hull (varargin) if (isempty (varargin)) result = infsupdec (); return endif l = u = cell (size (varargin)); ## Floating point numbers can be used without conversion floats = cellfun (@isfloat, varargin); l (floats) = u (floats) = varargin (floats); ## Convert everything else to interval, if necessary decoratedintervals = cellfun ("isclass", varargin, "infsupdec"); to_convert = not (decoratedintervals | floats); ## Use infsupdec constructor for conversion, because it can handle decorated ## interval literals. Also, it will trigger an interval:ImplicitPromote ## warning if necessary. varargin (to_convert) = cellfun (@infsupdec, varargin (to_convert), ... "UniformOutput", false ()); decoratedintervals = not (floats); nais = cellfun (@isnai, varargin (decoratedintervals)); if (any (nais)) ## Simply return first NaI result = varargin (decoratedintervals) {find (nais, 1)}; return endif ## Extract inf and sup matrices for remaining elements of l and u. l (decoratedintervals) = cellfun (@inf, varargin (decoratedintervals), ... "UniformOutput", false ()); u (decoratedintervals) = cellfun (@sup, varargin (decoratedintervals), ... "UniformOutput", false ()); ## Broadcast nonsingleton dimensions (otherwise cat would throw an error below) sizes1 = cellfun ("size", l, 1); sizes2 = cellfun ("size", l, 2); targetsize = [max(sizes1) max(sizes2)]; if ((targetsize (1) ~= 1 && min (sizes1 (sizes1 ~= 1)) ~= targetsize (1)) || (targetsize (2) ~= 1 && min (sizes2 (sizes2 ~= 1)) ~= targetsize (2))) error ("hull: dimension mismatch") endif if (any (targetsize ~= [1 1])) to_broadcast = sizes1 ~= targetsize (1) ... | sizes2 ~= targetsize (2); if (any (to_broadcast)) for i = find (to_broadcast) if (size (l {i}, 1) ~= targetsize (1)) ## Broadcast 1st dimension l {i} = l {i} (ones (targetsize (1), 1), :); u {i} = u {i} (ones (targetsize (1), 1), :); endif if (size (l {i}, 2) ~= targetsize (2)) ## Broadcast 2nd dimension l {i} = l {i} (:, ones (targetsize (2), 1)); u {i} = u {i} (:, ones (targetsize (2), 1)); endif endfor endif endif ## Compute min and max of inf and sup matrices, NaNs would be ignored and must ## be considered nans = false (targetsize); l = cat (3, l {:}); nans (any (isnan (l), 3)) = true; l = min (l, [], 3); u = cat (3, u {:}); nans (any (isnan (u), 3)) = true; u = max (u, [], 3); ## Compute best possible decoration dec = cell (targetsize); dec (:) = "com"; dec (not (isfinite (l) & isfinite (u))) = "dac"; dec (nans) = "trv"; ## Consider input decorations if (any (decoratedintervals)) dec = mindec (dec, cellfun (@decorationpart, ... varargin (decoratedintervals), ... "UniformOutput", false ())); endif result = infsupdec (l, u, dec); endfunction function decoration = mindec (decoration, decorations) ## Determine and apply the minimum decoration for i = 1 : length (decorations) if (iscell (decorations {i}) && not (isempty (decorations {i}))) otherdecoration = decorations {i} {1}; else otherdecoration = decorations {i}; endif ## Only check distinct elements for n = find (not (strcmp (decoration, decorations {i}))) (:)' if (iscell (decorations {i}) && not (isscalar (decorations {i}))) otherdecoration = decorations {i} {n}; else ## Scalars broadcast into the whole cell array. The value is set ## once before the inner for loop. endif ## Because of the simple propagation order com > dac > def > trv, we ## can use string comparison order. if (sign ((decoration {n}) - otherdecoration) * [4; 2; 1] < 0) decoration {n} = otherdecoration; endif endfor endfor endfunction %!assert (isnai (hull (nai))); %!assert (isempty (hull (nan))); %!assert (isequal (hull (2, nan, 3, 5), infsupdec (2, 5, "trv"))); %!xtest assert (isequal (hull ([1, 2, 3], [5; 0; 2]), infsupdec ([1, 2, 3; 0, 0, 0; 1, 2, 2], [5, 5, 5; 1, 2, 3; 2, 2, 3], "com"))); %!xtest assert (isequal (hull (magic (3), 10), infsupdec (magic (3), 10 (ones (3)), "com"))); %!xtest assert (isequal (hull (2, magic (3), [nan, 2, 3; nan, 1, 1; 99, 100, nan]), infsupdec ([2, 1, 2; 2, 1, 1; 2, 2, 2], [8, 2, 6; 3, 5, 7; 99, 100, 2], {"trv", "com", "com"; "trv", "com", "com"; "com", "com", "trv"}))); %!test "from the documentation string"; %! assert (isequal (hull (1, 2, 3, 4), infsupdec (1, 4, "com"))); %! assert (isequal (hull (empty, entire), infsupdec (-inf, inf, "trv"))); %! assert (isequal (hull ("0.1", "pi", "e"), infsupdec (0.1 - eps / 16, pi + eps * 2, "com"))); %! assert (isequal (hull ("[0, 3]", "[4, 7]"), infsupdec ("[0, 7]_com"))); interval-1.4.1/inst/interval_bitpack.m0000644000000000000000000000634312657475772016177 0ustar 00000000000000## Copyright 2014-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defun interval_bitpack (@var{X}) ## ## Decode an interval from its interchange format. ## ## The input must either be a matrix of n × 128 bits for n bare intervals, or a ## matrix of n × 136 bits for n decorated intervals. Bits are in increasing ## order. Byte order depends on the system's endianness. First 8 bytes are ## used for the lower interval boundary, next 8 bytes are used for the upper ## interval boundary, (optionally) last byte is used for the decoration. ## ## The result is a row vector of intervals. ## ## Accuracy: For all valid interchange encodings the following equation holds: ## @code{@var{X} == bitunpack (interval_bitpack (@var{X}))}. ## ## @seealso{@@infsup/bitunpack, @@infsupdec/bitunpack} ## @end defun ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2014-12-23 function result = interval_bitpack (x) if (nargin ~= 1) print_usage (); return endif if (not (islogical (x))) ## Built-in function bitpack will fail on other data types error ("interval:InvalidOperand", ... ['interval_bitpack: parameter must be a bool matrix, ' ... 'was: ' typeinfo(x)]) endif switch size (x, 2) case 128 # (inf, sup) l = bitpack (x (:, 1 : 64)' (:), 'double'); u = bitpack (x (:, 65 : 128)' (:), 'double'); result = infsup (l, u); case 136 # (inf, sup, dec) l = bitpack (x (:, 1 : 64)' (:), 'double'); u = bitpack (x (:, 65 : 128)' (:), 'double'); d = bitpack (x (:, 129 : 136)' (:), 'uint8'); dec = cell (size (x, 1), 1); dec (d == 4) = 'trv'; dec (d == 8) = 'def'; dec (d == 12) = 'dac'; dec (d == 16) = 'com'; result = infsupdec (l, u, dec); otherwise error ("interval:InvalidOperand", ... ['interval_bitpack: invalid bit-length, ' ... 'expected: 128 or 136, ' ... 'was: ' num2str(size (x, 2))]) endswitch endfunction %!test "bare"; %! littleendian = bitunpack (uint16 (1))(1); %! b = zeros (1, 128); %! if (littleendian) %! b([52, 63, 117, 127]) = 1; %! else %! b([7, 12, 71, 77]) = 1; %! endif %! decoded = interval_bitpack (logical (b)); %! assert (eq (decoded, infsup (3, 4))); %!test "decorated"; %! littleendian = bitunpack (uint16 (1))(1); %! b = zeros (1, 136); %! if (littleendian) %! b([52, 63, 117, 127, 133]) = 1; %! else %! b([7, 12, 71, 77, 133]) = 1; %! endif %! decoded = interval_bitpack (logical (b)); %! assert (eq (decoded, infsupdec (3, 4))); interval-1.4.1/inst/midrad.m0000644000000000000000000001220112657475772014104 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defun midrad (@var{M}, @var{R}) ## @defunx midrad (@var{M}) ## @defunx midrad () ## ## Create an interval enclosure for [@var{M}-@var{R}, @var{M}+@var{R}]. ## ## Without input parameters, return the empty interval. With only one input ## parameter, the radius @var{R} defaults to zero. ## ## Parameters can be simple numbers, intervals or interval literals as strings. ## Scalar values or scalar intervals do broadcast if combined with matrices or ## interval matrices. ## ## The result is not guaranteed to be tightest if parameters are given as ## strings. This is due to intermediate results. The infsupdec constructor ## with interval literals in uncertain form @code{m?ruE} can instead be used to ## create tight enclosures of decimal numbers with a radius. ## ## Accuracy: The result is an accurate enclosure. The result is tightest if ## @var{M} and @var{R} are floating-point numbers or intervals. ## ## @example ## @group ## midrad (42, 3) ## @result{} ans = [39, 45]_com ## midrad (0, inf) ## @result{} ans = [Entire]_dac ## midrad ("1.1", "0.1") ## @result{} ans ⊂ [0.99999, 1.2001]_com ## midrad ("25", "3/7") ## @result{} ans ⊂ [24.571, 25.429]_com ## @end group ## @end example ## @seealso{@@infsupdec/infsupdec, hull, @@infsupdec/mid, @@infsupdec/rad} ## @end defun ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-03-06 function result = midrad (m, r) switch nargin case 0 result = infsupdec (); case 1 result = infsupdec (m); case 2 if (isfloat (m) && isreal (m) && ... isfloat (r) && isreal (r)) ## Simple case: m and r are binary64 numbers l = mpfr_function_d ('minus', -inf, m, r); u = mpfr_function_d ('plus', +inf, m, r); emptyresult = r < 0 & true (size (m)); l (emptyresult) = inf; u (emptyresult) = -inf; result = infsupdec (l, u); else ## Complicated case: m and r are strings or other types m = infsupdec (m); if (isnai (m)) result = m; return endif if (not (isa (r, "infsup"))) ## [-inf, r] should make a valid interval, unless r == -inf ## Intersection with non-negative numbers ensures that we ## return [Empty] if r < 0. if (isfloat (r)) r (r == -inf) = nan; endif r = intersect (infsupdec (-inf, r), infsupdec (0, inf)); if (not (isnai (r))) ## Fix decoration r = newdec (intervalpart (r)); endif endif if (isa (r, "infsupdec")) if (isnai (r)) result = r; return endif dec_r = decorationpart (r); else dec_r = "com"; endif sup_r = sup (r); sup_r (sup_r < 0) = -inf; r = infsupdec (-sup_r, sup_r, dec_r); result = m + r; endif otherwise print_usage (); endswitch endfunction %!assert (isempty (midrad ())); %!assert (isempty (midrad (0, -inf))); %!assert (isempty (midrad (0, -.1))); %!assert (isempty (midrad (0, "-.1"))); %!assert (isempty (midrad (0, infsup("-.1")))); %!assert (isequal (midrad ("pi"), infsupdec ("pi"))); %!warning assert (isequal (midrad (infsup (2), 2), infsupdec (0, 4))); %!assert (isequal (midrad (2, infsup (2)), infsupdec (0, 4))); %!warning assert (isequal (midrad (infsup (2), infsup (2)), infsupdec (0, 4))); %!assert (isequal (midrad (2, infsupdec (2)), infsupdec (0, 4))); %!assert (isequal (midrad (infsupdec (2), 2), infsupdec (0, 4))); %!warning assert (isequal (midrad (infsup (2), infsupdec (2)), infsupdec (0, 4))); %!assert (isequal (midrad (infsupdec (2), infsup (2)), infsupdec (0, 4))); %!assert (isequal (midrad (infsupdec (2), infsupdec (2)), infsupdec (0, 4))); %!xtest assert (isequal (midrad (1, magic (3)), infsupdec ([-7, 0, -5; -2, -4, -6; -3, -8, -1], [9, 2, 7; 4, 6, 8; 5, 10, 3]))); %!xtest assert (isequal (midrad (magic (3), 1), infsupdec ([7, 0, 5; 2, 4, 6; 3, 8, 1], [9, 2, 7; 4, 6, 8; 5, 10, 3]))); %!test "from the documentation string"; %! assert (isequal (midrad (42, 3), infsupdec (39, 45))); %! assert (isequal (midrad (0, inf), entire ())); %! assert (isequal (midrad ("1.1", "0.1"), infsupdec (1 - eps, "1.2"))); interval-1.4.1/inst/nai.m0000644000000000000000000000351412657475772013422 0ustar 00000000000000## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## -*- texinfo -*- ## @documentencoding UTF-8 ## @defun nai () ## ## Return the ill-formed decorated interval, called NaI (Not an Interval). ## ## Ill-formed intervals are the result of an illegal interval creation, e.g. ## @code{[3, 2]}. They occur if the @code{infsupdec} constructor is called ## with an invalid input and survive through interval arithmetic computations. ## Boolean comparisons on NaIs return @code{false}, i.e. @code{[NaI] == [NaI]} ## is false. ## ## The interval part of NaI is undefined. The decoration part of NaI is ## @code{ill}. The size of NaI is one in each dimension. ## ## The infsup constructor will not produce NaIs, but an error instead. ## ## @example ## @group ## x = nai () ## @result{} x = [NaI] ## x + 42 ## @result{} ans = [NaI] ## @end group ## @end example ## @seealso{@@infsupdec/infsupdec} ## @end defun ## Author: Oliver Heimlich ## Keywords: interval ## Created: 2015-02-22 function result = nai () if (nargin ~= 0) print_usage (); return endif result = infsupdec ("[nai]"); endfunction %!assert (isnai (nai ())); %!error (nai (1)); %!error (intervalpart (nai ())); %!assert (decorationpart (nai ()), {"ill"}); interval-1.4.1/octave-interval.metainfo.xml0000644000000000000000000000760112657475772017147 0ustar 00000000000000 octave-interval www.octave.org-octave.desktop Interval Real-valued interval arithmetic Reellwertige Intervallarithmetik Arithmétique d'intervalles à valeurs réelles

The interval package for real-valued interval arithmetic allows one to evaluate functions over subsets of their domain. All results are verified, because interval computations automatically keep track of any errors.

These concepts can be used to handle uncertainties, estimate arithmetic errors and produce reliable results. Also it can be applied to computer-assisted proofs, constraint programming, and verified computing.

The implementation is based on interval boundaries represented by binary64 numbers and is conforming to IEEE Std 1788-2015, IEEE standard for interval arithmetic.

Das Intervall-Paket für rellwertige Intervallarithmetik kann Funktionen über Teilmengen ihres Definitionsbereichs auszuwerten. Alle Ergebnisse werden durch Rechnung mit Intervallschranken nachgewiesen, wobei sämtliche Fehler automatisch mitgeführt werden.

Mit diesen Konzepten lassen sich ungewisse Messwerte behandeln, arithmetische Fehler abschätzen und zuverlässige Ergebnisse erzeugen. Es kann auch für rechnergestützte Beweise, Constraintprogrammierung oder verifiziertes Rechnen angewandt werden.

Die Intervallschranken werden im Zahlenformat binary64 geführt und die Umsetzung ist standardkonform zu IEEE Std 1788-2015, dem IEEE-Standard für Intervallarithmetik.

Le paquet arithmétique d'intervalles à valeurs réelles permet d'évaluer des fonctions sur des sous-ensembles de leurs domaines. Tous les résultats sont garantis car les calculs par intervalles permettent un suivi automatique des erreurs.

Ces concepts peuvent être utilisés pour prendre en compte les incertitudes, estimer les erreurs arithmétiques, et générer des résultats fiables. Ils peuvent également être appliqués à des preuves assistées par ordinateur, à la programmation par contraintes et à des calculs garantis.

Cette implantation est basée sur des bornes d'intervalles sous forme de nombres réels 64 bits et se conforme au standard IEEE 1788-2015, standard IEEE pour l'arithmétique d'intervalles.

 interval arithmetic interval analysis interval computation parameter estimation rounding error measurement error numerical error scientific computing result verification verified result set arithmetic finite precision range interval tolerance uncertainty preimage constraint enclosure bisection http://octave.sourceforge.net/interval/ https://savannah.gnu.org/bugs/?group=octave FSFAP GPL-3.0+ Octave-Forge Community octave-maintainers@gnu.org interval-1.4.1/src/Makefile0000644000000000000000000000347112657475772013751 0ustar 00000000000000SHELL = /bin/sh ## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . OBJ = mpfr_function_d.oct \ mpfr_linspace_d.oct \ mpfr_matrix_mul_d.oct \ mpfr_matrix_sqr_d.oct \ mpfr_to_string_d.oct \ mpfr_vector_sum_d.oct \ mpfr_vector_dot_d.oct \ __setround__.oct LDFLAGS_MPFR =-lmpfr ## Use important flags in XTRA_CFLAGS for OpenMP (workaround for bug #45280) CFLAG_OPENMP =$(findstring -fopenmp,$(shell $(MKOCTFILE) -p XTRA_CFLAGS)) all: $(OBJ) ## GNU MPFR api oct-files mpfr_matrix_mul_d.oct mpfr_matrix_sqr_d.oct : mpfr_%.oct: mpfr_%.cc mpfr_commons.cc $(MKOCTFILE) -o $@ $(LDFLAGS_MPFR) $(CFLAG_OPENMP) $< mpfr_%.oct: mpfr_%.cc mpfr_commons.cc $(MKOCTFILE) -o $@ $(LDFLAGS_MPFR) $< ## api oct-file ## ## Note to redistributors: ## If you can't compile this function for a particular platform ## or `test @infsup/mtimes` throws a warning in Octave, you can safely ## omit the __setround__ function from a redistributed binary package. ## However, please inform the package maintainer of the error. __setround__.oct: __setround__.cc $(MKOCTFILE) -o $@ $< interval-1.4.1/src/__setround__.cc0000644000000000000000000000516312657475772015257 0ustar 00000000000000/* Copyright 2015 Kai T. Ohlhus (Original version for C++11) Copyright 2015-2016 Oliver Heimlich (Compatibility with C99 and different parameter semantics for compatibility with the Octave fenv package) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ #include #include #pragma STDC FENV_ACCESS ON DEFUN_DLD (__setround__, args, nargout, "-*- texinfo -*-\n" "@defun __setround__ (@var{rnd})\n" "\n" "Changes the floating-point rounding direction for the current thread and " "any new threads which will be spawned from the current thread.\n" "\n" "@table @option\n" "@item @var{rnd} = -inf\n" "switch rounding downwards (towards -inf)\n" "@item @var{rnd} = 0.5\n" "switch rounding to nearest (default rounding mode)\n" "@item @var{rnd} = +inf\n" "switch rounding upwards (towards +inf)\n" "@end table\n" "@end defun" ) { const int nargin = args.length (); if (nargin != 1) { print_usage (); return octave_value_list (); } const double rnd = args(0).scalar_value (); int mode = 0; if (rnd == -INFINITY) mode = FE_DOWNWARD; else if (rnd == +INFINITY) mode = FE_UPWARD; else if (rnd == 0.5) mode = FE_TONEAREST; else // No other rounding modes might be supported // (depends on the C implementation) error ("__setround__: Unsupported rounding mode, please use -inf, +inf " "or 0.5"); if (error_state) return octave_value_list (); if (fesetround (mode) != 0) error ("__setround__: Unable to change rounding mode"); return octave_value_list (); } /* %!test %! __setround__ (+inf); %! assert (1 + realmin > 1, true); %! assert (1 - realmin == 1, true); %! __setround__ (0.5); %!test %! __setround__ (-inf); %! assert (1 + realmin == 1, true); %! assert (1 - realmin < 1, true); %! __setround__ (0.5); %!test %! __setround__ (0.5); %! assert (1 + realmin == 1, true); %! assert (1 - realmin == 1, true); %!shared %! __setround__ (0.5); */ interval-1.4.1/src/mpfr_commons.cc0000644000000000000000000001141712657475772015316 0ustar 00000000000000/* Copyright 2015-2016 Oliver Heimlich This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ #include #include #define BINARY64_PRECISION 53 #define BINARY64_ACCU_PRECISION 2134 + 2150 mpfr_rnd_t parse_rounding_mode (const double octave_rounding_direction) { // Use rounding mode semantics from the GNU Octave fenv package mpfr_rnd_t mp_rnd; if (octave_rounding_direction == INFINITY) mp_rnd = MPFR_RNDU; else if (octave_rounding_direction == -INFINITY) mp_rnd = MPFR_RNDD; else if (octave_rounding_direction == 0.0) mp_rnd = MPFR_RNDZ; else // default mode mp_rnd = MPFR_RNDN; return mp_rnd; } void exact_interval_dot_product ( mpfr_t accu_l, mpfr_t accu_u, // Add result into the accu const MArray vector_xl, // Lower boundary of first parameter const MArray vector_xu, // Upper boundary of first parameter const MArray vector_yl, // Lower boundary of second parameter const MArray vector_yu) // Upper boundary of second parameter { if (! vector_xl.is_vector () || ! vector_xu.is_vector () || ! vector_yl.is_vector () || ! vector_yu.is_vector ()) { error ("dot product can only be computed over vectors"); return; } const octave_idx_type n = vector_xl.numel (); if (n != vector_xu.numel () || n != vector_yl.numel () || n != vector_yu.numel ()) { error ("vectors must be of equal size"); return; } if (mpfr_cmp (accu_l, accu_u) > 0) // Accu is already [Empty] return; mpfr_t mp_addend_l, mp_addend_u, mp_temp; mpfr_init2 (mp_addend_l, 2 * BINARY64_PRECISION + 1); mpfr_init2 (mp_addend_u, 2 * BINARY64_PRECISION + 1); mpfr_init2 (mp_temp, 2 * BINARY64_PRECISION + 1); for (octave_idx_type i = 0; i < n; i++) { const double xl = vector_xl.elem (i); const double xu = vector_xu.elem (i); const double yl = vector_yl.elem (i); const double yu = vector_yu.elem (i); if ((xl == INFINITY && xu == -INFINITY) || (yl == INFINITY && yu == -INFINITY)) { // [Empty] × Anything = [Empty] // [Empty] + Anything = [Empty] mpfr_set_inf (accu_l, +1); mpfr_set_inf (accu_u, -1); break; } if (mpfr_inf_p (accu_l) != 0 && mpfr_inf_p (accu_u) != 0) // [Entire] + Anything = [Entire] continue; if ((xl == 0.0 && xu == 0.0) || (yl == 0.0 && yu == 0.0)) // [0] × Anything = [0] continue; if ((xl == -INFINITY && xu == INFINITY) || (yl == -INFINITY && yu == INFINITY)) { // [Entire] × Anything = [Entire] mpfr_set_inf (accu_l, -1); mpfr_set_inf (accu_u, +1); continue; } // Both factors can be multiplied within 107 bits exactly! mpfr_set_d (mp_addend_l, xl, MPFR_RNDZ); mpfr_mul_d (mp_addend_l, mp_addend_l, yl, MPFR_RNDZ); mpfr_set (mp_addend_u, mp_addend_l, MPFR_RNDZ); // We have to compute the remaining 3 Products and determine min/max if (yl != yu) { mpfr_set_d (mp_temp, xl, MPFR_RNDZ); mpfr_mul_d (mp_temp, mp_temp, yu, MPFR_RNDZ); mpfr_min (mp_addend_l, mp_addend_l, mp_temp, MPFR_RNDZ); mpfr_max (mp_addend_u, mp_addend_u, mp_temp, MPFR_RNDZ); } if (xl != xu) { mpfr_set_d (mp_temp, xu, MPFR_RNDZ); mpfr_mul_d (mp_temp, mp_temp, yl, MPFR_RNDZ); mpfr_min (mp_addend_l, mp_addend_l, mp_temp, MPFR_RNDZ); mpfr_max (mp_addend_u, mp_addend_u, mp_temp, MPFR_RNDZ); } if (xl != xu || yl != yu) { mpfr_set_d (mp_temp, xu, MPFR_RNDZ); mpfr_mul_d (mp_temp, mp_temp, yu, MPFR_RNDZ); mpfr_min (mp_addend_l, mp_addend_l, mp_temp, MPFR_RNDZ); mpfr_max (mp_addend_u, mp_addend_u, mp_temp, MPFR_RNDZ); } // Compute sums if (mpfr_add (accu_l, accu_l, mp_addend_l, MPFR_RNDZ) != 0 || mpfr_add (accu_u, accu_u, mp_addend_u, MPFR_RNDZ) != 0) error ("failed to compute exact dot product"); } mpfr_clear (mp_addend_l); mpfr_clear (mp_addend_u); mpfr_clear (mp_temp); } interval-1.4.1/src/mpfr_function_d.cc0000644000000000000000000003777312657475772016010 0ustar 00000000000000/* Copyright 2015-2016 Oliver Heimlich This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ #include #include #include "mpfr_commons.cc" typedef int (*mpfr_unary_fun) (mpfr_t rop, const mpfr_t op, mpfr_rnd_t rnd); typedef int (*mpfr_binary_fun) (mpfr_t rop, const mpfr_t op1, const mpfr_t op2, mpfr_rnd_t rnd); typedef int (*mpfr_ternary_fun) (mpfr_t rop, const mpfr_t op1, const mpfr_t op2, const mpfr_t op3, mpfr_rnd_t rnd); // Evaluate an unary MPFR function on a binary64 matrix void evaluate ( Matrix &arg1, // Operand 1 and result const mpfr_rnd_t rnd, // Rounding direction const mpfr_unary_fun f) // The MPFR function to evaluate (element-wise) { mpfr_t mp; mpfr_init2 (mp, BINARY64_PRECISION); const octave_idx_type n = arg1.numel (); for (octave_idx_type i = 0; i < n; i ++) { mpfr_set_d (mp, arg1.elem (i), MPFR_RNDZ); (*f) (mp, mp, rnd); arg1.elem (i) = mpfr_get_d (mp, rnd); } mpfr_clear (mp); } // Evaluate a binary MPFR function on two binary64 matrices void evaluate ( Matrix &arg1, // Operand 1 and result const Matrix &arg2, // Operand 2 const mpfr_rnd_t rnd, // Rounding direction const mpfr_binary_fun f) // The MPFR function to evaluate (element-wise) { mpfr_t mp1, mp2; mpfr_init2 (mp1, BINARY64_PRECISION); mpfr_init2 (mp2, BINARY64_PRECISION); // arg1 shall contain the result and must be resized if (arg1.rows () == 1 && arg2.rows () != 1) arg1 = arg1.index (idx_vector (ColumnVector (arg2.rows (), 1.0)), idx_vector::colon); if (arg1.columns () == 1 && arg2.columns () != 1) arg1 = arg1.index (idx_vector::colon, idx_vector (RowVector (arg2.columns (), 1.0))); const octave_idx_type n = arg1.rows (); const octave_idx_type m = arg1.columns (); const bool broadcast_r = n != 1 && arg2.rows () == 1; const bool broadcast_c = m != 1 && arg2.columns () == 1; for (octave_idx_type i = 0; i < n; i ++) for (octave_idx_type j = 0; j < m; j ++) { mpfr_set_d (mp1, arg1.elem (i, j), MPFR_RNDZ); mpfr_set_d (mp2, (broadcast_r) ? ((broadcast_c) ? arg2.elem (0, 0) : arg2.elem (0, j)) : ((broadcast_c) ? arg2.elem (i, 0) : arg2.elem (i, j)) , MPFR_RNDZ); (*f) (mp1, mp1, mp2, rnd); arg1.elem (i, j) = mpfr_get_d (mp1, rnd); } mpfr_clear (mp1); mpfr_clear (mp2); } // Evaluate a ternary MPFR function on three binary64 matrices void evaluate ( Matrix &arg1, // Operand 1 and result const Matrix &arg2, // Operand 2 const Matrix &arg3, // Operand 3 const mpfr_rnd_t rnd, // Rounding direction const mpfr_ternary_fun f) // The MPFR function to evaluate (element-wise) { mpfr_t mp1, mp2, mp3; mpfr_init2 (mp1, BINARY64_PRECISION); mpfr_init2 (mp2, BINARY64_PRECISION); mpfr_init2 (mp3, BINARY64_PRECISION); bool scalar1 = arg1.numel () == 1; bool scalar2 = arg2.numel () == 1; bool scalar3 = arg3.numel () == 1; if (scalar1) { // arg1 shall contain the result and must possibly be resized if (!scalar2) { arg1 = Matrix (arg2.dims (), arg1.elem (0)); scalar1 = false; } else if (!scalar3) { arg1 = Matrix (arg3.dims (), arg1.elem (0)); scalar1 = false; } } const octave_idx_type n = std::max (std::max (arg1.numel (), arg2.numel ()), arg3.numel ()); for (octave_idx_type i = 0; i < n; i ++) { mpfr_set_d (mp1, arg1.elem (i), MPFR_RNDZ); mpfr_set_d (mp2, (scalar2) ? arg2.elem (0) // broadcast : arg2.elem (i), MPFR_RNDZ); mpfr_set_d (mp3, (scalar3) ? arg3.elem (0) // broadcast : arg3.elem (i), MPFR_RNDZ); (*f) (mp1, mp1, mp2, mp3, rnd); arg1.elem (i) = mpfr_get_d (mp1, rnd); } mpfr_clear (mp1); mpfr_clear (mp2); mpfr_clear (mp3); } // Evaluate nthroot void nthroot ( Matrix &arg1, // Operand 1 and result const uint64_t arg2, // Operand 2 const mpfr_rnd_t rnd) { mpfr_t mp; mpfr_init2 (mp, BINARY64_PRECISION); const octave_idx_type n = arg1.numel (); for (octave_idx_type i = 0; i < n; i ++) { mpfr_set_d (mp, arg1.elem (i), MPFR_RNDZ); mpfr_root (mp, mp, arg2, rnd); arg1.elem (i) = mpfr_get_d (mp, rnd); } mpfr_clear (mp); } // Evaluate factorial void factorial ( Matrix &result, // Result const uint64NDArray arg, // Operand const mpfr_rnd_t rnd) { mpfr_t mp; mpfr_init2 (mp, BINARY64_PRECISION); const octave_idx_type n = arg.numel (); for (octave_idx_type i = 0; i < n; i ++) { // Compilation on 32-bit systems produces ambiguity errors if the // type of arg.elem(i) is not defined explicitly const uint64_t current_arg = arg.elem (i); mpfr_fac_ui (mp, current_arg, rnd); result.elem (i) = mpfr_get_d (mp, rnd); } mpfr_clear (mp); } DEFUN_DLD (mpfr_function_d, args, nargout, "-*- texinfo -*-\n" "@documentencoding UTF-8\n" "@defun mpfr_function_d ('acos', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('acosh', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('asin', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('asinh', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('atan', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('atan2', @var{R}, @var{Y}, @var{X})\n" "@defunx mpfr_function_d ('atanh', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('cbrt', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('cos', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('cosh', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('cot', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('coth', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('csc', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('csch', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('dilog', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('ei', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('erf', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('erfc', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('exp', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('expm1', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('factorial', @var{R}, @var{N})\n" "@defunx mpfr_function_d ('fma', @var{R}, @var{X}, @var{Y}, @var{Z})\n" "@defunx mpfr_function_d ('gamma', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('gammaln', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('hypot', @var{R}, @var{X}, @var{Y})\n" "@defunx mpfr_function_d ('log', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('log2', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('log10', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('log1p', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('minus', @var{R}, @var{X}, @var{Y})\n" "@defunx mpfr_function_d ('nthroot', @var{R}, @var{X}, @var{N})\n" "@defunx mpfr_function_d ('plus', @var{R}, @var{X}, @var{Y})\n" "@defunx mpfr_function_d ('pow', @var{R}, @var{X}, @var{Y})\n" "@defunx mpfr_function_d ('pow2', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('pow10', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('psi', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('rdivide', @var{R}, @var{X}, @var{Y})\n" "@defunx mpfr_function_d ('realsqrt', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('rsqrt', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('sec', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('sech', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('sin', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('sinh', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('sinh', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('sinh', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('sqr', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('tan', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('tanh', @var{R}, @var{X})\n" "@defunx mpfr_function_d ('times', @var{R}, @var{X}, @var{Y})\n" "\n" "Evaluate a function in binary64 with correctly rounded result." "\n\n" "Parameter 1 is the function's name in GNU Octave, Parameter 2 is the " "rounding direction (@option{0}: towards zero, @option{0.5}: towards " "nearest and ties to even, @option{+inf}: towards positive infinity, " "@option{-inf}: towards negative infinity). " "Parameters 3 and (possibly) 4 and 5 are operands to the function." "\n\n" "Evaluated on matrices, the function will be applied element-wise. Scalar " "operands do broadcast for functions with more than one operand." "\n\n" "The result is guaranteed to be correctly rounded. That is, the function " "is evaluated with (virtually) infinite precision and the exact result is " "approximated with a binary64 number using the desired rounding direction." "\n\n" "@example\n" "@group\n" "mpfr_function_d ('plus', -inf, 1, eps / 2) == 1\n" " @result{} 1\n" "mpfr_function_d ('plus', +inf, 1, eps / 2) == 1 + eps\n" " @result{} 1\n" "@end group\n" "@end example\n" "@seealso{fesetround}\n" "@end defun" ) { // Check call syntax int nargin = args.length (); if (nargin < 3 || nargin > 5) { print_usage (); return octave_value_list (); } // Read parameters const std::string function = args (0).string_value (); const mpfr_rnd_t rnd = parse_rounding_mode (args (1).scalar_value ()); Matrix arg1 = args (2).matrix_value (); Matrix arg2; Matrix arg3; if (nargin >= 4) { arg2 = args (3).matrix_value (); if (arg1.rows () != 1 && arg2.rows () != 1 && arg1.rows () != arg2.rows ()) error ("mpfr_function_d: Matrix dimensions must agree!"); if (arg1.columns () != 1 && arg2.columns () != 1 && arg1.columns () != arg2.columns ()) error ("mpfr_function_d: Matrix dimensions must agree!"); } if (nargin >= 5) { arg3 = args (4).matrix_value (); if (arg3.numel () != 1 && ( (arg1.numel () != 1 && arg1.numel () != arg3.numel ()) || (arg2.numel () != 1 && arg2.numel () != arg3.numel ()))) error ("mpfr_function_d: Matrix dimensions must agree!"); } if (error_state) return octave_value_list (); // Choose the function to evaluate switch (nargin - 2) { case 1: // unary function if (function == "acos") evaluate (arg1, rnd, &mpfr_acos); else if (function == "acosh") evaluate (arg1, rnd, &mpfr_acosh); else if (function == "asin") evaluate (arg1, rnd, &mpfr_asin); else if (function == "asinh") evaluate (arg1, rnd, &mpfr_asinh); else if (function == "atan") evaluate (arg1, rnd, &mpfr_atan); else if (function == "atanh") evaluate (arg1, rnd, &mpfr_atanh); else if (function == "cbrt") evaluate (arg1, rnd, &mpfr_cbrt); else if (function == "cos") evaluate (arg1, rnd, &mpfr_cos); else if (function == "cosh") evaluate (arg1, rnd, &mpfr_cosh); else if (function == "cot") evaluate (arg1, rnd, &mpfr_cot); else if (function == "coth") evaluate (arg1, rnd, &mpfr_coth); else if (function == "csc") evaluate (arg1, rnd, &mpfr_csc); else if (function == "csch") evaluate (arg1, rnd, &mpfr_csch); else if (function == "dilog") evaluate (arg1, rnd, &mpfr_li2); else if (function == "ei") evaluate (arg1, rnd, &mpfr_eint); else if (function == "erf") evaluate (arg1, rnd, &mpfr_erf); else if (function == "erfc") evaluate (arg1, rnd, &mpfr_erfc); else if (function == "exp") evaluate (arg1, rnd, &mpfr_exp); else if (function == "expm1") evaluate (arg1, rnd, &mpfr_expm1); else if (function == "factorial") { const uint64NDArray argInt = args (2).uint64_array_value (); if (error_state) return octave_value_list (); factorial (arg1, argInt, rnd); } else if (function == "gamma") evaluate (arg1, rnd, &mpfr_gamma); else if (function == "gammaln") evaluate (arg1, rnd, &mpfr_lngamma); else if (function == "log") evaluate (arg1, rnd, &mpfr_log); else if (function == "log2") evaluate (arg1, rnd, &mpfr_log2); else if (function == "log10") evaluate (arg1, rnd, &mpfr_log10); else if (function == "log1p") evaluate (arg1, rnd, &mpfr_log1p); else if (function == "pow2") evaluate (arg1, rnd, &mpfr_exp2); else if (function == "pow10") evaluate (arg1, rnd, &mpfr_exp10); else if (function == "psi") evaluate (arg1, rnd, &mpfr_digamma); else if (function == "realsqrt") evaluate (arg1, rnd, &mpfr_sqrt); else if (function == "rsqrt") evaluate (arg1, rnd, &mpfr_rec_sqrt); else if (function == "sec") evaluate (arg1, rnd, &mpfr_sec); else if (function == "sech") evaluate (arg1, rnd, &mpfr_sech); else if (function == "sin") evaluate (arg1, rnd, &mpfr_sin); else if (function == "sinh") evaluate (arg1, rnd, &mpfr_sinh); else if (function == "sqr") evaluate (arg1, rnd, &mpfr_sqr); else if (function == "tan") evaluate (arg1, rnd, &mpfr_tan); else if (function == "tanh") evaluate (arg1, rnd, &mpfr_tanh); else { print_usage(); return octave_value_list (); } break; case 2: // binary function if (function == "atan2") evaluate (arg1, arg2, rnd, &mpfr_atan2); else if (function == "hypot") evaluate (arg1, arg2, rnd, &mpfr_hypot); else if (function == "minus") evaluate (arg1, arg2, rnd, &mpfr_sub); else if (function == "nthroot") { const uint64_t n = args (3).uint64_array_value ().elem (0); if (error_state) return octave_value_list (); nthroot (arg1, n, rnd); } else if (function == "plus") evaluate (arg1, arg2, rnd, &mpfr_add); else if (function == "pow") evaluate (arg1, arg2, rnd, &mpfr_pow); else if (function == "rdivide") evaluate (arg1, arg2, rnd, &mpfr_div); else if (function == "times") evaluate (arg1, arg2, rnd, &mpfr_mul); else { print_usage(); return octave_value_list (); } break; case 3: // ternary function if (function == "fma") evaluate (arg1, arg2, arg3, rnd, &mpfr_fma); else { print_usage(); return octave_value_list (); } break; } return octave_value (arg1); } /* %!assert (mpfr_function_d ('plus', 0, 2, 2), 4); %!assert (mpfr_function_d ('plus', -inf, 1, eps / 2), 1); %!assert (mpfr_function_d ('plus', +inf, 1, eps / 2), 1 + eps); %!error mpfr_function_d ('Krauskefarben', 0, 47, 11); */ interval-1.4.1/src/mpfr_linspace_d.cc0000644000000000000000000001024612657475772015743 0ustar 00000000000000/* Copyright 2015-2016 Oliver Heimlich This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ #include #include #include "mpfr_commons.cc" DEFUN_DLD (mpfr_linspace_d, args, nargout, "-*- texinfo -*-\n" "@documentencoding UTF-8\n" "@defun mpfr_linspace_d (@var{R}, @var{BASE}, @var{LIMIT}, @var{N})\n" "\n" "Return a row vector with @var{N} linearly spaced elements between " "@var{BASE} and @var{LIMIT}." "\n\n" "The result is rounded in the direction @var{R} (@option{+inf}: towards " "positive infinity, @option{-inf}: towards negative infinity)." "\n\n" "The result is not guaranteed to be correctly rounded, but should be within " "1 ULP of the correctly rounded result." "\n\n" "@example\n" "@group\n" "mpfr_linspace_d (-inf, 0, 10, 3)\n" " @result{} ans = \n" " 0 5 10\n" "@end group\n" "@end example\n" "@seealso{linspace}\n" "@end defun" ) { // Check call syntax int nargin = args.length (); if (nargin < 3 || nargin > 4) { print_usage (); return octave_value_list (); } const mpfr_rnd_t rnd = parse_rounding_mode (args(0).scalar_value ()); Matrix base = args(1).column_vector_value (); Matrix limit = args(2).column_vector_value (); int n; if (nargin < 4) n = 100; else n = args(3).int_value (); if (base.numel () != limit.numel () && base.numel () != 1 && limit.numel () != 1) error ("mpfr_linspace_d: vectors must be of equal length"); if (rnd != MPFR_RNDD && rnd != MPFR_RNDU) error ("mpfr_linspace_d: only directed rounding supported"); if (error_state) return octave_value_list (); // Result size n = std::max (n, 1); const int m = std::max (base.numel (), limit.numel ()); // helper variables const bool broadcast_base = base.numel () == 1; const bool broadcast_limit = limit.numel () == 1; const unsigned int n_1 = n - 1; // Initialize result and temporary variables Matrix result_d (m, n); mpfr_t tmp1, tmp2; mpfr_init2 (tmp1, 2 * BINARY64_PRECISION); mpfr_init2 (tmp2, 2 * BINARY64_PRECISION); mpfr_t mp_base, mp_limit; mpfr_init2 (mp_base, BINARY64_PRECISION); mpfr_init2 (mp_limit, BINARY64_PRECISION); for (octave_idx_type i = 0; i < m; i ++) if (n == 1) result_d.elem (i, 0) = broadcast_limit ? limit.elem (0) : limit.elem (i); else { mpfr_set_d (mp_base, broadcast_base ? base.elem (0) : base.elem (i), MPFR_RNDZ); mpfr_set_d (mp_limit, broadcast_limit ? limit.elem (0) : limit.elem (i), MPFR_RNDZ); for (unsigned int j = 0; j <= n_1; j ++) { if (j == 0 || mpfr_equal_p (mp_base, mp_limit)) result_d.elem (i, j) = mpfr_get_d (mp_base, MPFR_RNDZ); else if (j == n_1) result_d.elem (i, j) = mpfr_get_d (mp_limit, MPFR_RNDZ); else { mpfr_mul_ui (tmp1, mp_limit, j, MPFR_RNDZ); // exact mpfr_mul_ui (tmp2, mp_base, n_1 - j, MPFR_RNDZ); // exact mpfr_add (tmp1, tmp1, tmp2, rnd); // rounded mpfr_div_ui (tmp1, tmp1, n_1, rnd); // rounded result_d.elem (i, j) = mpfr_get_d (tmp1, rnd); } } } octave_value_list result; result(0) = result_d; // cleanup mpfr_clear (tmp1); mpfr_clear (tmp2); mpfr_clear (mp_base); mpfr_clear (mp_limit); return result; } /* %!assert (mpfr_linspace_d (-inf, 1, 10, 10), 1 : 10); %!assert (mpfr_linspace_d (inf, 1, 10, 8) - mpfr_linspace_d (-inf, 1, 10, 8), [0 2 2 4 4 4 8 0] .* eps); */ interval-1.4.1/src/mpfr_matrix_mul_d.cc0000644000000000000000000001117512657475772016330 0ustar 00000000000000/* Copyright 2015-2016 Oliver Heimlich This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ #include #include #include #include "mpfr_commons.cc" std::pair interval_matrix_mul ( const Matrix matrix_xl, const Matrix matrix_yl, const Matrix matrix_xu, const Matrix matrix_yu) { const octave_idx_type n = matrix_xl.rows (), m = matrix_yl.columns (), l = matrix_xl.columns (); if (l != matrix_yl.rows () || n != matrix_xu.rows () || m != matrix_yl.columns () || l != matrix_xu.columns () || l != matrix_yu.rows ()) error ("mpfr_matrix_mul_d: " "Matrix dimensions must agree"); Matrix result_l (dim_vector (n, m)); Matrix result_u (dim_vector (n, m)); // Instead of two nested loops (for row = 1 : n / for col = 1 : m), we use // a single loop, which can be parallelized more easily. OCTAVE_OMP_PRAGMA (omp parallel for) for (octave_idx_type i = 0; i < n * m; i++) { mpfr_t accu_l, accu_u; mpfr_init2 (accu_l, BINARY64_ACCU_PRECISION); mpfr_init2 (accu_u, BINARY64_ACCU_PRECISION); mpfr_set_zero (accu_l, 0); mpfr_set_zero (accu_u, 0); const octave_idx_type row = i % n; const octave_idx_type col = i / n; RowVector xl; RowVector xu; ColumnVector yl; ColumnVector yu; OCTAVE_OMP_PRAGMA (omp critical) { // Access to shared memory is critical xl = matrix_xl.row (row); xu = matrix_xu.row (row); yl = matrix_yl.column (col); yu = matrix_yu.column (col); } exact_interval_dot_product (accu_l, accu_u, xl, xu, yl, yu); const double accu_l_d = mpfr_get_d (accu_l, MPFR_RNDD); const double accu_u_d = mpfr_get_d (accu_u, MPFR_RNDU); OCTAVE_OMP_PRAGMA (omp critical) { // Access to shared memory is critical result_l.elem (row, col) = accu_l_d; result_u.elem (row, col) = accu_u_d; } mpfr_clear (accu_l); mpfr_clear (accu_u); } std::pair result (result_l, result_u); return result; } DEFUN_DLD (mpfr_matrix_mul_d, args, nargout, "-*- texinfo -*-\n" "@documentencoding UTF-8\n" "@deftypefun {[@var{L}, @var{U}] =} mpfr_matrix_mul_d (@var{XL}, @var{YL}, @var{XU}, @var{YU})\n" "\n" "Compute the matrix product with binary64 numbers and correctly rounded " "result." "\n\n" "Compute the lower and upper boundary of the matrix multiplication of " "interval matrices [@var{XL}, @var{XU}] and [@var{YL}, @var{YU}]." "\n\n" "The result is guaranteed to be tight. That is, the matrix product is " "evaluated with (virtually) infinite precision and the exact result is " "approximated with binary64 numbers using directed rounding." "\n\n" "@example\n" "@group\n" "m = magic (3);\n" "[l, u] = mpfr_matrix_mul_d (m, m', m + 1, m' + 1)\n" " @result{} l = \n" " 101 71 53\n" " 71 83 71\n" " 53 71 101\n" " u = \n" " 134 104 86\n" " 104 116 104\n" " 86 104 134\n" "@end group\n" "@end example\n" "@seealso{mtimes}\n" "@end deftypefun" ) { // Check call syntax int nargin = args.length (); if (nargin != 4) { print_usage (); return octave_value_list (); } Matrix matrix_xl = args (0).matrix_value (); Matrix matrix_yl = args (1).matrix_value (); Matrix matrix_xu = args (2).matrix_value (); Matrix matrix_yu = args (3).matrix_value (); if (error_state) return octave_value_list (); std::pair result_d = interval_matrix_mul (matrix_xl, matrix_yl, matrix_xu, matrix_yu); octave_value_list result; result (0) = result_d.first; result (1) = result_d.second; return result; } /* %!test; %! [l, u] = mpfr_matrix_mul_d (magic (3), magic (3)', magic (3) + 1, magic (3)' + 1); %! assert (l, [101, 71, 53; 71, 83, 71; 53, 71, 101]); %! assert (u, [134, 104, 86; 104, 116, 104; 86, 104, 134]); */ interval-1.4.1/src/mpfr_matrix_sqr_d.cc0000644000000000000000000003264112657475772016341 0ustar 00000000000000/* Copyright 2016 Oliver Heimlich This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ #include #include #include #include "mpfr_commons.cc" std::pair interval_matrix_sqr ( const Matrix matrix_xl, const Matrix matrix_xu) { const octave_idx_type n = matrix_xl.rows (); if (n != matrix_xl.columns ()) { error ("mpfr_matrix_sqr_d: Matrix must be square"); return std::pair (Matrix (), Matrix ()); } Matrix result_l (dim_vector (n, n)); Matrix result_u (dim_vector (n, n)); OCTAVE_OMP_PRAGMA (omp parallel for) for (octave_idx_type i = 0; i < n; i++) { mpfr_t accu_l, accu_u; mpfr_t mp_temp1, mp_temp2; mpfr_init2 (accu_l, BINARY64_ACCU_PRECISION); mpfr_init2 (accu_u, BINARY64_ACCU_PRECISION); mpfr_init2 (mp_temp1, BINARY64_ACCU_PRECISION); mpfr_init2 (mp_temp2, BINARY64_ACCU_PRECISION); RowVector xl; RowVector xu; OCTAVE_OMP_PRAGMA (omp critical) { // Access to shared memory is critical xl = matrix_xl.row (i); xu = matrix_xu.row (i); } for (octave_idx_type j = 0; j < n; j++) { mpfr_set_zero (accu_l, 0); mpfr_set_zero (accu_u, 0); ColumnVector yl; ColumnVector yu; OCTAVE_OMP_PRAGMA (omp critical) { // Access to shared memory is critical yl = matrix_xl.column (j); yu = matrix_xu.column (j); } // Each entry of the result is defined as // result(i,j) = sum[k != i,j] x(i,k)*x(k,j) // + x(i,j)*(x(i,i), x(j,j)) for i != j // or // result(i,i) = sum[k != i] x(i,k)*x(k,i) // + x(i,i)^2 // // We compute result(i,:) by matrix multiplication of x(i,:) with y, // where y is a matrix made from x such that no entry of x // participates in each entry of the final result more than once. // For i != j // Combine x(i,j)*x(i,i) and x(j,j)*x(i,j) into // x(i,j)*(x(i,i)+x(j,j)), // where x(i,j) would appear twice and introduce dependency errors if (i != j) { // Compute x(i,j)*(x(i,i)+x(j,j)) in the accumulator exactly if ((xl.elem (i) == INFINITY && xu.elem (i) == -INFINITY) || (xl.elem (j) == INFINITY && xu.elem (j) == -INFINITY) || (yl.elem (j) == INFINITY && yu.elem (j) == -INFINITY)) { // [Empty] interval detected mpfr_set_inf (accu_l, +1); mpfr_set_inf (accu_u, -1); } else { // Part 1 // x(i,i) + x(j,j) mpfr_set_d (accu_l, xl.elem (i), MPFR_RNDD); mpfr_set_d (accu_u, xu.elem (i), MPFR_RNDU); mpfr_add_d (accu_l, accu_l, yl.elem (j), MPFR_RNDD); mpfr_add_d (accu_u, accu_u, yu.elem (j), MPFR_RNDU); // Part 2 // Multiply x(i,j) into the accumulator if ((xl.elem (j) == 0.0 && xu.elem (j) == 0.0) || (mpfr_zero_p (accu_l) && mpfr_zero_p (accu_u))) { // Multiplication with zero detected mpfr_set_zero (accu_l, 0); mpfr_set_zero (accu_u, 0); } else { if ((xl.elem (j) == -INFINITY && xu.elem (j) == INFINITY) || (mpfr_inf_p (accu_l) && mpfr_inf_p (accu_u))) { // Multiplication with [Entire] detected mpfr_set_inf (accu_l, -1); mpfr_set_inf (accu_u, +1); } else { if (mpfr_sgn (accu_l) >= 0) { if (xl.elem (j) >= 0.0) { // non-negative × non-negative mpfr_mul_d (accu_l, accu_l, xl.elem (j), MPFR_RNDD); mpfr_mul_d (accu_u, accu_u, xu.elem (j), MPFR_RNDU); } else if (xu.elem (j) <= 0.0) { // non-negative × non-positive mpfr_swap (accu_l, accu_u); mpfr_mul_d (accu_l, accu_l, xl.elem (j), MPFR_RNDD); mpfr_mul_d (accu_u, accu_u, xu.elem (j), MPFR_RNDU); } else { // non-negative × inner-zero mpfr_set (accu_l, accu_u, MPFR_RNDZ); mpfr_mul_d (accu_l, accu_l, xl.elem (j), MPFR_RNDD); mpfr_mul_d (accu_u, accu_u, xu.elem (j), MPFR_RNDU); } } else if (mpfr_sgn (accu_u) <= 0) { if (xl.elem (j) >= 0.0) { // non-positive × non-negative mpfr_mul_d (accu_l, accu_l, xu.elem (j), MPFR_RNDD); mpfr_mul_d (accu_u, accu_u, xl.elem (j), MPFR_RNDU); } else if (xu.elem (j) <= 0.0) { // non-positive × non-positive mpfr_swap (accu_l, accu_u); mpfr_mul_d (accu_l, accu_l, xu.elem (j), MPFR_RNDD); mpfr_mul_d (accu_u, accu_u, xl.elem (j), MPFR_RNDU); } else { // non-positive × inner-zero mpfr_set (accu_u, accu_l, MPFR_RNDZ); mpfr_mul_d (accu_l, accu_l, xu.elem (j), MPFR_RNDD); mpfr_mul_d (accu_u, accu_u, xl.elem (j), MPFR_RNDU); } } else { if (xl.elem (j) >= 0.0) { // inner-zero × non-negative mpfr_mul_d (accu_l, accu_l, xu.elem (j), MPFR_RNDD); mpfr_mul_d (accu_u, accu_u, xu.elem (j), MPFR_RNDU); } else if (xu.elem (j) <= 0.0) { // inner-zero × non-positive mpfr_mul_d (accu_l, accu_l, xl.elem (j), MPFR_RNDD); mpfr_mul_d (accu_u, accu_u, xl.elem (j), MPFR_RNDU); } else { // inner-zero × inner-zero // Lower bound mpfr_mul_d (mp_temp1, accu_l, xu.elem (j), MPFR_RNDD); mpfr_mul_d (mp_temp2, accu_u, xl.elem (j), MPFR_RNDD); mpfr_min (mp_temp1, mp_temp1, mp_temp2, MPFR_RNDD); mpfr_swap (accu_l, mp_temp1); // Upper bound mpfr_mul_d (mp_temp1, mp_temp1, xl.elem (j), MPFR_RNDU); mpfr_mul_d (mp_temp2, accu_u, xu.elem (j), MPFR_RNDU); mpfr_max (accu_u, mp_temp1, mp_temp2, MPFR_RNDU); } } } } } } // For i == j // Make sure that x(i,i)^2 can be computed error free as // x(i,i)*x(i,i) if (i == j) { if (xl.elem (i) < 0.0 && xu.elem (i) > 0.0) { yl.elem (i) = 0.0; yu.elem (i) = std::max (std::abs (xl.elem (i)), std::abs (xu.elem (i))); } exact_interval_dot_product (accu_l, accu_u, yl.extract_n (i, 1), yu.extract_n (i, 1), yl.extract_n (i, 1), yu.extract_n (i, 1)); } // Elements i and j have already been computed in the accumulator // Add remaining products for k != i, j to the accumulator yl.elem (i) = 0.0; yu.elem (i) = 0.0; yl.elem (j) = 0.0; yu.elem (j) = 0.0; exact_interval_dot_product (accu_l, accu_u, xl, xu, yl, yu); const double accu_l_d = mpfr_get_d (accu_l, MPFR_RNDD); const double accu_u_d = mpfr_get_d (accu_u, MPFR_RNDU); OCTAVE_OMP_PRAGMA (omp critical) { // Access to shared memory is critical result_l.elem (i, j) = accu_l_d; result_u.elem (i, j) = accu_u_d; } } mpfr_clear (accu_l); mpfr_clear (accu_u); mpfr_clear (mp_temp1); mpfr_clear (mp_temp2); } std::pair result (result_l, result_u); return result; } DEFUN_DLD (mpfr_matrix_sqr_d, args, nargout, "-*- texinfo -*-\n" "@documentencoding UTF-8\n" "@deftypefun {[@var{L}, @var{U}] =} mpfr_matrix_sqr_d (@var{XL}, @var{XU})\n" "\n" "Compute the lower and upper boundary of the matrix square of " "interval matrix [@var{XL}, @var{XU}]." "\n\n" "The result is guaranteed to be tight. That is, the matrix square is " "evaluated with (virtually) infinite precision and the exact result is " "approximated with binary64 numbers using directed rounding." "\n\n" "Unlike @code{@var{X} * @var{X}} this function avoids the dependency " "problem during computation and produces a better enclosure. The algorithm " "has been implemented after “Feasible algorithm for computing the square of " "an interval matrix” in O. Kosheleva, V. Kreinovich, G. Mayer, and " "H. T. Nguyen (2005): Computing the cube of an interval matrix is NP-hard. " "In SAC '05: Proc. of the 2005 ACM Symposium on Applied Computing, " "pages 1449–1453, 2005." "\n\n" "@example\n" "@group\n" "m = magic (3);\n" "[l, u] = mpfr_matrix_sqr_d (m, m + 1)\n" " @result{} l = \n" " 91 67 67\n" " 67 91 67\n" " 67 67 91\n" " u = \n" " 124 100 100\n" " 100 124 100\n" " 100 100 124\n" "@end group\n" "@end example\n" "@seealso{mpower}\n" "@end deftypefun" ) { // Check call syntax int nargin = args.length (); if (nargin != 2) { print_usage (); return octave_value_list (); } Matrix matrix_xl = args (0).matrix_value (); Matrix matrix_xu = args (1).matrix_value (); if (error_state) return octave_value_list (); std::pair result_d = interval_matrix_sqr (matrix_xl, matrix_xu); octave_value_list result; result (0) = result_d.first; result (1) = result_d.second; return result; } interval-1.4.1/src/mpfr_to_string_d.cc0000644000000000000000000001403112657475772016151 0ustar 00000000000000/* Copyright 2015-2016 Oliver Heimlich This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ #include #include #include #include #include #include #include "mpfr_commons.cc" std::string inttostring (const int number) { std::ostringstream buffer; buffer << number; return buffer.str (); } DEFUN_DLD (mpfr_to_string_d, args, nargout, "-*- texinfo -*-\n" "@documentencoding UTF-8\n" "@defun mpfr_to_string_d (@var{R}, @var{FORMAT}, @var{X})\n" "\n" "Convert binary64 numbers @var{X} to string representation, either exact or " "correctly rounded." "\n\n" "The result is a cell array of strings and, if not exact, is rounded in " "the direction @var{R} (@option{0}: towards zero, @option{0.5}: towards " "nearest and ties to even, @option{+inf}: towards positive infinity, " "@option{-inf}: towards negative infinity)." "\n\n" "The @var{FORMAT} may be one of the following:\n" "@table @option\n" "@item auto\n" "Varying mantissa length with 5 or 15 places, depending on the currently " "active @command{format}. It is also possible to define other values with " "the @command{output_precision} function.\n" "@item decimal\n" "Varying mantissa length with up to 16 or 17 places. This format will " "correctly separate subsequent numbers of binary64 precision with the least " "possible number of digits.\n" "@item exact decimal\n" "Varying mantissa length with up to 751 places.\n" "@item exact hexadecimal\n" "Mantissa with exactly 13 hexadecimal places.\n" "@end table" "\n\n" "@example\n" "@group\n" "mpfr_to_string_d (-inf, \"exact hexadecimal\", magic (3) / 10)\n" " @result{}\n" " @{\n" " [1,1] = 0XC.CCCCCCCCCCCD0P-4\n" " [2,1] = 0X4.CCCCCCCCCCCCCP-4\n" " [3,1] = 0X6.6666666666668P-4\n" " [1,2] = 0X1.999999999999AP-4\n" " [2,2] = 0X8.0000000000000P-4\n" " [3,2] = 0XE.6666666666668P-4\n" " [1,3] = 0X9.9999999999998P-4\n" " [2,3] = 0XB.3333333333330P-4\n" " [3,3] = 0X3.3333333333334P-4\n" " @}\n" "@end group\n" "@end example\n" "@end defun" ) { // Check call syntax int nargin = args.length (); if (nargin != 3) { print_usage (); return octave_value_list (); } const mpfr_rnd_t rnd = parse_rounding_mode (args (0).scalar_value ()); std::string format = args (1).string_value (); std::string str_template; // Switch to hexadecimal, if “format hex” is active if (format == "auto") // Maybe there is an easier way to find out whether format hex is active?! if (feval ("disp", octave_value_list(octave_value (octave_uint8(255))), 1) (0).string_value () == "ff\n") format = "exact hexadecimal"; // Switch the conversion template depending on the format if (format == "auto") { const int precision = feval ("output_precision")(0).scalar_value (); str_template = "%." + inttostring (precision) + "R*g"; } else if (format == "decimal") // This might be increased to 17 below, if 16 is not enough for the // particular number. str_template = "%.16R*g"; else if (format == "exact hexadecimal") str_template = "%.13R*A"; else if (format == "exact decimal") str_template = "%.751R*g"; else { error ("mpfr_to_string_d: Illegal format"); return octave_value_list (); } const Matrix x = args (2).matrix_value (); if (error_state) return octave_value_list (); char buf [768]; mpfr_t mp; mpfr_t zero; mpfr_init2 (mp, BINARY64_PRECISION); mpfr_init2 (zero, BINARY64_PRECISION); mpfr_set_zero (zero, 0); Cell str (dim_vector (x.rows (), x.cols ())); bool isexact = true; const mpfr_rnd_t complementary_rnd = (rnd == MPFR_RNDD) ? MPFR_RNDU : (rnd == MPFR_RNDU) ? MPFR_RNDD : (rnd == MPFR_RNDZ) ? MPFR_RNDA : (rnd == MPFR_RNDA) ? MPFR_RNDZ : MPFR_RNDN; const octave_idx_type n = x.numel (); for (octave_idx_type i = 0; i < n; i++) { mpfr_set_d (mp, x.elem (i), MPFR_RNDZ); mpfr_sprintf (buf, str_template.c_str (), rnd, mp); str.elem (i) = buf; if (format == "decimal") { if (x.elem (i) != 0.0) { // Precision 16 might not be enough mpfr_nexttoward (mp, zero); mpfr_sprintf (buf, str_template.c_str (), rnd, mp); mpfr_set_d (mp, x.elem (i), MPFR_RNDZ); if (str.elem (i).string_value () == buf) { // Increase precision to 17 mpfr_sprintf (buf, "%.17R*g", rnd, mp); str.elem (i) = buf; } } } // Check, whether output was exact if (isexact && nargout >=2 && format != "exact decimal" && format != "exact hexadecimal") { mpfr_sprintf (buf, str_template.c_str (), complementary_rnd, mp); if (str.elem (i).string_value () != buf) isexact = false; } } mpfr_clear (mp); mpfr_clear (zero); octave_value_list result; result (0) = str; result (1) = isexact; return result; } /* %!test; %! [s, isexact] = mpfr_to_string_d (-inf, "decimal", .1); %! assert (s, {"0.1"}); %! assert (isexact, false); */ interval-1.4.1/src/mpfr_vector_dot_d.cc0000644000000000000000000001647512657475772016327 0ustar 00000000000000/* Copyright 2015-2016 Oliver Heimlich This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ #include #include #include "mpfr_commons.cc" std::pair interval_vector_dot ( Matrix vector_xl, Matrix vector_yl, Matrix vector_xu, Matrix vector_yu) { if (vector_xl.numel () == 1 && vector_yl.numel () != 1) { // Broadcast vector x vector_xl = Matrix (vector_yl.dims (), vector_xl.elem (0)); vector_xu = Matrix (vector_yl.dims (), vector_xu.elem (0)); } else if (vector_yl.numel () == 1 && vector_xl.numel () != 1) { // Broadcast vector y vector_yl = Matrix (vector_xl.dims (), vector_yl.elem (0)); vector_yu = Matrix (vector_xl.dims (), vector_yu.elem (0)); } mpfr_t accu_l, accu_u; mpfr_init2 (accu_l, BINARY64_ACCU_PRECISION); mpfr_init2 (accu_u, BINARY64_ACCU_PRECISION); mpfr_set_zero (accu_l, 0); mpfr_set_zero (accu_u, 0); exact_interval_dot_product (accu_l, accu_u, vector_xl, vector_xu, vector_yl, vector_yu); std::pair result (mpfr_get_d (accu_l, MPFR_RNDD), mpfr_get_d (accu_u, MPFR_RNDU)); mpfr_clear (accu_l); mpfr_clear (accu_u); return result; } std::pair vector_dot ( mpfr_rnd_t rnd, Matrix vector_x, Matrix vector_y, const bool compute_error) { if (vector_x.numel () == 1 && vector_y.numel () != 1) // Broadcast vector x vector_x = Matrix (vector_y.dims (), vector_x.elem (0)); else if (vector_y.numel () == 1 && vector_x.numel () != 1) // Broadcast vector y vector_y = Matrix (vector_x.dims (), vector_y.elem (0)); const octave_idx_type n = vector_x.numel (); // Compute sum of products in accumulator // This is faster than the less accurate mpfr_sum function, because we // do not have to instantiate an array of mpfr_t values. mpfr_t accu; mpfr_init2 (accu, BINARY64_ACCU_PRECISION); mpfr_set_zero (accu, 0); mpfr_t product; mpfr_init2 (product, 2 * BINARY64_PRECISION + 1); for (octave_idx_type i = 0; i < n; i++) { mpfr_set_d (product, vector_x.elem (i), MPFR_RNDZ); mpfr_mul_d (product, product, vector_y.elem (i), MPFR_RNDZ); int exact = mpfr_add (accu, accu, product, MPFR_RNDZ); if (exact != 0) error ("mpfr_vector_dot_d: Failed to compute exact dot product"); if (mpfr_nan_p (accu)) // Short-Circtuit if one addend is NAN or if -INF + INF break; } double result; double error; if (mpfr_nan_p (accu) != 0) { result = NAN; error = NAN; } else if (mpfr_cmp_d (accu, 0.0) == 0) { // exact zero if (rnd == MPFR_RNDD) result = -0.0; else result = +0.0; error = 0.0; } else { result = mpfr_get_d (accu, rnd); if (compute_error) { mpfr_sub_d (accu, accu, result, MPFR_RNDA); error = mpfr_get_d (accu, MPFR_RNDA); } else error = 0.0; } mpfr_clear (accu); mpfr_clear (product); return std::pair (result, error); } DEFUN_DLD (mpfr_vector_dot_d, args, nargout, "-*- texinfo -*-\n" "@documentencoding UTF-8\n" "@deftypefun {[@var{L}, @var{U}] =} mpfr_vector_dot_d (@var{XL}, @var{YL}, @var{XU}, @var{YU})\n" "@deftypefunx {[@var{D}, @var{E}] =} mpfr_vector_dot_d (@var{R}, @var{X}, @var{Y})\n" "\n" "Compute the dot product of binary64 numbers with correctly rounded result." "\n\n" "Syntax 1: Compute the lower and upper boundary of the dot product of " "interval vectors [@var{XL}, @var{XU}] and [@var{YL}, @var{YU}] with " "tightest accuracy." "\n\n" "Syntax 2: Compute the dot product @var{D} of two binary64 vectors with " "correctly rounded result and rounding direction @var{R} (@option{0}: " "towards zero, @option{0.5}: towards nearest and ties to even, " "@option{+inf}: towards positive infinity, @option{-inf}: towards negative " "infinity). Output parameter @var{E} yields an approximation of the error, " "that is the difference between the exact dot product and @var{D} as a " "second binary64 number, rounded towards zero." "\n\n" "The result is guaranteed to be tight / correctly rounded. That is, the " "dot product is evaluated with (virtually) infinite precision and the exact " "result is approximated with a binary64 number using the desired rounding " "direction." "\n\n" "For syntax 2 only: If one element of any vector is NaN, infinities of " "both signs or a product of zero and (positive or negative) infinity are " "encountered, the result will be NaN. An @emph{exact} zero is returned as " "+0 in all rounding directions, except for rounding towards negative " "infinity, where -0 is returned." "\n\n" "@example\n" "@group\n" "[l, u] = mpfr_vector_dot_d (-1, -1, 2, 3)\n" " @result{}\n" " l = -3\n" " u = 6\n" "@end group\n" "@end example\n" "@seealso{dot}\n" "@end deftypefun" ) { // Check call syntax int nargin = args.length (); if (nargin < 3 || nargin > 4) { print_usage (); return octave_value_list (); } octave_value_list result; switch (nargin) { case 4: // Interval version { Matrix vector_xl = args (0).row_vector_value (); Matrix vector_yl = args (1).row_vector_value (); Matrix vector_xu = args (2).row_vector_value (); Matrix vector_yu = args (3).row_vector_value (); if (error_state) return octave_value_list (); std::pair result_d = interval_vector_dot (vector_xl, vector_yl, vector_xu, vector_yu); result (0) = result_d.first; result (1) = result_d.second; break; } case 3: // Non-interval version { const mpfr_rnd_t rnd = parse_rounding_mode (args (0).scalar_value()); const Matrix vector_x = args (1).row_vector_value (); const Matrix vector_y = args (2).row_vector_value (); if (error_state) return octave_value_list (); std::pair result_and_error = vector_dot (rnd, vector_x, vector_y, nargout >= 2); result (0) = result_and_error.first; result (1) = result_and_error.second; break; } } return result; } /* %!test; %! [l, u] = mpfr_vector_dot_d (-1, -1, 2, 3); %! assert (l, -3); %! assert (u, 6); %!test; %! x = [realmax, realmax, -realmax, -realmax, 1, eps/2]; %! y = ones (size (x)); %! [l, u] = mpfr_vector_dot_d (x, y, x, y); %! assert (l, 1); %! assert (u, 1 + eps); %!test; %! [l, u] = mpfr_vector_dot_d (0, 0, inf, inf); %! assert (l, 0); %! assert (u, inf); */ interval-1.4.1/src/mpfr_vector_sum_d.cc0000644000000000000000000001005512657475772016331 0ustar 00000000000000/* Copyright 2015-2016 Oliver Heimlich This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ #include #include #include "mpfr_commons.cc" DEFUN_DLD (mpfr_vector_sum_d, args, nargout, "-*- texinfo -*-\n" "@documentencoding UTF-8\n" "@deftypefun {[@var{S}, @var{E}] =} mpfr_vector_sum_d (@var{R}, @var{X})\n" "\n" "Compute the sum @var{S} of all numbers in a binary64 vector @var{X} with " "correctly rounded result." "\n\n" "@var{R} is the rounding direction (@option{0}: towards zero, @option{0.5}: " "towards nearest and ties to even, @option{+inf}: towards positive " "infinity, @option{-inf}: towards negative infinity)." "\n\n" "The result is guaranteed to be correctly rounded. That is, the sum is " "evaluated with (virtually) infinite precision and the exact result is " "approximated with a binary64 number using the desired rounding direction." "\n\n" "If one element of the vector is NaN or infinities of both signs are " "encountered, the result will be NaN. An @emph{exact} zero is returned as " "+0 in all rounding directions, except for rounding towards negative " "infinity, where -0 is returned." "\n\n" "A second output parameter yields an approximation of the error. The " "difference between the exact sum over @var{X} and @var{S} is approximated " "by a second binary64 number @var{E} with rounding towards zero." "\n\n" "@example\n" "@group\n" "mpfr_vector_sum_d (-inf, [1, eps/2, realmax, -realmax]) == 1\n" " @result{} 1\n" "mpfr_vector_sum_d (+inf, [1, eps/2, realmax, -realmax]) == 1 + eps\n" " @result{} 1\n" "@end group\n" "@end example\n" "@seealso{sum}\n" "@end deftypefun" ) { // Check call syntax int nargin = args.length (); if (nargin != 2) { print_usage (); return octave_value_list (); } // Read parameters const mpfr_rnd_t rnd = parse_rounding_mode (args (0).scalar_value ()); const Matrix vector = args (1).row_vector_value (); if (error_state) return octave_value_list (); const octave_idx_type n = vector.numel (); // Compute sum in accumulator // This is faster than the less accurate mpfr_sum function, because we // do not have to instantiate an array of mpfr_t values. mpfr_t accu; mpfr_init2 (accu, BINARY64_ACCU_PRECISION); mpfr_set_zero (accu, 0); for (octave_idx_type i = 0; i < n; i++) { int exact = mpfr_add_d (accu, accu, vector.elem (i), rnd); if (exact != 0) error ("mpfr_vector_sum_d: Failed to compute exact sum"); if (mpfr_nan_p (accu)) // Short-Circtuit if one addend is NAN or if -INF + INF break; } octave_value_list result; if (mpfr_nan_p (accu) != 0) { result (0) = NAN; result (1) = NAN; } else if (mpfr_cmp_d (accu, 0.0) == 0) { // exact zero if (rnd == MPFR_RNDD) result (0) = -0.0; else result (0) = +0.0; result (1) = 0.0; } else { const double sum = mpfr_get_d (accu, rnd); result (0) = sum; if (nargout >= 2) { mpfr_sub_d (accu, accu, sum, MPFR_RNDA); const double error = mpfr_get_d (accu, MPFR_RNDA); result (1) = error; } } mpfr_clear (accu); return result; } /* %!assert (mpfr_vector_sum_d (0, [eps, realmax, realmax, -realmax, -realmax]), eps) %!assert (mpfr_vector_sum_d (-inf, [eps/2, 1]), 1) %!assert (mpfr_vector_sum_d (+inf, [eps/2, 1]), 1 + eps) */ interval-1.4.1/test/abs_rev.itl0000644000000000000000000000364312657475772014635 0ustar 00000000000000/* Copyright 2015-2016 Oliver Heimlich This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ testcase minimal.absRevBin_test { absRevBin [empty] [entire] = [empty]; absRevBin [0.0, 1.0] [empty] = [empty]; absRevBin [0.0, 1.0] [7.0, 9.0] = [empty]; absRevBin [empty] [0.0, 1.0] = [empty]; absRevBin [-2.0, -1.0] [entire] = [empty]; absRevBin [1.0, 1.0] [entire] = [-1.0, 1.0]; absRevBin [0.0, 0.0] [entire] = [0.0, 0.0]; absRevBin [-1.0, -1.0] [entire] = [empty]; absRevBin [0x1.FFFFFFFFFFFFFp1023, 0x1.FFFFFFFFFFFFFp1023] [entire] = [-0x1.FFFFFFFFFFFFFp1023, 0x1.FFFFFFFFFFFFFp1023]; absRevBin [0x1p-1022, 0x1p-1022] [entire] = [-0x1p-1022, 0x1p-1022]; absRevBin [-0x1p-1022, -0x1p-1022] [entire] = [empty]; absRevBin [-0x1.FFFFFFFFFFFFFp1023, -0x1.FFFFFFFFFFFFFp1023] [entire] = [empty]; absRevBin [1.0, 2.0] [entire] = [-2.0, 2.0]; absRevBin [1.0, 2.0] [0.0, 2.0] = [1.0, 2.0]; absRevBin [0.0, 1.0] [-0.5, 2.0] = [-0.5, 1.0]; absRevBin [-1.0, 1.0] [entire] = [-1.0, 1.0]; absRevBin [-1.0, 0.0] [entire] = [0.0, 0.0]; absRevBin [0.0, infinity] [entire] = [entire]; absRevBin [entire] [entire] = [entire]; absRevBin [-infinity, 0.0] [entire] = [0.0, 0.0]; absRevBin [1.0, infinity] [-infinity, 0.0] = [-infinity, -1.0]; absRevBin [-1.0, infinity] [entire] = [entire]; absRevBin [-infinity, -1.0] [entire] = [empty]; absRevBin [-infinity, 1.0] [entire] = [-1.0, 1.0]; } interval-1.4.1/test/atan2.itl0000644000000000000000000000670212657475772014220 0ustar 00000000000000/* Copyright 2015-2016 Oliver Heimlich This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ testcase minimal.atan2_test { atan2 [empty] [empty] = [empty]; atan2 [empty] [entire] = [empty]; atan2 [entire] [empty] = [empty]; atan2 [0.0, 0.0] [0.0, 0.0] = [empty]; atan2 [entire] [entire] = [-0x1.921FB54442D19p1, +0x1.921FB54442D19p1]; atan2 [0.0, 0.0] [-infinity, 0.0] = [0x1.921FB54442D18p1, 0x1.921FB54442D19p1]; atan2 [0.0, 0.0] [0.0, infinity] = [0.0, 0.0]; atan2 [0.0, infinity] [0.0, 0.0] = [0x1.921FB54442D18p0, 0x1.921FB54442D19p0]; atan2 [-infinity, 0.0] [0.0, 0.0] = [-0x1.921FB54442D19p0, -0x1.921FB54442D18p0]; atan2 [-0x1p-1022, 0.0] [-0x1p-1022, -0x1p-1022] = [-0x1.921FB54442D19p1, +0x1.921FB54442D19p1]; atan2 [1.0, 1.0] [-1.0, -1.0] = [0x1.2D97C7F3321D2p1, 0x1.2D97C7F3321D3p1]; atan2 [1.0, 1.0] [1.0, 1.0] = [0x1.921FB54442D18p-1, 0x1.921FB54442D19p-1]; atan2 [-1.0, -1.0] [1.0, 1.0] = [-0x1.921FB54442D19p-1, -0x1.921FB54442D18p-1]; atan2 [-1.0, -1.0] [-1.0, -1.0] = [-0x1.2D97C7F3321D3p1, -0x1.2D97C7F3321D2p1]; atan2 [-0x1p-1022, 0x1p-1022] [-0x1p-1022, -0x1p-1022] = [-0x1.921FB54442D19p1, +0x1.921FB54442D19p1]; atan2 [-0x1p-1022, 0x1p-1022] [0x1p-1022, 0x1p-1022] = [-0x1.921FB54442D19p-1, +0x1.921FB54442D19p-1]; atan2 [-0x1p-1022, -0x1p-1022] [-0x1p-1022, 0x1p-1022] = [-0x1.2D97C7F3321D3p1, -0x1.921FB54442D18p-1]; atan2 [0x1p-1022, 0x1p-1022] [-0x1p-1022, 0x1p-1022] = [0x1.921FB54442D18p-1, 0x1.2D97C7F3321D3p1]; atan2 [-2.0, 2.0] [-3.0, -1.0] = [-0x1.921FB54442D19p1, +0x1.921FB54442D19p1]; atan2 [0.0, 2.0] [-3.0, -1.0] = [0x1.0468A8ACE4DF6p1, 0x1.921FB54442D19p1]; atan2 [1.0, 3.0] [-3.0, -1.0] = [0x1.E47DF3D0DD4Dp0, 0x1.68F095FDF593Dp1]; atan2 [1.0, 3.0] [-2.0, 0.0] = [0x1.921FB54442D18p0, 0x1.56C6E7397F5AFp1]; atan2 [1.0, 3.0] [-2.0, 2.0] = [0x1.DAC670561BB4Fp-2, 0x1.56C6E7397F5AFp1]; atan2 [1.0, 3.0] [0.0, 2.0] = [0x1.DAC670561BB4Fp-2, 0x1.921FB54442D19p0]; atan2 [1.0, 3.0] [1.0, 3.0] = [0x1.4978FA3269EE1p-2, 0x1.3FC176B7A856p0]; atan2 [0.0, 2.0] [1.0, 3.0] = [0x0p0, 0x1.1B6E192EBBE45p0]; atan2 [-2.0, 2.0] [1.0, 3.0] = [-0x1.1B6E192EBBE45p0, +0x1.1B6E192EBBE45p0]; atan2 [-2.0, 0.0] [1.0, 3.0] = [-0x1.1B6E192EBBE45p0, 0x0p0]; atan2 [-3.0, -1.0] [1.0, 3.0] = [-0x1.3FC176B7A856p0, -0x1.4978FA3269EE1p-2]; atan2 [-3.0, -1.0] [0.0, 2.0] = [-0x1.921FB54442D19p0, -0x1.DAC670561BB4Fp-2]; atan2 [-3.0, -1.0] [-2.0, 2.0] = [-0x1.56C6E7397F5AFp1, -0x1.DAC670561BB4Fp-2]; atan2 [-3.0, -1.0] [-2.0, 0.0] = [-0x1.56C6E7397F5AFp1, -0x1.921FB54442D18p0]; atan2 [-3.0, -1.0] [-3.0, -1.0] = [-0x1.68F095FDF593Dp1, -0x1.E47DF3D0DD4Dp0]; atan2 [-2.0, 0.0] [-3.0, -1.0] = [-0x1.921FB54442D19p1, +0x1.921FB54442D19p1]; atan2 [-5.0, 0.0] [-5.0, 0.0] = [-0x1.921FB54442D19p1, +0x1.921FB54442D19p1]; atan2 [0.0, 5.0] [-5.0, 0.0] = [0x1.921FB54442D18p0, 0x1.921FB54442D19p1]; atan2 [0.0, 5.0] [0.0, 5.0] = [0x0p0, 0x1.921FB54442D19p0]; atan2 [-5.0, 0.0] [0.0, 5.0] = [-0x1.921FB54442D19p0, 0x0p0]; } interval-1.4.1/test/c-xsc.itl0000644000000000000000000002174012657475772014227 0ustar 00000000000000/* Copyright 1990-2000 Institut fuer Angewandte Mathematik, Universitaet Karlsruhe, Germany 2000-2014 Wiss. Rechnen/Softwaretechnologie Universitaet Wuppertal, Germany Copyright 2015-2016 Oliver Heimlich Origin: unit tests in C-XSC version 2.5.4, Original license: LGPLv2+ Converted into portable ITL format by Oliver Heimlich. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ // Tests A+B, B+A, A-B, B-A, -A, +A testcase cxsc.intervaladdsub { add [10.0, 20.0] [13.0, 17.0] = [23.0, 37.0]; add [13.0, 17.0] [10.0, 20.0] = [23.0, 37.0]; sub [10.0, 20.0] [13.0, 16.0] = [-6.0, 7.0]; sub [13.0, 16.0] [10.0, 20.0] = [-7.0, 6.0]; neg [10.0, 20.0] = [-20.0, -10.0]; pos [10.0, 20.0] = [10.0, 20.0]; } // Tests A*B, B*A, A/B, B/A testcase cxsc.intervalmuldiv { mul [1.0, 2.0] [3.0, 4.0] = [3.0, 8.0]; mul [-1.0, 2.0] [3.0, 4.0] = [-4.0, 8.0]; mul [-2.0, 1.0] [3.0, 4.0] = [-8.0, 4.0]; mul [-2.0, -1.0] [3.0, 4.0] = [-8.0, -3.0]; mul [1.0, 2.0] [-3.0, 4.0] = [-6.0, 8.0]; mul [-1.0, 2.0] [-3.0, 4.0] = [-6.0, 8.0]; mul [-2.0, 1.0] [-3.0, 4.0] = [-8.0, 6.0]; mul [-2.0, -1.0] [-3.0, 4.0] = [-8.0, 6.0]; mul [1.0, 2.0] [-4.0, 3.0] = [-8.0, 6.0]; mul [-1.0, 2.0] [-4.0, 3.0] = [-8.0, 6.0]; mul [-2.0, 1.0] [-4.0, 3.0] = [-6.0, 8.0]; mul [-2.0, -1.0] [-4.0, 3.0] = [-6.0, 8.0]; mul [1.0, 2.0] [-4.0, -3.0] = [-8.0, -3.0]; mul [-1.0, 2.0] [-4.0, -3.0] = [-8.0, 4.0]; mul [-2.0, -1.0] [-4.0, -3.0] = [3.0, 8.0]; div [1.0, 2.0] [4.0, 8.0] = [0.125, 0.5]; div [-1.0, 2.0] [4.0, 8.0] = [-0.25, 0.5]; div [-2.0, 1.0] [4.0, 8.0] = [-0.5, 0.25]; div [-2.0, -1.0] [4.0, 8.0] = [-0.5, -0.125]; div [1.0, 2.0] [-4.0, 8.0] = [entire]; div [-1.0, 2.0] [-4.0, 8.0] = [entire]; div [-2.0, 1.0] [-4.0, 8.0] = [entire]; div [-2.0, -1.0] [-4.0, 8.0] = [entire]; div [1.0, 2.0] [-8.0, 4.0] = [entire]; div [-1.0, 2.0] [-8.0, 4.0] = [entire]; div [-2.0, 1.0] [-8.0, 4.0] = [entire]; div [-2.0, -1.0] [-8.0, 4.0] = [entire]; div [1.0, 2.0] [-8.0, -4.0] = [-0.5, -0.125]; div [-1.0, 2.0] [-8.0, -4.0] = [-0.5, 0.25]; div [-2.0, 1.0] [-8.0, -4.0] = [-0.25, 0.5]; div [-2.0, -1.0] [-8.0, -4.0] = [0.125, 0.5]; } // Tests A|B, B|A, A&B, B&A testcase cxsc.intervalsetops { convexHull [-2.0, 2.0] [-4.0, -3.0] = [-4.0, 2.0]; convexHull [-2.0, 2.0] [-4.0, -1.0] = [-4.0, 2.0]; convexHull [-2.0, 2.0] [-4.0, 4.0] = [-4.0, 4.0]; convexHull [-2.0, 2.0] [-1.0, 1.0] = [-2.0, 2.0]; convexHull [-2.0, 2.0] [1.0, 4.0] = [-2.0, 4.0]; convexHull [-2.0, 2.0] [3.0, 4.0] = [-2.0, 4.0]; convexHull [-4.0, -3.0] [-2.0, 2.0] = [-4.0, 2.0]; convexHull [-4.0, -1.0] [-2.0, 2.0] = [-4.0, 2.0]; convexHull [-4.0, 4.0] [-2.0, 2.0] = [-4.0, 4.0]; convexHull [-1.0, 1.0] [-2.0, 2.0] = [-2.0, 2.0]; convexHull [1.0, 4.0] [-2.0, 2.0] = [-2.0, 4.0]; convexHull [3.0, 4.0] [-2.0, 2.0] = [-2.0, 4.0]; intersection [-2.0, 2.0] [-4.0, -3.0] = [empty]; intersection [-2.0, 2.0] [-4.0, -1.0] = [-2.0, -1.0]; intersection [-2.0, 2.0] [-4.0, 4.0] = [-2.0, 2.0]; intersection [-2.0, 2.0] [-1.0, 1.0] = [-1.0, 1.0]; intersection [-2.0, 2.0] [1.0, 4.0] = [1.0, 2.0]; intersection [-2.0, 2.0] [3.0, 4.0] = [empty]; intersection [-4.0, -3.0] [-2.0, 2.0] = [empty]; intersection [-4.0, -1.0] [-2.0, 2.0] = [-2.0, -1.0]; intersection [-4.0, 4.0] [-2.0, 2.0] = [-2.0, 2.0]; intersection [-1.0, 1.0] [-2.0, 2.0] = [-1.0, 1.0]; intersection [1.0, 4.0] [-2.0, 2.0] = [1.0, 2.0]; intersection [3.0, 4.0] [-2.0, 2.0] = [empty]; } // Tests A|B, B|A, A&B, B&A, B is scalar-type testcase cxsc.intervalmixsetops { convexHull [-2.0, 2.0] [-4.0, -4.0] = [-4.0, 2.0]; convexHull [-2.0, 2.0] [1.0, 1.0] = [-2.0, 2.0]; convexHull [-2.0, 2.0] [4.0, 4.0] = [-2.0, 4.0]; convexHull [-4.0, -4.0] [-2.0, 2.0] = [-4.0, 2.0]; convexHull [1.0, 1.0] [-2.0, 2.0] = [-2.0, 2.0]; convexHull [4.0, 4.0] [-2.0, 2.0] = [-2.0, 4.0]; intersection [-2.0, 2.0] [-4.0, -4.0] = [empty]; intersection [-2.0, 2.0] [1.0, 1.0] = [1.0, 1.0]; intersection [-2.0, 2.0] [4.0, 4.0] = [empty]; intersection [-4.0, -4.0] [-2.0, 2.0] = [empty]; intersection [1.0, 1.0] [-2.0, 2.0] = [1.0, 1.0]; intersection [4.0, 4.0] [-2.0, 2.0] = [empty]; } // Tests A|B, B|A, A and B are scalar-type testcase cxsc.scalarmixsetops { convexHull [-2.0, -2.0] [-4.0, -4.0] = [-4.0, -2.0]; convexHull [-2.0, -2.0] [-2.0, -2.0] = [-2.0, -2.0]; convexHull [-2.0, -2.0] [2.0, 2.0] = [-2.0, 2.0]; convexHull [-4.0, -4.0] [-2.0, -2.0] = [-4.0, -2.0]; convexHull [-2.0, -2.0] [-2.0, -2.0] = [-2.0, -2.0]; convexHull [2.0, 2.0] [-2.0, -2.0] = [-2.0, 2.0]; } // Tests AB, A<=B, A>=B, A==B testcase cxsc.intervalsetcompops { interior [-1.0, 2.0] [-1.0, 2.0] = false; interior [-2.0, 1.0] [-3.0, 2.0] = true; interior [-2.0, 2.0] [-1.0, 1.0] = false; interior [-2.0, 2.0] [-1.0, 2.0] = false; interior [-2.0, 2.0] [-2.0, 1.0] = false; interior [-2.0, 2.0] [-2.0, 3.0] = false; interior [-2.0, 2.0] [-3.0, 2.0] = false; interior [-1.0, 2.0] [-1.0, 2.0] = false; interior [-3.0, 2.0] [-2.0, 1.0] = false; interior [-1.0, 1.0] [-2.0, 2.0] = true; interior [-1.0, 2.0] [-2.0, 2.0] = false; interior [-2.0, 1.0] [-2.0, 2.0] = false; interior [-2.0, 3.0] [-2.0, 2.0] = false; interior [-3.0, 2.0] [-2.0, 2.0] = false; subset [-1.0, 2.0] [-1.0, 2.0] = true; subset [-2.0, 1.0] [-3.0, 2.0] = true; subset [-2.0, 2.0] [-1.0, 1.0] = false; subset [-2.0, 2.0] [-1.0, 2.0] = false; subset [-2.0, 2.0] [-2.0, 1.0] = false; subset [-2.0, 2.0] [-2.0, 3.0] = true; subset [-2.0, 2.0] [-3.0, 2.0] = true; subset [-3.0, 2.0] [-2.0, 1.0] = false; subset [-1.0, 1.0] [-2.0, 2.0] = true; subset [-1.0, 2.0] [-2.0, 2.0] = true; subset [-2.0, 1.0] [-2.0, 2.0] = true; subset [-2.0, 3.0] [-2.0, 2.0] = false; subset [-3.0, 2.0] [-2.0, 2.0] = false; equal [-1.0, 2.0] [-1.0, 2.0] = true; equal [-2.0, 1.0] [-3.0, 2.0] = false; equal [-2.0, 2.0] [-1.0, 1.0] = false; equal [-2.0, 2.0] [-1.0, 2.0] = false; equal [-2.0, 2.0] [-2.0, 1.0] = false; equal [-2.0, 2.0] [-2.0, 3.0] = false; equal [-2.0, 2.0] [-3.0, 2.0] = false; } // Tests AB, A<=B, A>=B, A==B, BA, B<=A, B>=A, B==A, where B is scalar testcase cxsc.intervalscalarsetcompops { interior [-1.0, 2.0] [-2.0, -2.0] = false; interior [-2.0, 2.0] [-2.0, -2.0] = false; interior [-2.0, 2.0] [0.0, 0.0] = false; interior [-2.0, 2.0] [2.0, 2.0] = false; interior [-2.0, 2.0] [3.0, 3.0] = false; interior [-1.0, -1.0] [1.0, 1.0] = false; interior [-1.0, -1.0] [-1.0, -1.0] = false; interior [-2.0, -2.0] [-1.0, 2.0] = false; interior [-2.0, -2.0] [-2.0, 2.0] = false; interior [0.0, 0.0] [-2.0, 2.0] = true; interior [2.0, 2.0] [-2.0, 2.0] = false; interior [3.0, 3.0] [-2.0, 2.0] = false; interior [1.0, 1.0] [-1.0, -1.0] = false; interior [-1.0, -1.0] [-1.0, -1.0] = false; subset [-1.0, 2.0] [-2.0, -2.0] = false; subset [-2.0, 2.0] [-2.0, -2.0] = false; subset [-2.0, 2.0] [0.0, 0.0] = false; subset [-2.0, 2.0] [2.0, 2.0] = false; subset [-2.0, 2.0] [3.0, 3.0] = false; subset [-1.0, -1.0] [1.0, 1.0] = false; subset [-1.0, -1.0] [-1.0, -1.0] = true; subset [-2.0, -2.0] [-1.0, 2.0] = false; subset [-2.0, -2.0] [-2.0, 2.0] = true; subset [0.0, 0.0] [-2.0, 2.0] = true; subset [2.0, 2.0] [-2.0, 2.0] = true; subset [3.0, 3.0] [-2.0, 2.0] = false; subset [1.0, 1.0] [-1.0, -1.0] = false; subset [-1.0, -1.0] [-1.0, -1.0] = true; equal [-1.0, 2.0] [-2.0, -2.0] = false; equal [-2.0, 2.0] [-2.0, -2.0] = false; equal [-2.0, 2.0] [0.0, 0.0] = false; equal [-2.0, 2.0] [2.0, 2.0] = false; equal [-2.0, 2.0] [3.0, 3.0] = false; equal [-1.0, -1.0] [1.0, 1.0] = false; equal [-1.0, -1.0] [-1.0, -1.0] = true; } testcase cxsc.intervalstdfunc { sqr [11.0, 11.0] = [121.0, 121.0]; sqr [0.0, 0.0] = [0.0, 0.0]; sqr [-9.0, -9.0] = [81.0, 81.0]; sqrt [121.0, 121.0] = [11.0, 11.0]; sqrt [0.0, 0.0] = [0.0, 0.0]; sqrt [81.0, 81.0] = [9.0, 9.0]; rootn [27.0, 27.0] 3 = [3.0, 3.0]; rootn [0.0, 0.0] 4 = [0.0, 0.0]; rootn [1024.0, 1024.0] 10 = [2.0, 2.0]; pow [2.0, 2.0] [2.0, 2.0] = [4.0, 4.0]; pow [4.0, 4.0] [5.0, 5.0] = [1024.0, 1024.0]; // Negativ geht noch nicht pow [2.0, 2.0] [3.0, 3.0] = [8.0, 8.0]; }interval-1.4.1/test/fi_lib.itl0000644000000000000000000030725712657475772014450 0ustar 00000000000000/* Copyright 1997-2000 Institut fuer Wissenschaftliches Rechnen und Mathematische Modellbildung (IWRMM) and Institut fuer Angewandte Mathematik Universitaet Karlsruhe, Germany 2000-2005 Wiss. Rechnen/Softwaretechnologie Universitaet Wuppertal, Germany Copyright 2015-2016 Oliver Heimlich Original authors: Werner Hofschuster and Walter Kraemer (unit tests in FI_LIB version 1.2, original license: LGPLv2+) Converted into portable ITL format by Oliver Heimlich. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ testcase FI_LIB.addii { add [0X0.0000000000000P+0, 0X0.0000000000000P+0] [0X0.0000000000000P+0, 0X0.0000000000000P+0] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; add [0X1.0000000000000P+0, 0X1.0000000000000P+0] [0X2.0000000000000P+0, 0X2.0000000000000P+0] = [0X3.0000000000000P+0, 0X3.0000000000000P+0]; add [-0X1.0000000000000P+0, -0X1.0000000000000P+0] [-0X2.0000000000000P+0, -0X2.0000000000000P+0] = [-0X3.0000000000000P+0, -0X3.0000000000000P+0]; add [0X1.0000000000000P+0, 0X1.0000000000000P+0] [-0X1.0000000000000P+0, -0X1.0000000000000P+0] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; add [-0X1.0000000000000P+0, -0X1.0000000000000P+0] [0X1.0000000000000P+0, 0X1.0000000000000P+0] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; add [0X1.FA00000000000P-1064, 0X1.FA00000000000P-1064] [0X1.FA00000000000P-1064, 0X1.FA00000000000P-1064] = [0X3.F400000000000P-1064, 0X3.F400000000000P-1064]; add [0X1.FA00000000000P-1064, 0X1.FA00000000000P-1064] [0X1.0000000000000P+0, 0X1.0000000000000P+0] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; add [-0X1.FA00000000000P-1064, -0X1.FA00000000000P-1064] [-0X1.FA00000000000P-1064, -0X1.FA00000000000P-1064] = [-0X3.F400000000000P-1064, -0X3.F400000000000P-1064]; add [-0X1.FA00000000000P-1064, -0X1.FA00000000000P-1064] [0X1.0000000000000P+0, 0X1.0000000000000P+0] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; add [0XF.FFFFFFFFFFFF8P+1020, 0XF.FFFFFFFFFFFF8P+1020] [-0X1.0000000000000P+0, -0X1.0000000000000P+0] = [0XF.FFFFFFFFFFFF0P+1020, 0XF.FFFFFFFFFFFF8P+1020]; add [-0XF.FFFFFFFFFFFF8P+1020, -0XF.FFFFFFFFFFFF8P+1020] [0X1.0000000000000P+0, 0X1.0000000000000P+0] = [-0XF.FFFFFFFFFFFF8P+1020, -0XF.FFFFFFFFFFFF0P+1020]; add [0X0.0000000000000P+0, 0X1.0000000000000P+0] [0X1.0000000000000P+0, 0X2.0000000000000P+0] = [0X1.0000000000000P+0, 0X3.0000000000000P+0]; add [0X1.0000000000000P+0, 0X2.0000000000000P+0] [0X0.0000000000000P+0, 0X1.0000000000000P+0] = [0X1.0000000000000P+0, 0X3.0000000000000P+0]; add [0X1.0000000000000P+0, 0X2.0000000000000P+0] [0X3.0000000000000P+0, 0X4.0000000000000P+0] = [0X4.0000000000000P+0, 0X6.0000000000000P+0]; add [0X3.0000000000000P+0, 0X4.0000000000000P+0] [0X1.0000000000000P+0, 0X2.0000000000000P+0] = [0X4.0000000000000P+0, 0X6.0000000000000P+0]; add [-0X1.0000000000000P+0, 0X0.0000000000000P+0] [-0X4.0000000000000P+0, -0X3.0000000000000P+0] = [-0X5.0000000000000P+0, -0X3.0000000000000P+0]; add [-0X4.0000000000000P+0, -0X3.0000000000000P+0] [-0X1.0000000000000P+0, 0X0.0000000000000P+0] = [-0X5.0000000000000P+0, -0X3.0000000000000P+0]; add [-0X5.0000000000000P+0, -0X4.0000000000000P+0] [0X4.0000000000000P+0, 0X5.0000000000000P+0] = [-0X1.0000000000000P+0, +0X1.0000000000000P+0]; add [0X4.0000000000000P+0, 0X5.0000000000000P+0] [-0X5.0000000000000P+0, -0X4.0000000000000P+0] = [-0X1.0000000000000P+0, +0X1.0000000000000P+0]; } testcase FI_LIB.subii { sub [0X0.0000000000000P+0, 0X0.0000000000000P+0] [0X0.0000000000000P+0, 0X0.0000000000000P+0] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; sub [0X1.0000000000000P+0, 0X1.0000000000000P+0] [0X2.0000000000000P+0, 0X2.0000000000000P+0] = [-0X1.0000000000000P+0, -0X1.0000000000000P+0]; sub [-0X1.0000000000000P+0, -0X1.0000000000000P+0] [-0X2.0000000000000P+0, -0X2.0000000000000P+0] = [0X1.0000000000000P+0, 0X1.0000000000000P+0]; sub [0X1.0000000000000P+0, 0X1.0000000000000P+0] [-0X1.0000000000000P+0, -0X1.0000000000000P+0] = [0X2.0000000000000P+0, 0X2.0000000000000P+0]; sub [-0X1.0000000000000P+0, -0X1.0000000000000P+0] [0X1.0000000000000P+0, 0X1.0000000000000P+0] = [-0X2.0000000000000P+0, -0X2.0000000000000P+0]; sub [0X1.FA00000000000P-1064, 0X1.FA00000000000P-1064] [0X1.FA00000000000P-1064, 0X1.FA00000000000P-1064] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; sub [0X1.FA00000000000P-1064, 0X1.FA00000000000P-1064] [0X1.0000000000000P+0, 0X1.0000000000000P+0] = [-0X1.0000000000000P+0, -0XF.FFFFFFFFFFFF8P-4]; sub [-0X1.FA00000000000P-1064, -0X1.FA00000000000P-1064] [-0X1.FA00000000000P-1064, -0X1.FA00000000000P-1064] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; sub [-0X1.FA00000000000P-1064, -0X1.FA00000000000P-1064] [0X1.0000000000000P+0, 0X1.0000000000000P+0] = [-0X1.0000000000001P+0, -0X1.0000000000000P+0]; sub [0XF.FFFFFFFFFFFF8P+1020, 0XF.FFFFFFFFFFFF8P+1020] [0X1.0000000000000P+0, 0X1.0000000000000P+0] = [0XF.FFFFFFFFFFFF0P+1020, 0XF.FFFFFFFFFFFF8P+1020]; sub [-0XF.FFFFFFFFFFFF8P+1020, -0XF.FFFFFFFFFFFF8P+1020] [-0X1.0000000000000P+0, -0X1.0000000000000P+0] = [-0XF.FFFFFFFFFFFF8P+1020, -0XF.FFFFFFFFFFFF0P+1020]; sub [0X0.0000000000000P+0, 0X1.0000000000000P+0] [0X1.0000000000000P+0, 0X2.0000000000000P+0] = [-0X2.0000000000000P+0, 0X0.0000000000000P+0]; sub [0X1.0000000000000P+0, 0X2.0000000000000P+0] [0X0.0000000000000P+0, 0X1.0000000000000P+0] = [0X0.0000000000000P+0, 0X2.0000000000000P+0]; sub [0X1.0000000000000P+0, 0X2.0000000000000P+0] [0X3.0000000000000P+0, 0X4.0000000000000P+0] = [-0X3.0000000000000P+0, -0X1.0000000000000P+0]; sub [0X3.0000000000000P+0, 0X4.0000000000000P+0] [0X1.0000000000000P+0, 0X2.0000000000000P+0] = [0X1.0000000000000P+0, 0X3.0000000000000P+0]; sub [-0X1.0000000000000P+0, 0X0.0000000000000P+0] [-0X4.0000000000000P+0, -0X3.0000000000000P+0] = [0X2.0000000000000P+0, 0X4.0000000000000P+0]; sub [-0X4.0000000000000P+0, -0X3.0000000000000P+0] [-0X1.0000000000000P+0, 0X0.0000000000000P+0] = [-0X4.0000000000000P+0, -0X2.0000000000000P+0]; sub [-0X5.0000000000000P+0, -0X4.0000000000000P+0] [0X4.0000000000000P+0, 0X5.0000000000000P+0] = [-0XA.0000000000000P+0, -0X8.0000000000000P+0]; sub [0X4.0000000000000P+0, 0X5.0000000000000P+0] [-0X5.0000000000000P+0, -0X4.0000000000000P+0] = [0X8.0000000000000P+0, 0XA.0000000000000P+0]; } testcase FI_LIB.mulii { mul [0X0.0000000000000P+0, 0X0.0000000000000P+0] [0X0.0000000000000P+0, 0X0.0000000000000P+0] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; mul [-0X1.0000000000000P+0, -0X1.0000000000000P+0] [-0X1.0000000000000P+0, -0X1.0000000000000P+0] = [0X1.0000000000000P+0, 0X1.0000000000000P+0]; mul [-0X1.0000000000000P+0, -0X1.0000000000000P+0] [0X0.0000000000000P+0, 0X0.0000000000000P+0] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; mul [-0X1.0000000000000P+0, -0X1.0000000000000P+0] [0X1.0000000000000P+0, 0X1.0000000000000P+0] = [-0X1.0000000000000P+0, -0X1.0000000000000P+0]; mul [0X0.0000000000000P+0, 0X0.0000000000000P+0] [-0X1.0000000000000P+0, -0X1.0000000000000P+0] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; mul [0X0.0000000000000P+0, 0X0.0000000000000P+0] [0X1.0000000000000P+0, 0X1.0000000000000P+0] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; mul [0X1.0000000000000P+0, 0X1.0000000000000P+0] [-0X1.0000000000000P+0, -0X1.0000000000000P+0] = [-0X1.0000000000000P+0, -0X1.0000000000000P+0]; mul [0X1.0000000000000P+0, 0X1.0000000000000P+0] [0X0.0000000000000P+0, 0X0.0000000000000P+0] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; mul [0X1.0000000000000P+0, 0X1.0000000000000P+0] [0X1.0000000000000P+0, 0X1.0000000000000P+0] = [0X1.0000000000000P+0, 0X1.0000000000000P+0]; mul [0XF.FFFFFFFFFFFF8P+1020, 0XF.FFFFFFFFFFFF8P+1020] [0X8.0000000000000P-4, 0X8.0000000000000P-4] = [0X7.FFFFFFFFFFFFCP+1020, 0X7.FFFFFFFFFFFFCP+1020]; mul [-0XF.FFFFFFFFFFFF8P+1020, -0XF.FFFFFFFFFFFF8P+1020] [0X8.0000000000000P-4, 0X8.0000000000000P-4] = [-0X7.FFFFFFFFFFFFCP+1020, -0X7.FFFFFFFFFFFFCP+1020]; mul [0X1.FA00000000000P-1064, 0X1.FA00000000000P-1064] [0X1.FA00000000000P-1064, 0X1.FA00000000000P-1064] = [0X0.0000000000000P+0, 0X4.0000000000000P-1076]; mul [0X1.FA00000000000P-1064, 0X1.FA00000000000P-1064] [0X1.0000000000000P+0, 0X1.0000000000000P+0] = [0X1.FA00000000000P-1064, 0X1.FA00000000000P-1064]; mul [0X1.FA00000000000P-1064, 0X1.FA00000000000P-1064] [-0X1.0000000000000P+0, -0X1.0000000000000P+0] = [-0X1.FA00000000000P-1064, -0X1.FA00000000000P-1064]; mul [-0X3.0000000000000P+0, -0X2.0000000000000P+0] [-0X3.0000000000000P+0, -0X2.0000000000000P+0] = [0X4.0000000000000P+0, 0X9.0000000000000P+0]; mul [-0X3.0000000000000P+0, -0X2.0000000000000P+0] [-0X1.0000000000000P+0, +0X1.0000000000000P+0] = [-0X3.0000000000000P+0, +0X3.0000000000000P+0]; mul [-0X3.0000000000000P+0, -0X2.0000000000000P+0] [0X2.0000000000000P+0, 0X3.0000000000000P+0] = [-0X9.0000000000000P+0, -0X4.0000000000000P+0]; mul [-0X1.0000000000000P+0, +0X1.0000000000000P+0] [-0X3.0000000000000P+0, -0X2.0000000000000P+0] = [-0X3.0000000000000P+0, +0X3.0000000000000P+0]; mul [-0X1.0000000000000P+0, +0X1.0000000000000P+0] [-0X1.0000000000000P+0, +0X1.0000000000000P+0] = [-0X1.0000000000000P+0, +0X1.0000000000000P+0]; mul [-0X1.0000000000000P+0, +0X1.0000000000000P+0] [0X2.0000000000000P+0, 0X3.0000000000000P+0] = [-0X3.0000000000000P+0, +0X3.0000000000000P+0]; mul [0X2.0000000000000P+0, 0X3.0000000000000P+0] [-0X3.0000000000000P+0, -0X2.0000000000000P+0] = [-0X9.0000000000000P+0, -0X4.0000000000000P+0]; mul [0X2.0000000000000P+0, 0X3.0000000000000P+0] [-0X1.0000000000000P+0, +0X1.0000000000000P+0] = [-0X3.0000000000000P+0, +0X3.0000000000000P+0]; mul [0X2.0000000000000P+0, 0X3.0000000000000P+0] [0X2.0000000000000P+0, 0X3.0000000000000P+0] = [0X4.0000000000000P+0, 0X9.0000000000000P+0]; mul [-0X5.0000000000000P+0, +0X2.0000000000000P+0] [-0X4.0000000000000P+0, +0X3.0000000000000P+0] = [-0XF.0000000000000P+0, +0X1.4000000000000P+4]; mul [-0X5.0000000000000P+0, +0X2.0000000000000P+0] [-0X3.0000000000000P+0, +0X8.0000000000000P+0] = [-0X2.8000000000000P+4, +0X1.0000000000000P+4]; mul [-0X2.0000000000000P+0, +0X5.0000000000000P+0] [-0X4.0000000000000P+0, +0X3.0000000000000P+0] = [-0X1.4000000000000P+4, +0XF.0000000000000P+0]; mul [-0X4.0000000000000P+0, +0X5.0000000000000P+0] [-0X4.0000000000000P+0, +0X3.0000000000000P+0] = [-0X1.4000000000000P+4, +0X1.0000000000000P+4]; mul [-0X3.0000000000000P+0, 0X0.0000000000000P+0] [-0X3.0000000000000P+0, -0X2.0000000000000P+0] = [0X0.0000000000000P+0, 0X9.0000000000000P+0]; mul [-0X3.0000000000000P+0, 0X0.0000000000000P+0] [-0X1.0000000000000P+0, +0X1.0000000000000P+0] = [-0X3.0000000000000P+0, +0X3.0000000000000P+0]; mul [-0X3.0000000000000P+0, 0X0.0000000000000P+0] [0X2.0000000000000P+0, 0X3.0000000000000P+0] = [-0X9.0000000000000P+0, 0X0.0000000000000P+0]; mul [-0X3.0000000000000P+0, -0X2.0000000000000P+0] [-0X3.0000000000000P+0, 0X0.0000000000000P+0] = [0X0.0000000000000P+0, 0X9.0000000000000P+0]; mul [-0X3.0000000000000P+0, -0X2.0000000000000P+0] [0X0.0000000000000P+0, 0X3.0000000000000P+0] = [-0X9.0000000000000P+0, 0X0.0000000000000P+0]; mul [-0X1.0000000000000P+0, +0X1.0000000000000P+0] [-0X3.0000000000000P+0, 0X0.0000000000000P+0] = [-0X3.0000000000000P+0, +0X3.0000000000000P+0]; mul [-0X1.0000000000000P+0, +0X1.0000000000000P+0] [0X0.0000000000000P+0, 0X3.0000000000000P+0] = [-0X3.0000000000000P+0, +0X3.0000000000000P+0]; mul [0X0.0000000000000P+0, 0X3.0000000000000P+0] [-0X3.0000000000000P+0, -0X2.0000000000000P+0] = [-0X9.0000000000000P+0, 0X0.0000000000000P+0]; mul [0X0.0000000000000P+0, 0X3.0000000000000P+0] [-0X1.0000000000000P+0, +0X1.0000000000000P+0] = [-0X3.0000000000000P+0, +0X3.0000000000000P+0]; mul [0X0.0000000000000P+0, 0X3.0000000000000P+0] [0X2.0000000000000P+0, 0X3.0000000000000P+0] = [0X0.0000000000000P+0, 0X9.0000000000000P+0]; mul [0X2.0000000000000P+0, 0X3.0000000000000P+0] [-0X3.0000000000000P+0, 0X0.0000000000000P+0] = [-0X9.0000000000000P+0, 0X0.0000000000000P+0]; mul [0X2.0000000000000P+0, 0X3.0000000000000P+0] [-0X3.0000000000000P+0, 0X0.0000000000000P+0] = [-0X9.0000000000000P+0, 0X0.0000000000000P+0]; mul [0X0.0000000000000P+0, 0X2.0000000000000P+0] [-0X3.0000000000000P+0, 0X0.0000000000000P+0] = [-0X6.0000000000000P+0, 0X0.0000000000000P+0]; mul [-0X1.FA00000000000P-1064, -0X1.FA00000000000P-1064] [-0X1.FA00000000000P-1064, -0X1.FA00000000000P-1064] = [0X0.0000000000000P+0, 0X4.0000000000000P-1076]; mul [-0X1.FA00000000000P-1064, -0X1.FA00000000000P-1064] [0X1.0000000000000P+0, 0X1.0000000000000P+0] = [-0X1.FA00000000000P-1064, -0X1.FA00000000000P-1064]; mul [-0X1.FA00000000000P-1064, -0X1.FA00000000000P-1064] [-0X1.0000000000000P+0, -0X1.0000000000000P+0] = [0X1.FA00000000000P-1064, 0X1.FA00000000000P-1064]; mul [-0X1.FA00000000000P-1064, -0X1.FA00000000000P-1064] [0X1.FA00000000000P-1064, 0X1.FA00000000000P-1064] = [-0X4.0000000000000P-1076, 0X0.0000000000000P+0]; mul [-0X1.FA00000000000P-1064, -0X1.FA00000000000P-1064] [0X0.0000000000000P+0, 0X0.0000000000000P+0] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; mul [0X1.FA00000000000P-1064, 0X1.FA00000000000P-1064] [0X0.0000000000000P+0, 0X0.0000000000000P+0] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; } testcase FI_LIB.divii { div [-0X1.0000000000000P+0, -0X1.0000000000000P+0] [-0X1.0000000000000P+0, -0X1.0000000000000P+0] = [0X1.0000000000000P+0, 0X1.0000000000000P+0]; div [-0X1.0000000000000P+0, -0X1.0000000000000P+0] [0X1.0000000000000P+0, 0X1.0000000000000P+0] = [-0X1.0000000000000P+0, -0X1.0000000000000P+0]; div [0X0.0000000000000P+0, 0X0.0000000000000P+0] [-0X1.0000000000000P+0, -0X1.0000000000000P+0] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; div [0X0.0000000000000P+0, 0X0.0000000000000P+0] [0X1.0000000000000P+0, 0X1.0000000000000P+0] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; div [0X1.0000000000000P+0, 0X1.0000000000000P+0] [-0X1.0000000000000P+0, -0X1.0000000000000P+0] = [-0X1.0000000000000P+0, -0X1.0000000000000P+0]; div [0X1.0000000000000P+0, 0X1.0000000000000P+0] [0X1.0000000000000P+0, 0X1.0000000000000P+0] = [0X1.0000000000000P+0, 0X1.0000000000000P+0]; div [0XF.FFFFFFFFFFFF8P+1020, 0XF.FFFFFFFFFFFF8P+1020] [0X2.0000000000000P+0, 0X2.0000000000000P+0] = [0X7.FFFFFFFFFFFFCP+1020, 0X7.FFFFFFFFFFFFCP+1020]; div [-0XF.FFFFFFFFFFFF8P+1020, -0XF.FFFFFFFFFFFF8P+1020] [0X2.0000000000000P+0, 0X2.0000000000000P+0] = [-0X7.FFFFFFFFFFFFCP+1020, -0X7.FFFFFFFFFFFFCP+1020]; div [0X1.FA00000000000P-1064, 0X1.FA00000000000P-1064] [0X1.FA00000000000P-1064, 0X1.FA00000000000P-1064] = [0X1.0000000000000P+0, 0X1.0000000000000P+0]; div [0X1.FA00000000000P-1064, 0X1.FA00000000000P-1064] [0X1.0000000000000P+0, 0X1.0000000000000P+0] = [0X1.FA00000000000P-1064, 0X1.FA00000000000P-1064]; div [0X1.FA00000000000P-1064, 0X1.FA00000000000P-1064] [-0X1.0000000000000P+0, -0X1.0000000000000P+0] = [-0X1.FA00000000000P-1064, -0X1.FA00000000000P-1064]; div [-0X3.0000000000000P+0, -0X2.0000000000000P+0] [-0X3.0000000000000P+0, -0X2.0000000000000P+0] = [0XA.AAAAAAAAAAAA8P-4, 0X1.8000000000000P+0]; div [-0X3.0000000000000P+0, -0X2.0000000000000P+0] [0X2.0000000000000P+0, 0X3.0000000000000P+0] = [-0X1.8000000000000P+0, -0XA.AAAAAAAAAAAA8P-4]; div [-0X1.0000000000000P+0, +0X1.0000000000000P+0] [-0X3.0000000000000P+0, -0X2.0000000000000P+0] = [-0X8.0000000000000P-4, +0X8.0000000000000P-4]; div [-0X1.0000000000000P+0, +0X1.0000000000000P+0] [0X2.0000000000000P+0, 0X3.0000000000000P+0] = [-0X8.0000000000000P-4, +0X8.0000000000000P-4]; div [0X2.0000000000000P+0, 0X3.0000000000000P+0] [-0X3.0000000000000P+0, -0X2.0000000000000P+0] = [-0X1.8000000000000P+0, -0XA.AAAAAAAAAAAA8P-4]; div [0X2.0000000000000P+0, 0X3.0000000000000P+0] [0X2.0000000000000P+0, 0X3.0000000000000P+0] = [0XA.AAAAAAAAAAAA8P-4, 0X1.8000000000000P+0]; div [-0X3.0000000000000P+0, 0X0.0000000000000P+0] [-0X3.0000000000000P+0, -0X2.0000000000000P+0] = [0X0.0000000000000P+0, 0X1.8000000000000P+0]; div [-0X3.0000000000000P+0, 0X0.0000000000000P+0] [0X2.0000000000000P+0, 0X3.0000000000000P+0] = [-0X1.8000000000000P+0, 0X0.0000000000000P+0]; div [0X0.0000000000000P+0, 0X3.0000000000000P+0] [-0X3.0000000000000P+0, -0X2.0000000000000P+0] = [-0X1.8000000000000P+0, 0X0.0000000000000P+0]; div [0X0.0000000000000P+0, 0X3.0000000000000P+0] [0X2.0000000000000P+0, 0X3.0000000000000P+0] = [0X0.0000000000000P+0, 0X1.8000000000000P+0]; } testcase FI_LIB.unary_functions { exp [-0X1.16CC0DF1540F5P+112, -0X1.B3E4076622F04P-232] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; exp [-0X2.42042B9A88438P-220, -0X2.A213429DB0508P-508] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; exp [-0X2.0E2E40B15D814P+272, -0X1.5D74CFDA6B292P-200] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; exp [-0X2.0EA791886F712P-416, -0X3.FE66A8D1A3472P-456] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; //exp [-0X6.FF424CB26239CP+292, -0X2.89F6682121BA8P+252] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; exp [-0X8.80EEFDF700148P+332, -0X1.C4E85E50A626DP+0] = [0X0.0000000000000P+0, 0X2.BA43457B11D98P-4]; exp [-0X6.CA83546563A5CP+236, -0X4.F0F28370909FCP-440] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; exp [-0X4.E60572D4FCFD0P+172, -0X1.EB095183538C8P-344] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; exp [-0X2.7ED8954764B12P-288, -0X8.71DC22117BE90P-756] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; exp [-0XD.CF39B8DD68B98P-76, -0X8.0205C5B1357B0P-564] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; //exp [-0X1.582D3AFB2C63DP+312, -0X5.08DC843E57ED4P+180] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; exp [-0X4.AF296DD37FD74P+256, -0X5.CBE2BD423B02CP-48] = [0X0.0000000000000P+0, 0XF.FFFFFFFFFFA38P-4]; exp [-0X1.1FBA2D1252D2BP+656, -0X2.4B7A4095C91B4P+8] = [0X0.0000000000000P+0, 0X1.5D7A2F6655DFCP-848]; //exp [-0X3.2FD3FDE325402P+688, -0X2.738623C238270P+48] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; exp [-0X1.44F2134E1901EP+8, -0X2.581DAD9AFE6DCP-172] = [0X9.34C0766401B20P-472, 0X1.0000000000000P+0]; exp [-0X2.9529E333F2ABAP+988, -0X7.19390F862F49CP-544] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; exp [-0X1.58391FD92C387P-148, -0X4.0C12426A57194P-440] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; exp [-0XB.FADC4FB83E140P+348, -0XF.13E388B2165F0P-512] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; //exp [-0XD.F2552B8F60978P+236, -0X7.FBDBC320979A4P+188] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; exp [-0X8.86826CE1AB700P-240, -0X4.FEA8D3A3ED018P-316] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; exp [0X1.0000000000000P+0, 0X2.0000000000000P+0] = [0X2.B7E151628AED2P+0, 0X7.63992E35376B8P+0]; exp [-0X1.0000000000000P+0, +0X2.0000000000000P+0] = [0X5.E2D58D8B3BCDCP-4, 0X7.63992E35376B8P+0]; exp [-0X5.0000000000000P+0, -0X3.0000000000000P+0] = [0X1.B993FE00D5376P-8, 0XC.BED8666758578P-8]; exp [-0X2.0000000000000P+0, +0X9.9999999999998P-4] = [0X2.2A555477F0396P-4, 0X1.D27660B11A9F0P+0]; exp [0X4.0000000000000P-1076, 0X4.4444400000000P-1056] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; exp [0X4.4440000000000P-1064, 0X1.0000000000000P+0] = [0X1.0000000000000P+0, 0X2.B7E151628AED4P+0]; exp [-0X4.4444000000000P-1060, +0X4.4444000000000P-1060] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000001P+0]; exp [-0X4.4400000000000P-1068, +0X1.FFF0000000000P+0] = [0XF.FFFFFFFFFFFF8P-4, 0X7.6322F8540CFB4P+0]; exp [-0X1.FFFF000000000P+0, -0X8.8888880000000P-1052] = [0X2.2A577ECE59DC6P-4, 0X1.0000000000000P+0]; exp [-0X1.FFFFFFF000000P+0, +0X8.CD11555400000P-1044] = [0X2.2A55549A958EAP-4, 0X1.0000000000001P+0]; exp2 [-0X1.16CC0DF1540F5P+112, -0X1.B3E4076622F04P-232] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; exp2 [-0X2.42042B9A88438P-220, -0X2.A213429DB0508P-508] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; exp2 [-0X2.0E2E40B15D814P+272, -0X1.5D74CFDA6B292P-200] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; exp2 [-0X2.0EA791886F712P-416, -0X3.FE66A8D1A3472P-456] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; //exp2 [-0X6.FF424CB26239CP+292, -0X2.89F6682121BA8P+252] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; exp2 [-0X8.80EEFDF700148P+332, -0X1.C4E85E50A626DP+0] = [0X0.0000000000000P+0, 0X4.B1AC6F8470484P-4]; exp2 [-0X6.CA83546563A5CP+236, -0X4.F0F28370909FCP-440] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; exp2 [-0X4.E60572D4FCFD0P+172, -0X1.EB095183538C8P-344] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; exp2 [-0X2.7ED8954764B12P-288, -0X8.71DC22117BE90P-756] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; exp2 [-0XD.CF39B8DD68B98P-76, -0X8.0205C5B1357B0P-564] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; //exp2 [-0X1.582D3AFB2C63DP+312, -0X5.08DC843E57ED4P+180] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; exp2 [-0X4.AF296DD37FD74P+256, -0X5.CBE2BD423B02CP-48] = [0X0.0000000000000P+0, 0XF.FFFFFFFFFFC00P-4]; exp2 [-0X1.1FBA2D1252D2BP+656, -0X2.4B7A4095C91B4P+8] = [0X0.0000000000000P+0, 0X1.6FB78C613E5ECP-588]; //exp2 [-0X3.2FD3FDE325402P+688, -0X2.738623C238270P+48] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; exp2 [-0X1.44F2134E1901EP+8, -0X2.581DAD9AFE6DCP-172] = [0X8.4EB038B9B8508P-328, 0X1.0000000000000P+0]; exp2 [-0X2.9529E333F2ABAP+988, -0X7.19390F862F49CP-544] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; exp2 [-0X1.58391FD92C387P-148, -0X4.0C12426A57194P-440] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; exp2 [-0XB.FADC4FB83E140P+348, -0XF.13E388B2165F0P-512] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; //exp2 [-0XD.F2552B8F60978P+236, -0X7.FBDBC320979A4P+188] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; exp2 [-0X8.86826CE1AB700P-240, -0X4.FEA8D3A3ED018P-316] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; exp2 [0X1.0000000000000P+0, 0X2.0000000000000P+0] = [0X2.0000000000000P+0, 0X4.0000000000000P+0]; exp2 [-0X1.0000000000000P+0, +0X2.0000000000000P+0] = [0X8.0000000000000P-4, 0X4.0000000000000P+0]; exp2 [-0X5.0000000000000P+0, -0X3.0000000000000P+0] = [0X8.0000000000000P-8, 0X2.0000000000000P-4]; exp2 [-0X2.0000000000000P+0, +0X9.9999999999998P-4] = [0X4.0000000000000P-4, 0X1.8406003B2AE5DP+0]; exp2 [0X4.4400000000000P-1068, 0X4.48CD100000000P-1052] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; exp2 [-0X4.8D15088880000P-1040, +0X4.8D11554000000P-1048] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000001P+0]; exp2 [0XD.0888D11000000P-1044, 0X1.000003443AAAAP+0] = [0X1.0000000000000P+0, 0X2.0000048742860P+0]; exp2 [-0XD.15550CC880000P-1040, +0X4.8D150CC000000P-1048] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000001P+0]; exp2 [-0X4.8D159E0000000P-1048, +0X1.FFFFFF0999999P+0] = [0XF.FFFFFFFFFFFF8P-4, 0X3.FFFFFD54D58B0P+0]; exp2 [-0X1.FFFFFFFFFFFFFP+0, +0X1.14C8911540000P-1040] = [0X4.0000000000000P-4, 0X1.0000000000001P+0]; exp10 [-0X2.8457BC029986EP+112, -0X1.7A77BFCCF5A9EP-232] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; exp10 [-0X6.05C0BB1BCB730P-220, -0X3.C5EC30FBB68C8P-508] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; exp10 [-0X2.9B09919BF9D9EP+272, -0XE.20FF41BD18058P-204] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; exp10 [-0X1.1503444763FC5P-416, -0X2.075DF98B2478CP-456] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; //exp10 [-0X2.7C064F6929234P+292, -0X1.5444E676976F1P+252] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; exp10 [-0X4.ECBC855871080P+332, -0X1.3A01905E36F84P+0] = [0X0.0000000000000P+0, 0XF.317F8555628F0P-8]; exp10 [-0X7.32EDAB7F60A50P+236, -0X2.404E44C49C644P-440] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; exp10 [-0X6.5263CF84EF388P+172, -0X1.63A15E999EB64P-344] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; exp10 [-0X1.4171976A1CA54P-288, -0X6.941F470A70074P-756] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; exp10 [-0X4.69BB1D34B9570P-76, -0X7.78A1F475A306CP-564] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; //exp10 [-0X1.F0D19ADCB5D74P+312, -0X1.BA04D452BBB35P+180] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; exp10 [-0X2.E046DB554037CP+256, -0X2.6ABC15579B2B2P-48] = [0X0.0000000000000P+0, 0XF.FFFFFFFFFFA70P-4]; exp10 [-0XE.33C49CF5B8790P+652, -0X8.297A99ED9ED08P+8] = [0X0.0000000000000P+0, 0X4.0000000000000P-1076]; //exp10 [-0X2.A69A969772FDEP+688, -0X3.436DFE8F08194P+48] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; exp10 [-0X1.7AAA15EBBD3F2P+8, -0X6.3E590E626451CP-172] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; exp10 [-0X2.8F9204BC4041EP+988, -0X6.ACFA418D8F92CP-544] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; exp10 [-0X2.B00450A48D586P-148, -0X2.BB570B356C6CAP-440] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; exp10 [-0X1.9E7DDBBE00F75P+352, -0XC.41329461A0C30P-512] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; //exp10 [-0XD.5E2045CEE9720P+236, -0X6.6978492A3064CP+188] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; exp10 [-0X1.5BD629B25AA23P-236, -0X7.DEA605DEC97CCP-316] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; //exp10 [-0XB.A944253373080P+564, -0XD.05E9CCF66CF58P+424] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; exp10 [-0X3.AE1DC13A652CAP+168, -0X6.65D7E0A247778P-56] = [0X0.0000000000000P+0, 0XF.FFFFFFFFFFFF8P-4]; exp10 [-0XA.27B4555158148P-68, -0X5.2B55801231EC8P-344] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; exp10 [-0X1.D68A6BA7E617FP+12, -0X6.36B661DCE2688P-236] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; exp10 [-0X1.98EF0C6A8BD66P+132, -0X1.EB0E1AB78F314P-480] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; exp10 [-0X1.C08152CC09416P+220, -0X7.4CF193131FA64P-192] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; exp10 [-0X6.F70E0DA4D2BA0P-140, -0X1.7036C237D5B00P-672] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; //exp10 [-0XB.24D19E00C8460P+324, -0X1.D283CF8F05665P+252] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; exp10 [-0XF.CC937FA330E40P+648, -0X3.A0EE84451C92CP-324] = [0X0.0000000000000P+0, 0X1.0000000000000P+0]; exp10 [-0X5.F775993940188P-120, -0X1.8BCA641025A83P-124] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; log [0XC.4B4A6EB6B3AF0P-264, 0XA.DD2C4C1BE4B30P+92] = [-0XB.47B530A1054D8P+4, +0X4.227AD8183FB70P+4]; log [0X2.6213E21B14894P-516, 0X6.6606F0995E5F4P-224] = [-0X1.64CBA844FC0EAP+8, -0X9.968AD8B569FE0P+4]; log [0X9.0FF2CAA1B3048P-240, 0X1.95F14B9BA7449P+236] = [-0XA.426B5145A44A0P+4, +0XA.40B346F454218P+4]; log [0X8.E2ADA8DFBE938P-492, 0X3.67CB3BE0BB146P-452] = [-0X1.52D81024E4C23P+8, -0X1.3813C01ACD25CP+8]; log [0X1.394270BBCBA7EP+196, 0X8.4976F0BF45A40P+224] = [0X8.80F0717A1DC40P+4, 0X9.D6130F01F8B78P+4]; log [0X6.A000A12839A50P-44, 0X3.86DC59439415AP+276] = [-0X1.C9B8D4127E3DAP+4, +0XC.091AAD1207058P+4]; log [0X1.3C84E4F9C80CEP-476, 0X9.1E9439C3B4358P+196] = [-0X1.49B9D16B7E46AP+8, +0X8.A1137BDE55CF8P+4]; log [0X8.41D2DB6D93548P-376, 0X2.EDCF4A7919034P+140] = [-0X1.028323B4D95B4P+8, +0X6.21D80D9193AB8P+4]; log [0X1.2C18FEEBCAEAEP-768, 0X1.C369E759DF5E3P-328] = [-0X2.142D983D15A28P+8, -0XE.2C8FA3F896A50P+4]; log [0X4.D94E91619D3F0P-580, 0X2.9F6CAF6B5513EP-132] = [-0X1.907255D3994FEP+8, -0X5.A87FCF5FBD800P+4]; log [0X2.9CD12C1D0AAC4P+116, 0X3.BF7E0E52DC1AAP+276] = [0X5.15D8B410E0A5CP+4, 0XC.0A13DC536CD58P+4]; log [0X3.36DE5C55594EEP-100, 0X1.D0460177B1553P+204] = [-0X4.425A8474E3980P+4, +0X8.DFF506FE0D9F8P+4]; log [0X4.BD4031736F7A8P+4, 0XF.A10BB3C91C7B0P+592] = [0X4.54169A4297548P+0, 0X1.9D179EA5204D0P+8]; log [0X2.8E258DB3C44F8P+20, 0X3.1A4EDE719A4C0P+628] = [0XE.CD14BEBE2CD68P+0, 0X1.B46DC0D02B874P+8]; log [0X2.33950F38F830EP-176, 0X5.BE0388619B018P-24] = [-0X7.9346BAB839B58P+4, -0XE.E33F2C933B990P+0]; log [0X3.24F03DF33568CP-560, 0XE.67255823421E8P+920] = [-0X1.83044F26AAA2BP+8, +0X2.805CE2DC91036P+8]; log [0X2.D572639DC5FA8P-468, 0X1.95CF42AA171CDP-160] = [-0X1.4359ECD75CB6CP+8, -0X6.E715E1BA0E35CP+4]; log [0X4.705A028302DB0P-532, 0X2.E57341C14970CP+324] = [-0X1.6F438EE9F6020P+8, +0XE.1A4A3523F2658P+4]; log [0X4.DBA1D21D6F308P+144, 0X3.667988C57865AP+196] = [0X6.564D09AD1D214P+4, 0X8.914A9531FD118P+4]; log [0X4.9FA5A1E4DF740P-328, 0X1.11B85141B78F6P-240] = [-0XE.1D2336A5BE1A8P+4, -0XA.649D44362A2F0P+4]; log [0XA.0CDE9DC015B08P+360, 0XF.99D84F862AC58P+524] = [0XF.BD7308ED73FF0P+4, 0X1.6DF4DA39DC5DDP+8]; log [0X6.88441038D56B8P-108, 0X3.3D65C09938132P+136] = [-0X4.8FBAEF1169C24P+4, +0X5.F718BBF0CE2F8P+4]; log [0X7.1761CAB055134P-356, 0X1.92EFD09488689P-76] = [-0XF.4CD3094A3B4B8P+4, -0X3.439BFD719BAE8P+4]; log [0X6.2085E427413C8P-252, 0XB.8CDD3B024EA10P-36] = [-0XA.CDC41AEE74318P+4, -0X1.681AFF89E9C89P+4]; log [0XB.F5F1C0FA33978P-504, 0X4.924DD8D50B1CCP+72] = [-0X1.5ADD53379EF4DP+8, +0X3.36D2B121508A8P+4]; log [0XB.BC7E37EB2D388P-216, 0X1.CFE27BB53DEBBP+192] = [-0X9.341D196AD2D58P+4, +0X8.5ADC069F618A8P+4]; log [0X1.E139DD116F868P-688, 0XD.2545346D68FD0P-148] = [-0X1.DC410CBC8E1C8P+8, -0X6.4027B79D2EAA8P+4]; log [0X2.E0C8E64A890ACP+192, 0X2.6A898D2CAA9A4P+260] = [0X8.6243148F46208P+4, 0XB.519B6E544F898P+4]; log [0X5.9C4642ED78BC8P-340, 0X4.631BD2232F0C0P+588] = [-0XE.9F20674285418P+4, +0X1.990C99B6124FEP+8]; log [0XF.C05EA810DFE88P-180, 0XA.05884FBED5F48P-152] = [-0X7.A02728D7D3790P+4, -0X6.70DBA893A16E0P+4]; log2 [0XC.4B4A6EB6B3AF0P-264, 0XA.DD2C4C1BE4B30P+92] = [-0X1.04614E93EA794P+8, +0X5.F7104B04804E4P+4]; log2 [0X2.6213E21B14894P-516, 0X6.6606F0995E5F4P-224] = [-0X2.02BF4547CF74AP+8, -0XD.D527F669B7AA0P+4]; log2 [0X9.0FF2CAA1B3048P-240, 0X1.95F14B9BA7449P+236] = [-0XE.CD1F394A2C268P+4, +0XE.CAA4613C31FD0P+4]; log2 [0X8.E2ADA8DFBE938P-492, 0X3.67CB3BE0BB146P-452] = [-0X1.E8D93AC78E47CP+8, -0X1.C23B6E9F9BE73P+8]; log2 [0X1.394270BBCBA7EP+196, 0X8.4976F0BF45A40P+224] = [0XC.44A8D0A480900P+4, 0XE.30D042BD32E08P+4]; log2 [0X6.A000A12839A50P-44, 0X3.86DC59439415AP+276] = [-0X2.945A6DE3564F2P+4, +0X1.15D18004DA527P+8]; log2 [0X1.3C84E4F9C80CEP-476, 0X9.1E9439C3B4358P+196] = [-0X1.DBB1A03AD9911P+8, +0XC.7305ECF8E75D8P+4]; log2 [0X8.41D2DB6D93548P-376, 0X2.EDCF4A7919034P+140] = [-0X1.74F450FB5F194P+8, +0X8.D8CE5C08208D0P+4]; log2 [0X1.2C18FEEBCAEAEP-768, 0X1.C369E759DF5E3P-328] = [-0X2.FFC54D5EF9E5AP+8, -0X1.472E83799CCFAP+8]; log2 [0X4.D94E91619D3F0P-580, 0X2.9F6CAF6B5513EP-132] = [-0X2.41B8EC5041B68P+8, -0X8.29BE215800410P+4]; log2 [0X2.9CD12C1D0AAC4P+116, 0X3.BF7E0E52DC1AAP+276] = [0X7.562AE05DF4698P+4, 0X1.15E7F7FA196AAP+8]; log2 [0X3.36DE5C55594EEP-100, 0X1.D0460177B1553P+204] = [-0X6.250C3695FCF20P+4, +0XC.CDBDC5938D560P+4]; log2 [0X4.BD4031736F7A8P+4, 0XF.A10BB3C91C7B0P+592] = [0X6.3EA22BED11920P+0, 0X2.53F7565A6FA4CP+8]; log2 [0X2.8E258DB3C44F8P+20, 0X3.1A4EDE719A4C0P+628] = [0X1.55A7D090E9BC4P+4, 0X2.75A230A6EF148P+8]; log2 [0X2.33950F38F830EP-176, 0X5.BE0388619B018P-24] = [-0XA.EDC8C6AE09A00P+4, -0X1.57A778189781EP+4]; log2 [0X3.24F03DF33568CP-560, 0XE.67255823421E8P+920] = [-0X2.2E58E661BEF52P+8, +0X3.9BD9297418726P+8]; log2 [0X2.D572639DC5FA8P-468, 0X1.95CF42AA171CDP-160] = [-0X1.D27F4D5811EC0P+8, -0X9.F55D8E4A51F88P+4]; log2 [0X4.705A028302DB0P-532, 0X2.E57341C14970CP+324] = [-0X2.11D98CE9F01E8P+8, +0X1.4588C1B9F05FCP+8]; log2 [0X4.DBA1D21D6F308P+144, 0X3.667988C57865AP+196] = [0X9.247C4A0D6A240P+4, 0XC.5C40234316DE0P+4]; log2 [0X4.9FA5A1E4DF740P-328, 0X1.11B85141B78F6P-240] = [-0X1.45CA7D7508D73P+8, -0XE.FE7480A8A6A70P+4]; log2 [0XA.0CDE9DC015B08P+360, 0XF.99D84F862AC58P+524] = [0X1.6B54440063A2FP+8, 0X2.0FF6AC0A1DF08P+8]; log2 [0X6.88441038D56B8P-108, 0X3.3D65C09938132P+136] = [-0X6.94ADB7A807630P+4, +0X8.9B227CD69B7B0P+4]; log2 [0X7.1761CAB055134P-356, 0X1.92EFD09488689P-76] = [-0X1.612C877FDEFC9P+8, -0X4.B58789B7D2AB8P+4]; log2 [0X6.2085E427413C8P-252, 0XB.8CDD3B024EA10P-36] = [-0XF.96282D809EDE0P+4, -0X2.0785B9A270C10P+4]; log2 [0XB.F5F1C0FA33978P-504, 0X4.924DD8D50B1CCP+72] = [-0X1.F46B75E4932F4P+8, +0X4.A3152AC221298P+4]; log2 [0XB.BC7E37EB2D388P-216, 0X1.CFE27BB53DEBBP+192] = [-0XD.47274C2E0B298P+4, +0XC.0DB8D252704A8P+4]; log2 [0X1.E139DD116F868P-688, 0XD.2545346D68FD0P-148] = [-0X2.AF16E4D3D6128P+8, -0X9.048930492A7A0P+4]; log2 [0X2.E0C8E64A890ACP+192, 0X2.6A898D2CAA9A4P+260] = [0XC.1866CEA5B0408P+4, 0X1.0545D0C4DA7BAP+8]; log2 [0X5.9C4642ED78BC8P-340, 0X4.631BD2232F0C0P+588] = [-0X1.51830AD8B30FCP+8, +0X2.4E221EC1DB53EP+8]; log2 [0XF.C05EA810DFE88P-180, 0XA.05884FBED5F48P-152] = [-0XB.005C8501548A8P+4, -0X9.4ACCA02A24828P+4]; log10 [0XC.4B4A6EB6B3AF0P-264, 0XA.DD2C4C1BE4B30P+92] = [-0X4.E61D94C4C8D58P+4, +0X1.CBB1247192AE0P+4]; log10 [0X2.6213E21B14894P-516, 0X6.6606F0995E5F4P-224] = [-0X9.AF44F24283358P+4, -0X4.29FE8451F9E24P+4]; log10 [0X9.0FF2CAA1B3048P-240, 0X1.95F14B9BA7449P+236] = [-0X4.74A3ADB971C48P+4, +0X4.73E4925024C64P+4]; log10 [0X8.E2ADA8DFBE938P-492, 0X3.67CB3BE0BB146P-452] = [-0X9.32877CA0160B8P+4, -0X8.7888BDDBCE5D0P+4]; log10 [0X1.394270BBCBA7EP+196, 0X8.4976F0BF45A40P+224] = [0X3.B16EC52507DF2P+4, 0X4.4595F97548968P+4]; log10 [0X6.A000A12839A50P-44, 0X3.86DC59439415AP+276] = [-0XC.6C93FFEF64F78P+0, +0X5.3A1B471A21FF4P+4]; log10 [0X1.3C84E4F9C80CEP-476, 0X9.1E9439C3B4358P+196] = [-0X8.F32B7DBB21008P+4, +0X3.BF63BA7A3C658P+4]; log10 [0X8.41D2DB6D93548P-376, 0X2.EDCF4A7919034P+140] = [-0X7.0453C2F061648P+4, +0X2.A9C64A16830FCP+4]; log10 [0X1.2C18FEEBCAEAEP-768, 0X1.C369E759DF5E3P-328] = [-0XE.71F3C5029D848P+4, -0X6.27DD331C437F0P+4]; log10 [0X4.D94E91619D3F0P-580, 0X2.9F6CAF6B5513EP-132] = [-0XA.DE968FD95ABE0P+4, -0X2.7513429684674P+4]; log10 [0X2.9CD12C1D0AAC4P+116, 0X3.BF7E0E52DC1AAP+276] = [0X2.35627EFD00A60P+4, 0X5.3A877F4AD58E8P+4]; log10 [0X3.36DE5C55594EEP-100, 0X1.D0460177B1553P+204] = [-0X1.D988D7EBC5AE3P+4, +0X3.DAB2CD7F2625EP+4]; log10 [0X4.BD4031736F7A8P+4, 0XF.A10BB3C91C7B0P+592] = [0X1.E13C93CF0C5D8P+0, 0XB.367584AC914D0P+4]; log10 [0X2.8E258DB3C44F8P+20, 0X3.1A4EDE719A4C0P+628] = [0X6.6D93B54D66420P+0, 0XB.D89E0CA927598P+4]; log10 [0X2.33950F38F830EP-176, 0X5.BE0388619B018P-24] = [-0X3.4A378CAAD54DAP+4, -0X6.773414D886C14P+0]; log10 [0X3.24F03DF33568CP-560, 0XE.67255823421E8P+920] = [-0XA.8144B5B8F5DD8P+4, +0X1.161B25DAC86ECP+8]; log10 [0X2.D572639DC5FA8P-468, 0X1.95CF42AA171CDP-160] = [-0X8.C6DFF01C76970P+4, -0X2.FF6F7B088B0CCP+4]; log10 [0X4.705A028302DB0P-532, 0X2.E57341C14970CP+324] = [-0X9.F802CE339E840P+4, +0X6.1FEDD0FB88D78P+4]; log10 [0X4.DBA1D21D6F308P+144, 0X3.667988C57865AP+196] = [0X2.C08E6C63F32E4P+4, 0X3.B888C99289754P+4]; log10 [0X4.9FA5A1E4DF740P-328, 0X1.11B85141B78F6P-240] = [-0X6.212A6B69124F0P+4, -0X4.837D7868C93BCP+4]; log10 [0XA.0CDE9DC015B08P+360, 0XF.99D84F862AC58P+524] = [0X6.D5F7B5F14DD48P+4, 0X9.EEED0801EA480P+4]; log10 [0X6.88441038D56B8P-108, 0X3.3D65C09938132P+136] = [-0X1.FB238786D64F9P+4, +0X2.9735AA99F42AAP+4]; log10 [0X7.1761CAB055134P-356, 0X1.92EFD09488689P-76] = [-0X6.A50E2200DFF14P+4, -0X1.6AE688B7C8203P+4]; log10 [0X6.2085E427413C8P-252, 0XB.8CDD3B024EA10P-36] = [-0X4.B1282C68FE4F8P+4, -0X9.C644DFB9EE3E0P+0]; log10 [0XB.F5F1C0FA33978P-504, 0X4.924DD8D50B1CCP+72] = [-0X9.6A430336AD680P+4, +0X1.6558F570C1420P+4]; log10 [0XB.BC7E37EB2D388P-216, 0X1.CFE27BB53DEBBP+192] = [-0X3.FF3F46384E0E2P+4, +0X3.A0E51611FF75EP+4]; log10 [0X1.E139DD116F868P-688, 0XD.2545346D68FD0P-148] = [-0XC.ED5A39E5D4878P+4, -0X2.B6F044CDE4A0CP+4]; log10 [0X2.E0C8E64A890ACP+192, 0X2.6A898D2CAA9A4P+260] = [0X3.A41C190FE9E7AP+4, 0X4.EA6A3021E4FB8P+4]; log10 [0X5.9C4642ED78BC8P-340, 0X4.631BD2232F0C0P+588] = [-0X6.599E84FEF71BCP+4, +0XB.1A5D77BC55F98P+4]; log10 [0XF.C05EA810DFE88P-180, 0XA.05884FBED5F48P-152] = [-0X3.4FCF2BC10B840P+4, -0X2.CC1706E0167D2P+4]; sin [-0XA.644C9D88EA8C8P-152, -0XD.8EC7927926F18P-944] = [-0XA.644C9D88EA8C8P-152, -0XD.8EC7927926F10P-944]; sin [-0X1.9EE1A9DB994F5P-436, -0X6.D914701C82FECP-624] = [-0X1.9EE1A9DB994F5P-436, -0X6.D914701C82FE8P-624]; sin [-0X5.65057F3EFFC60P+4, -0X2.3617CF5815ECAP-960] = [-0X1.0000000000000P+0, +0X1.0000000000000P+0]; sin [-0X1.975299CCB0E08P-372, +0XB.BEC7D35B45B00P-588] = [-0X1.975299CCB0E08P-372, +0XB.BEC7D35B45B00P-588]; sin [-0X3.51D388D47AED2P-356, -0X1.C3A9CD7025105P-564] = [-0X3.51D388D47AED2P-356, -0X1.C3A9CD7025104P-564]; sin [-0XC.DB363268CF708P-332, -0X2.171B7D7BFE4E0P-412] = [-0XC.DB363268CF708P-332, -0X2.171B7D7BFE4DEP-412]; sin [-0X1.32690AAC2472DP-40, -0X8.706EBDCF39C88P-792] = [-0X1.32690AAC2472DP-40, -0X8.706EBDCF39C80P-792]; sin [-0X5.0145AF0C53324P-200, -0X2.F5A0CB3301856P-204] = [-0X5.0145AF0C53324P-200, -0X2.F5A0CB3301854P-204]; sin [0XF.4077C7E8CD6A0P-268, 0X3.753426098AC5AP-80] = [0XF.4077C7E8CD698P-268, 0X3.753426098AC5AP-80]; sin [-0XB.B25F8D8BB7FB8P-376, -0X2.017A332F9B05CP-916] = [-0XB.B25F8D8BB7FB8P-376, -0X2.017A332F9B05AP-916]; sin [-0XD.947CA427FDFE0P-592, +0XE.3BE493B5BC8E8P-16] = [-0XD.947CA427FDFE0P-592, +0XE.3BE491D517170P-16]; sin [-0X9.C46198B2471F0P-336, -0X1.65ED85DF2D4B7P-576] = [-0X9.C46198B2471F0P-336, -0X1.65ED85DF2D4B6P-576]; sin [-0X3.2C867C027DB44P-936, +0X6.1883EA827AB6CP-388] = [-0X3.2C867C027DB44P-936, +0X6.1883EA827AB6CP-388]; sin [-0X3.560EF91C47DEAP-492, +0X5.413664DD17ABCP-20] = [-0X3.560EF91C47DEAP-492, +0X5.413664DCFF7D4P-20]; sin [-0X8.36BFCD74A6D68P-304, -0X3.2C20EB130D510P-836] = [-0X8.36BFCD74A6D68P-304, -0X3.2C20EB130D50EP-836]; sin [-0X6.BCEC84603958CP-500, -0X1.068B13DA99666P-760] = [-0X6.BCEC84603958CP-500, -0X1.068B13DA99665P-760]; sin [-0X1.2789C2D583BCDP-568, -0X1.F2BD89DAD0665P-780] = [-0X1.2789C2D583BCDP-568, -0X1.F2BD89DAD0664P-780]; sin [-0XC.FE4E8D857E3E0P-548, +0X1.580844B9DC45CP-780] = [-0XC.FE4E8D857E3E0P-548, +0X1.580844B9DC45CP-780]; sin [-0XC.508D29ACB01B8P-52, +0X1.B1E6B793078DDP-664] = [-0XC.508D29ACB01B8P-52, +0X1.B1E6B793078DDP-664]; sin [-0XA.12F7783880A78P-124, -0X3.765DF69EE106EP-548] = [-0XA.12F7783880A78P-124, -0X3.765DF69EE106CP-548]; sin [-0X6.3A58D52FDF844P-896, -0X1.039E2518CF503P-1008] = [-0X6.3A58D52FDF844P-896, -0X1.039E2518CF502P-1008]; sin [-0XB.DD3171FDEEC18P-168, +0X1.069E434EE9E0FP-740] = [-0XB.DD3171FDEEC18P-168, +0X1.069E434EE9E0FP-740]; sin [-0X3.CF0053257533AP-776, -0X1.7883A587654E5P-928] = [-0X3.CF0053257533AP-776, -0X1.7883A587654E4P-928]; sin [0X1.455801D3D2B63P-704, 0X3.A4C915783D07AP-28] = [0X1.455801D3D2B62P-704, 0X3.A4C915783D07AP-28]; sin [-0X2.097D06F4DE3E2P-376, +0X2.2E7561FD9255EP-772] = [-0X2.097D06F4DE3E2P-376, +0X2.2E7561FD9255EP-772]; sin [-0X1.7E13DBB66E5A3P-84, -0X6.BC8F45D6A8F48P-540] = [-0X1.7E13DBB66E5A3P-84, -0X6.BC8F45D6A8F44P-540]; sin [-0X4.1F50C5F2CDA54P-276, -0X3.DF16F79756422P-496] = [-0X4.1F50C5F2CDA54P-276, -0X3.DF16F79756420P-496]; sin [-0X7.ECC4C5EEC4CACP-328, -0X2.E02E1DB7A08F6P-876] = [-0X7.ECC4C5EEC4CACP-328, -0X2.E02E1DB7A08F4P-876]; sin [-0XC.1BC7A4C89D440P-256, +0X2.A7F56252D1D34P-608] = [-0XC.1BC7A4C89D440P-256, +0X2.A7F56252D1D34P-608]; sin [-0XB.CE50D7B2F2868P-236, -0XE.6B08988339B80P-432] = [-0XB.CE50D7B2F2868P-236, -0XE.6B08988339B78P-432]; cos [-0XA.644C9D88EA8C8P-152, -0XD.8EC7927926F18P-944] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0X1.9EE1A9DB994F5P-436, -0X6.D914701C82FECP-624] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0X5.65057F3EFFC60P+4, -0X2.3617CF5815ECAP-960] = [-0X1.0000000000000P+0, +0X1.0000000000000P+0]; cos [-0X1.975299CCB0E08P-372, +0XB.BEC7D35B45B00P-588] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0X3.51D388D47AED2P-356, -0X1.C3A9CD7025105P-564] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0XC.DB363268CF708P-332, -0X2.171B7D7BFE4E0P-412] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0X1.32690AAC2472DP-40, -0X8.706EBDCF39C88P-792] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0X5.0145AF0C53324P-200, -0X2.F5A0CB3301856P-204] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [0XF.4077C7E8CD6A0P-268, 0X3.753426098AC5AP-80] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0XB.B25F8D8BB7FB8P-376, -0X2.017A332F9B05CP-916] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0XD.947CA427FDFE0P-592, +0XE.3BE493B5BC8E8P-16] = [0XF.FFFFF9AB27E58P-4, 0X1.0000000000000P+0]; cos [-0X9.C46198B2471F0P-336, -0X1.65ED85DF2D4B7P-576] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0X3.2C867C027DB44P-936, +0X6.1883EA827AB6CP-388] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0X3.560EF91C47DEAP-492, +0X5.413664DD17ABCP-20] = [0XF.FFFFFFFF231A0P-4, 0X1.0000000000000P+0]; cos [-0X8.36BFCD74A6D68P-304, -0X3.2C20EB130D510P-836] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0X6.BCEC84603958CP-500, -0X1.068B13DA99666P-760] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0X1.2789C2D583BCDP-568, -0X1.F2BD89DAD0665P-780] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0XC.FE4E8D857E3E0P-548, +0X1.580844B9DC45CP-780] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0XC.508D29ACB01B8P-52, +0X1.B1E6B793078DDP-664] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0XA.12F7783880A78P-124, -0X3.765DF69EE106EP-548] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0X6.3A58D52FDF844P-896, -0X1.039E2518CF503P-1008] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0XB.DD3171FDEEC18P-168, +0X1.069E434EE9E0FP-740] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0X3.CF0053257533AP-776, -0X1.7883A587654E5P-928] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [0X1.455801D3D2B63P-704, 0X3.A4C915783D07AP-28] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0X2.097D06F4DE3E2P-376, +0X2.2E7561FD9255EP-772] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0X1.7E13DBB66E5A3P-84, -0X6.BC8F45D6A8F48P-540] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0X4.1F50C5F2CDA54P-276, -0X3.DF16F79756422P-496] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0X7.ECC4C5EEC4CACP-328, -0X2.E02E1DB7A08F6P-876] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0XC.1BC7A4C89D440P-256, +0X2.A7F56252D1D34P-608] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; cos [-0XB.CE50D7B2F2868P-236, -0XE.6B08988339B80P-432] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; tan [0X4.6AF931A62EB70P+4, 0X4.6C0D89ACF83F0P+4] = [-0X4.2B94A5B864748P+16, -0XE.CC7EFFC39BBE8P+0]; tan [0X9.B824319678E98P+4, 0X9.B8365416B3188P+4] = [-0X9.517610C9FF4F0P+28, -0XE.1DCEBD0ABA128P+4]; tan [0XE.231D6DE6B2910P+0, 0XE.232155989FD58P+0] = [-0X1.1A74CC770CA81P+20, -0X4.09E5FC000B430P+12]; tan [0X3.A1E994576AF38P+4, 0X3.A1F62CB3D8B0CP+4] = [-0X3.EDBBE63A85A20P+12, -0X1.3EC2E09B0B82DP+8]; tan [0X4.504512C674C88P+8, 0X4.5045147DF4570P+8] = [-0XC.5E819F2BCA708P+28, -0X9.51D20751384C0P+12]; tan [0X7.DA9E8C267B000P+0, 0XA.CCC7028A13E50P+0] = [-0X8.CE26DA7B8CCA8P+20, +0X5.0BA299C8F763CP+0]; tan [0XC.CA9E956E09870P+12, 0XC.CA9FEB35E8D28P+12] = [-0X9.40D68D3420248P+16, -0XB.F4CB43C962B98P+0]; tan [0X2.F6B1D30E1AC2CP+8, 0X2.F6B1EAD90ED6EP+8] = [-0X1.1E211833A60A2P+20, -0XA.BBFD5C235E8E8P+8]; tan [0XB.C33774AC8C510P+8, 0XB.C3378F9640B80P+8] = [-0X3.B8E9A3359EA76P+12, -0X8.33C065B080F78P+8]; tan [0X4.B65F2027400ECP+0, 0X4.B65F690A4503CP+0] = [-0X2.D46AD27DDB548P+24, -0X3.7ECF31F99ADC4P+16]; tan [0X3.C60A2C774D8A6P+8, 0X3.C60A76B28E42CP+8] = [-0X3.28E3C44C11B44P+24, -0X3.72D85B31BD660P+8]; tan [0X7.DA9E8A5DF3B7CP+0, 0X7.DAA9CFE45466CP+0] = [-0X1.D9B11082E8FC3P+28, -0X1.6B6333E88C1DFP+12]; tan [0X3.A1E953315B022P+4, 0X3.A3624FC9B84C0P+4] = [-0X4.91A5298A762FCP+24, -0XA.D59BACA695F48P+0]; tan [0X7.DA9E8AB1B7B7CP+0, 0X8.E4A2BCBB988B0P+0] = [-0X2.C52AD8545AC54P+24, -0X9.691CCDB9751E8P-4]; tan [0X5.48783C12B018CP+8, 0X5.487863A8A0C78P+8] = [-0X4.7465D978FF1E8P+4, -0X4.455187267B294P+4]; tan [0X1.AB41B772619C2P+4, 0X1.AB96C295E1A23P+4] = [-0X2.55DE9F429F276P+16, -0X3.02439C1296068P+4]; tan [0X1.87E20C8B7CCC1P+16, 0X1.87E20E060934FP+16] = [-0X7.5F7BB0C55311CP+28, -0XA.D1F5D5F3730E8P+4]; tan [0X2.5BA5629043048P+16, 0X2.5BA5A6106DDF4P+16] = [-0X4.BDE3C915168D8P+4, -0X3.84ED584601B4CP+0]; tan [0X1.A9AF913EE27CFP+8, 0X1.A9AFA6D06E549P+8] = [-0X2.CB455269CB954P+16, -0XB.ACE6E2EAA9098P+8]; tan [0X7.64CF403A51948P+8, 0X7.64D139F1912E4P+8] = [-0X5.38F704820A47CP+28, -0X8.19686283B81E8P+4]; tan [0X4.1437B08F8BA70P+16, 0X4.1439A27E86D50P+16] = [-0X1.3ADB30F7A9B56P+24, +0X6.48C7464A8F9A0P-4]; tan [0X2.74518B3BAFB7CP+4, 0X2.74518DE5A60C0P+4] = [-0XF.8E3A10DB36640P+24, -0X5.FF456443FD8B8P+16]; tan [0X1.DD85A7816A0FFP+4, 0X1.DD89849DFDF09P+4] = [-0X3.FA5C8BD1A67ECP+20, -0X4.23D96B0387510P+8]; tan [0X1.AB41B29964887P+4, 0X1.B5CBD4ED0D1DDP+4] = [-0X7.FC8B577B97310P+16, -0X1.4AB8A7BB81552P+0]; tan [0X1.19454E95BC804P+12, 0X1.194551E9AD95AP+12] = [-0X1.2A53ECF4C9B1AP+12, -0X3.D27F074C2DA94P+8]; tan [0X4.C4823D2C30D00P+8, 0X4.C482DEAE395CCP+8] = [-0X7.F7B434A3F3544P+28, -0X1.95C659F53B09BP+8]; tan [0X1.DD85BAAB9BAF9P+4, 0X1.DD8660423BAACP+4] = [-0XD.2F5338751C9C8P+12, -0X1.623D682415BE0P+12]; tan [0X2.F798BB3536690P+16, 0X2.F79A363308C32P+16] = [-0X2.F8C1AC15A9CCEP+16, -0X1.731B7ACF94603P-4]; tan [0X1.78FDB9F143616P+4, 0X1.78FDB9F143616P+4] = [-0XC.9CFD638FE0A18P+24, -0XC.9CFD638FE0A10P+24]; tan [0X1.78FDB9F143616P+4, 0X1.79367E02D4EAAP+4] = [-0XC.9CFD638FE0A18P+24, -0X4.826BF805C4E68P+4]; cot [0X4.51D73651EA89CP+4, 0X4.52EB8E58B411CP+4] = [0XE.CC7EFFC39DE08P+0, 0X4.2B94A5E391E20P+16]; cot [0X9.9F02364234BC8P+4, 0X9.9F1458C26EEB8P+4] = [0XE.1DCEBD0AA72D0P+4, 0X9.516DD4FA21CF0P+28]; cot [0XC.90FDB8A26FBF8P+0, 0XC.9101A0545D040P+0] = [0X4.09E5FC0006C38P+12, 0X1.1A74CC76B6B71P+20]; cot [0X3.88C7990326C68P+4, 0X3.88D4315F9483CP+4] = [0X1.3EC2E09B0928AP+8, 0X3.EDBBE6390EF44P+12]; cot [0X4.4EB2F3113085CP+8, 0X4.4EB2F4C8B0144P+8] = [0X9.51D206F220E70P+12, 0XC.5DDA26E3680B8P+28]; cot [0X6.487ED6E2382ECP+0, 0X9.3AA74D45D1138P+0] = [-0X5.0BA299C8F7644P+0, +0X8.CE26D93009840P+20]; cot [0XC.CA857372B5428P+12, 0XC.CA86C93A948E0P+12] = [0XB.F4CB43CC4C9E8P+0, 0X9.40D848DDFC130P+16]; cot [0X2.F51FB358D6800P+8, 0X2.F51FCB23CA942P+8] = [0XA.BBFD5C1B7C1D8P+8, 0X1.1E2116D584957P+20]; cot [0XB.C1A554F7480E0P+8, 0XB.C1A56FE0FC750P+8] = [0X8.33C065BCB81C8P+8, 0X3.B8E9A35DDF6BCP+12]; cot [0X3.243F6AE2FD3D8P+0, 0X3.243FB3C602324P+0] = [0X3.7ECF31F964F42P+16, 0X2.D46AD05A0B746P+24]; cot [0X3.C4780CC209478P+8, 0X3.C47856FD49FFEP+8] = [0X3.72D85B3269A44P+8, 0X3.28E454E439A90P+24]; cot [0X6.487ED519B0E68P+0, 0X6.488A1AA011958P+0] = [0X1.6B6333E883806P+12, 0X1.D9B101DF34E20P+28]; cot [0X3.88C757DD16D52P+4, 0X3.8A405475741F0P+4] = [0XA.D59BACA695410P+0, 0X4.91A509DE53224P+24]; cot [0X6.487ED56D74E68P+0, 0X7.5283077755B9CP+0] = [0X9.691CCDB975190P-4, 0X2.C52AD6475D346P+24]; cot [0X5.46E61C5D6BD60P+8, 0X5.46E643F35C84CP+8] = [0X4.4551872667304P+4, 0X4.7465D978E9638P+4]; cot [0X1.921FBC1E1D6F1P+4, 0X1.9274C7419D752P+4] = [0X3.02439C1295BB8P+4, 0X2.55DE9F3FCCF28P+16]; cot [0X1.87E07A6BC787DP+16, 0X1.87E07BE653F0BP+16] = [0XA.D1F5D5DED35E0P+4, 0X7.55F4ABD4357C8P+28]; cot [0X2.5BA3D0708DC04P+16, 0X2.5BA413F0B89B0P+16] = [0X3.84ED5845DBFB2P+0, 0X4.BDE3C91120740P+4]; cot [0X1.A81D71899E3A2P+8, 0X1.A81D871B2A11CP+8] = [0XB.ACE6E2E9DA370P+8, 0X2.CB45525DF368EP+16]; cot [0X7.633D20850D51CP+8, 0X7.633F1A3C4CEB8P+8] = [0X8.19686283704C0P+4, 0X5.38D928BC4D11CP+28]; cot [0X4.14361E6FD662CP+16, 0X4.1438105ED190CP+16] = [-0X6.48C7464AC3A74P-4, +0X1.3AD6ED9B4C193P+24]; cot [0X2.5B2F8FE76B8ACP+4, 0X2.5B2F929161DF0P+4] = [0X5.FF45640D6BF8CP+16, 0XF.8E38A1B8F3CE0P+24]; cot [0X1.C463AC2D25E2EP+4, 0X1.C4678949B9C38P+4] = [0X4.23D96B037E734P+8, 0X3.FA5C8B4EB13BAP+20]; cot [0X1.921FB745205B6P+4, 0X1.9CA9D998C8F0CP+4] = [0X1.4AB8A7BB8153CP+0, 0X7.FC8B575A99618P+16]; cot [0X1.192C2C9A683C1P+12, 0X1.192C2FEE59517P+12] = [0X3.D27F074ED4C1AP+8, 0X1.2A53ECF8BBB09P+12]; cot [0X4.C2F01D76EC8D4P+8, 0X4.C2F0BEF8F51A0P+8] = [0X1.95C659F50F06FP+8, 0X7.F76EB663A7898P+28]; cot [0X1.C463BF5757828P+4, 0X1.C46464EDF77DBP+4] = [0X1.623D682405E56P+12, 0XD.2F53386F7DF28P+12]; cot [0X2.F79729158124CP+16, 0X2.F798A413537EEP+16] = [0X1.731B7ACF66E92P-4, 0X2.F8C19331ECBFCP+16]; cot [0X3.371943E536E9EP+8, 0X3.371D0784693FAP+8] = [0X3.E06D09FC7DDC2P+4, 0X2.C1B5E6F32FDEEP+8]; cot [0X1.5FDBBE9CFF344P+4, 0X1.601482AE90BD8P+4] = [0X4.826BF805C583CP+4, 0XC.9CFDB05DEF930P+24]; asin [-0X3.11A309475E762P-164, -0XC.3784302E15500P-680] = [-0X3.11A309475E764P-164, -0XC.3784302E15500P-680]; asin [-0X5.7DD17A4248D38P-280, -0X2.898FC0F386F74P-640] = [-0X5.7DD17A4248D3CP-280, -0X2.898FC0F386F74P-640]; asin [-0XE.D83DCD7F564A0P-296, -0X1.62F61FBA0F40FP-764] = [-0XE.D83DCD7F564A8P-296, -0X1.62F61FBA0F40FP-764]; asin [-0X1.67712A1E64C2CP-944, -0X1.C0102C4D258EFP-976] = [-0X1.67712A1E64C2DP-944, -0X1.C0102C4D258EFP-976]; asin [0X2.E3D991AE84668P-728, 0X1.92C3C728CCF4AP-612] = [0X2.E3D991AE84668P-728, 0X1.92C3C728CCF4BP-612]; asin [-0X1.BCD3FEB3B0175P-640, +0X1.BEBE69E3BF3C2P-536] = [-0X1.BCD3FEB3B0176P-640, +0X1.BEBE69E3BF3C3P-536]; asin [-0X1.2469575189327P-372, -0X7.51C0C39F58A4CP-1008] = [-0X1.2469575189328P-372, -0X7.51C0C39F58A4CP-1008]; asin [-0X1.C4D163A6CCCD9P-336, -0X1.3BEE6DAB70397P-796] = [-0X1.C4D163A6CCCDAP-336, -0X1.3BEE6DAB70397P-796]; asin [-0X2.0FAE5DE90C98CP-896, -0X2.2079777EC2418P-976] = [-0X2.0FAE5DE90C98EP-896, -0X2.2079777EC2418P-976]; asin [-0X1.08C248C37E53BP-816, +0X2.8C9F04EE5DE84P-948] = [-0X1.08C248C37E53CP-816, +0X2.8C9F04EE5DE86P-948]; asin [-0X2.0002542B01474P-228, +0X2.4D59F217BF74CP-796] = [-0X2.0002542B01476P-228, +0X2.4D59F217BF74EP-796]; asin [0XD.D4033889729A0P-844, 0X7.44451BF919D78P-556] = [0XD.D4033889729A0P-844, 0X7.44451BF919D7CP-556]; asin [-0X2.08918B016995CP-64, +0X3.3FC26450C6E4AP-268] = [-0X2.08918B016995EP-64, +0X3.3FC26450C6E4CP-268]; asin [-0X2.66C95BD8D7716P-388, +0X1.7E16B310F878AP-232] = [-0X2.66C95BD8D7718P-388, +0X1.7E16B310F878BP-232]; asin [-0X3.D9C66BD30B774P-256, -0X4.A8C30F678CB68P-456] = [-0X3.D9C66BD30B776P-256, -0X4.A8C30F678CB68P-456]; asin [-0X1.AA045CCB15AEDP-804, +0XD.450C473265610P-24] = [-0X1.AA045CCB15AEEP-804, +0XD.450C473266E68P-24]; asin [-0X2.23ADFA571FC3CP-344, -0X1.30D1074DC059EP-868] = [-0X2.23ADFA571FC3EP-344, -0X1.30D1074DC059EP-868]; asin [-0X3.DFBC1A4BF3888P-68, -0X4.A89E39B247C84P-840] = [-0X3.DFBC1A4BF388AP-68, -0X4.A89E39B247C84P-840]; asin [0X9.583064525D370P-496, 0X2.C67652F06A55EP-408] = [0X9.583064525D370P-496, 0X2.C67652F06A560P-408]; asin [-0X3.38BF880EC3082P-304, -0X7.7B19877E536ACP-512] = [-0X3.38BF880EC3084P-304, -0X7.7B19877E536ACP-512]; asin [-0X2.ADBF037238702P-44, +0X1.98DC940C3AE1EP-564] = [-0X2.ADBF037238704P-44, +0X1.98DC940C3AE1FP-564]; asin [-0X4.E4A79C48B3A58P-328, +0XA.28B02E59D39D8P-856] = [-0X4.E4A79C48B3A5CP-328, +0XA.28B02E59D39E0P-856]; asin [-0X6.80D3E87B911D8P-232, -0X2.3DF54212C46E4P-520] = [-0X6.80D3E87B911DCP-232, -0X2.3DF54212C46E4P-520]; asin [-0X1.4E54C309C46F8P-480, +0X9.47E982AC83F98P-688] = [-0X1.4E54C309C46F9P-480, +0X9.47E982AC83FA0P-688]; asin [-0X2.276202227A6DEP-808, +0X1.C53E9BA64FADFP-768] = [-0X2.276202227A6E0P-808, +0X1.C53E9BA64FAE0P-768]; asin [-0X4.8E4B4D7BA6DD0P-212, -0X1.4B35284C1064BP-548] = [-0X4.8E4B4D7BA6DD4P-212, -0X1.4B35284C1064BP-548]; asin [-0X3.5C52B8D9FF582P-248, -0X2.AF868D652B866P-912] = [-0X3.5C52B8D9FF584P-248, -0X2.AF868D652B866P-912]; asin [0X1.6938CC5EE183AP-692, 0XB.F7A583AC38168P-664] = [0X1.6938CC5EE183AP-692, 0XB.F7A583AC38170P-664]; asin [-0X3.68B35F23B2506P-560, +0X9.F9C9246D05138P-304] = [-0X3.68B35F23B2508P-560, +0X9.F9C9246D05140P-304]; asin [-0XA.BDE70B6850EA0P-516, +0X2.BB76D5BF703FAP-1020] = [-0XA.BDE70B6850EA8P-516, +0X2.BB76D5BF703FCP-1020]; acos [-0X3.11A309475E762P-164, -0XC.3784302E15500P-680] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0X5.7DD17A4248D38P-280, -0X2.898FC0F386F74P-640] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0XE.D83DCD7F564A0P-296, -0X1.62F61FBA0F40FP-764] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0X1.67712A1E64C2CP-944, -0X1.C0102C4D258EFP-976] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [0X2.E3D991AE84668P-728, 0X1.92C3C728CCF4AP-612] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0X1.BCD3FEB3B0175P-640, +0X1.BEBE69E3BF3C2P-536] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0X1.2469575189327P-372, -0X7.51C0C39F58A4CP-1008] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0X1.C4D163A6CCCD9P-336, -0X1.3BEE6DAB70397P-796] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0X2.0FAE5DE90C98CP-896, -0X2.2079777EC2418P-976] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0X1.08C248C37E53BP-816, +0X2.8C9F04EE5DE84P-948] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0X2.0002542B01474P-228, +0X2.4D59F217BF74CP-796] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [0XD.D4033889729A0P-844, 0X7.44451BF919D78P-556] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0X2.08918B016995CP-64, +0X3.3FC26450C6E4AP-268] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0X2.66C95BD8D7716P-388, +0X1.7E16B310F878AP-232] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0X3.D9C66BD30B774P-256, -0X4.A8C30F678CB68P-456] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0X1.AA045CCB15AEDP-804, +0XD.450C473265610P-24] = [0X1.921FA7FF368A5P+0, 0X1.921FB54442D19P+0]; acos [-0X2.23ADFA571FC3CP-344, -0X1.30D1074DC059EP-868] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0X3.DFBC1A4BF3888P-68, -0X4.A89E39B247C84P-840] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [0X9.583064525D370P-496, 0X2.C67652F06A55EP-408] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0X3.38BF880EC3082P-304, -0X7.7B19877E536ACP-512] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0X2.ADBF037238702P-44, +0X1.98DC940C3AE1EP-564] = [0X1.921FB54442D18P+0, 0X1.921FB54442FC7P+0]; acos [-0X4.E4A79C48B3A58P-328, +0XA.28B02E59D39D8P-856] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0X6.80D3E87B911D8P-232, -0X2.3DF54212C46E4P-520] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0X1.4E54C309C46F8P-480, +0X9.47E982AC83F98P-688] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0X2.276202227A6DEP-808, +0X1.C53E9BA64FADFP-768] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0X4.8E4B4D7BA6DD0P-212, -0X1.4B35284C1064BP-548] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0X3.5C52B8D9FF582P-248, -0X2.AF868D652B866P-912] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [0X1.6938CC5EE183AP-692, 0XB.F7A583AC38168P-664] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0X3.68B35F23B2506P-560, +0X9.F9C9246D05138P-304] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acos [-0XA.BDE70B6850EA0P-516, +0X2.BB76D5BF703FAP-1020] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; atan [0X1.7A77BFCCF5A9EP-232, 0X2.8457BC029986EP+112] = [0X1.7A77BFCCF5A9DP-232, 0X1.921FB54442D19P+0]; atan [0X3.C5EC30FBB68C8P-508, 0X6.05C0BB1BCB730P-220] = [0X3.C5EC30FBB68C6P-508, 0X6.05C0BB1BCB730P-220]; atan [0XE.20FF41BD18058P-204, 0X2.9B09919BF9D9EP+272] = [0XE.20FF41BD18050P-204, 0X1.921FB54442D19P+0]; atan [0X2.075DF98B2478CP-456, 0X1.1503444763FC5P-416] = [0X2.075DF98B2478AP-456, 0X1.1503444763FC5P-416]; atan [0X1.5444E676976F1P+252, 0X2.7C064F6929234P+292] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; atan [0X1.3A01905E36F84P+0, 0X4.ECBC855871080P+332] = [0XE.3062E34353278P-4, 0X1.921FB54442D19P+0]; atan [0X2.404E44C49C644P-440, 0X7.32EDAB7F60A50P+236] = [0X2.404E44C49C642P-440, 0X1.921FB54442D19P+0]; atan [0X1.63A15E999EB64P-344, 0X6.5263CF84EF388P+172] = [0X1.63A15E999EB63P-344, 0X1.921FB54442D19P+0]; atan [0X6.941F470A70074P-756, 0X1.4171976A1CA54P-288] = [0X6.941F470A70070P-756, 0X1.4171976A1CA54P-288]; atan [0X7.78A1F475A306CP-564, 0X4.69BB1D34B9570P-76] = [0X7.78A1F475A3068P-564, 0X4.69BB1D34B9570P-76]; atan [0X1.BA04D452BBB35P+180, 0X1.F0D19ADCB5D74P+312] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; atan [0X2.6ABC15579B2B2P-48, 0X2.E046DB554037CP+256] = [0X2.6ABC15579B2B0P-48, 0X1.921FB54442D19P+0]; atan [0X8.297A99ED9ED08P+8, 0XE.33C49CF5B8790P+652] = [0X1.920057E3A66F1P+0, 0X1.921FB54442D19P+0]; atan [0X3.436DFE8F08194P+48, 0X2.A69A969772FDEP+688] = [0X1.921FB54442D13P+0, 0X1.921FB54442D19P+0]; atan [0X6.3E590E626451CP-172, 0X1.7AAA15EBBD3F2P+8] = [0X6.3E590E6264518P-172, 0X1.9172A3136EB8DP+0]; atan [0X6.ACFA418D8F92CP-544, 0X2.8F9204BC4041EP+988] = [0X6.ACFA418D8F928P-544, 0X1.921FB54442D19P+0]; atan [0X2.BB570B356C6CAP-440, 0X2.B00450A48D586P-148] = [0X2.BB570B356C6C8P-440, 0X2.B00450A48D586P-148]; atan [0XC.41329461A0C30P-512, 0X1.9E7DDBBE00F75P+352] = [0XC.41329461A0C28P-512, 0X1.921FB54442D19P+0]; atan [0X6.6978492A3064CP+188, 0XD.5E2045CEE9720P+236] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; atan [0X7.DEA605DEC97CCP-316, 0X1.5BD629B25AA23P-236] = [0X7.DEA605DEC97C8P-316, 0X1.5BD629B25AA23P-236]; atan [0XD.05E9CCF66CF58P+424, 0XB.A944253373080P+564] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; atan [0X6.65D7E0A247778P-56, 0X3.AE1DC13A652CAP+168] = [0X6.65D7E0A247774P-56, 0X1.921FB54442D19P+0]; atan [0X5.2B55801231EC8P-344, 0XA.27B4555158148P-68] = [0X5.2B55801231EC4P-344, 0XA.27B4555158148P-68]; atan [0X6.36B661DCE2688P-236, 0X1.D68A6BA7E617FP+12] = [0X6.36B661DCE2684P-236, 0X1.921700D14CFE5P+0]; atan [0X1.EB0E1AB78F314P-480, 0X1.98EF0C6A8BD66P+132] = [0X1.EB0E1AB78F313P-480, 0X1.921FB54442D19P+0]; atan [0X7.4CF193131FA64P-192, 0X1.C08152CC09416P+220] = [0X7.4CF193131FA60P-192, 0X1.921FB54442D19P+0]; atan [0X1.7036C237D5B00P-672, 0X6.F70E0DA4D2BA0P-140] = [0X1.7036C237D5AFFP-672, 0X6.F70E0DA4D2BA0P-140]; atan [0X1.D283CF8F05665P+252, 0XB.24D19E00C8460P+324] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; atan [0X3.A0EE84451C92CP-324, 0XF.CC937FA330E40P+648] = [0X3.A0EE84451C92AP-324, 0X1.921FB54442D19P+0]; atan [0X1.8BCA641025A83P-124, 0X5.F775993940188P-120] = [0X1.8BCA641025A82P-124, 0X5.F775993940188P-120]; acot [0X1.7A77BFCCF5A9EP-232, 0X2.8457BC029986EP+112] = [0X6.5B5B8AA0A6884P-116, 0X1.921FB54442D19P+0]; acot [0X3.C5EC30FBB68C8P-508, 0X6.05C0BB1BCB730P-220] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acot [0XE.20FF41BD18058P-204, 0X2.9B09919BF9D9EP+272] = [0X6.23FD67FFA09A4P-276, 0X1.921FB54442D19P+0]; acot [0X2.075DF98B2478CP-456, 0X1.1503444763FC5P-416] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acot [0X1.5444E676976F1P+252, 0X2.7C064F6929234P+292] = [0X6.70A3F8408ABF0P-296, 0XC.099B90EB0FA30P-256]; acot [0X1.3A01905E36F84P+0, 0X4.ECBC855871080P+332] = [0X3.3FB79247499D6P-336, 0XA.F1987100D9F08P-4]; acot [0X2.404E44C49C644P-440, 0X7.32EDAB7F60A50P+236] = [0X2.38F904C465F6AP-240, 0X1.921FB54442D19P+0]; acot [0X1.63A15E999EB64P-344, 0X6.5263CF84EF388P+172] = [0X2.87E9C09D98938P-176, 0X1.921FB54442D19P+0]; acot [0X6.941F470A70074P-756, 0X1.4171976A1CA54P-288] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acot [0X7.78A1F475A306CP-564, 0X4.69BB1D34B9570P-76] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acot [0X1.BA04D452BBB35P+180, 0X1.F0D19ADCB5D74P+312] = [0X8.3E949ACCB0F88P-316, 0X9.443E1DD721FE8P-184]; acot [0X2.6ABC15579B2B2P-48, 0X2.E046DB554037CP+256] = [0X5.9028FAA64FBC8P-260, 0X1.921FB54442CF2P+0]; acot [0X8.297A99ED9ED08P+8, 0XE.33C49CF5B8790P+652] = [0X1.2067D7F96AFE5P-656, 0X1.F5D609C62725FP-12]; acot [0X3.436DFE8F08194P+48, 0X2.A69A969772FDEP+688] = [0X6.09322FE56F794P-692, 0X4.E7223FE097808P-52]; acot [0X6.3E590E626451CP-172, 0X1.7AAA15EBBD3F2P+8] = [0XA.D1230D418C238P-12, 0X1.921FB54442D19P+0]; acot [0X6.ACFA418D8F92CP-544, 0X2.8F9204BC4041EP+988] = [0X6.3F7C8D3DDFC74P-992, 0X1.921FB54442D19P+0]; acot [0X2.BB570B356C6CAP-440, 0X2.B00450A48D586P-148] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acot [0XC.41329461A0C30P-512, 0X1.9E7DDBBE00F75P+352] = [0X9.E1C9C04F15630P-356, 0X1.921FB54442D19P+0]; acot [0X6.6978492A3064CP+188, 0XD.5E2045CEE9720P+236] = [0X1.326922CF32B2EP-240, 0X2.7ECD966556E9CP-192]; acot [0X7.DEA605DEC97CCP-316, 0X1.5BD629B25AA23P-236] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acot [0XD.05E9CCF66CF58P+424, 0XB.A944253373080P+564] = [0X1.5F401B7014200P-568, 0X1.3A84A0CB7AC42P-428]; acot [0X6.65D7E0A247778P-56, 0X3.AE1DC13A652CAP+168] = [0X4.59002C447A028P-172, 0X1.921FB54442D18P+0]; acot [0X5.2B55801231EC8P-344, 0XA.27B4555158148P-68] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acot [0X6.36B661DCE2688P-236, 0X1.D68A6BA7E617FP+12] = [0X8.B472F5D335130P-16, 0X1.921FB54442D19P+0]; acot [0X1.EB0E1AB78F314P-480, 0X1.98EF0C6A8BD66P+132] = [0XA.042BAEF7787B8P-136, 0X1.921FB54442D19P+0]; acot [0X7.4CF193131FA64P-192, 0X1.C08152CC09416P+220] = [0X9.21EF65D6A5190P-224, 0X1.921FB54442D19P+0]; acot [0X1.7036C237D5B00P-672, 0X6.F70E0DA4D2BA0P-140] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; acot [0X1.D283CF8F05665P+252, 0XB.24D19E00C8460P+324] = [0X1.6F8ED062CAC9BP-328, 0X8.C7ADFB6368868P-256]; acot [0X3.A0EE84451C92CP-324, 0XF.CC937FA330E40P+648] = [0X1.03413E0E19942P-652, 0X1.921FB54442D19P+0]; acot [0X1.8BCA641025A83P-124, 0X5.F775993940188P-120] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; sinh [-0X3.53DC9496DE0A0P-160, -0XC.287E0E10EC1B8P-960] = [-0X3.53DC9496DE0A2P-160, -0XC.287E0E10EC1B8P-960]; sinh [-0X1.CF3637DCBCC9AP-452, -0X5.E4846462FF33CP-636] = [-0X1.CF3637DCBCC9BP-452, -0X5.E4846462FF33CP-636]; sinh [-0X1.0362421843787P+0, -0X3.3D2CCEF698A5AP-972] = [-0X1.32197576F3697P+0, -0X3.3D2CCEF698A5AP-972]; sinh [-0X1.494A24A7585D1P-380, +0X1.A0790A9E3013EP-604] = [-0X1.494A24A7585D2P-380, +0X1.A0790A9E3013FP-604]; sinh [-0X2.B64BC5E999866P-368, -0XF.0633041110C28P-572] = [-0X2.B64BC5E999868P-368, -0XF.0633041110C28P-572]; sinh [-0X7.56F52F4FED854P-336, -0X4.F40A3934B3354P-416] = [-0X7.56F52F4FED858P-336, -0X4.F40A3934B3354P-416]; sinh [-0XA.0E33C2BA95C88P-48, -0X1.1927CA3847669P-808] = [-0XA.0E33C2BA95C90P-48, -0X1.1927CA3847669P-808]; sinh [-0X1.1BBBD6FE8B950P-208, -0X1.463A32DBA649DP-220] = [-0X1.1BBBD6FE8B951P-208, -0X1.463A32DBA649DP-220]; sinh [0X5.290FE84915530P-268, 0X1.8C9AF520C22C3P-96] = [0X5.290FE84915530P-268, 0X1.8C9AF520C22C4P-96]; sinh [-0X2.E7332C654ABB6P-384, -0X1.4363967367F55P-932] = [-0X2.E7332C654ABB8P-384, -0X1.4363967367F55P-932]; sinh [-0X1.55EBB1D70A46EP-592, +0X4.733FA51468530P-20] = [-0X1.55EBB1D70A46FP-592, +0X4.733FA51477038P-20]; sinh [-0X1.1B4B8388A3D92P-340, -0XD.51D4A3CE4C490P-600] = [-0X1.1B4B8388A3D93P-340, -0XD.51D4A3CE4C490P-600]; sinh [-0X4.21B73745BC4C0P-952, +0XD.E40D83923C3E0P-404] = [-0X4.21B73745BC4C4P-952, +0XD.E40D83923C3E8P-404]; sinh [-0X1.73D14FA7DA1CBP-504, +0X1.5B3AFEEB17A85P-28] = [-0X1.73D14FA7DA1CCP-504, +0X1.5B3AFEEB17A86P-28]; sinh [-0X3.3CD34997DF066P-320, -0X1.606C7BCE75819P-852] = [-0X3.3CD34997DF068P-320, -0X1.606C7BCE75819P-852]; sinh [-0XC.5356A56E59748P-516, -0X1.33B9A95C55513P-772] = [-0XC.5356A56E59750P-516, -0X1.33B9A95C55513P-772]; sinh [-0X5.FA887950A63CCP-588, -0X2.B707741B15478P-800] = [-0X5.FA887950A63D0P-588, -0X2.B707741B15478P-800]; sinh [-0X2.9476464AAE5BAP-548, +0X4.0734E17C026D4P-784] = [-0X2.9476464AAE5BCP-548, +0X4.0734E17C026D8P-784]; sinh [-0XF.A46AC05B0EAA8P-68, +0X1.EFA89F34F4188P-684] = [-0XF.A46AC05B0EAB0P-68, +0X1.EFA89F34F4189P-684]; sinh [-0X9.9488CB205AFA8P-124, -0X2.940180D1AA2AEP-556] = [-0X9.9488CB205AFB0P-124, -0X2.940180D1AA2AEP-556]; sinh [-0X3.F9D9FE5792CE0P-912, -0X3.F00FC8CE24ADCP-1016] = [-0X3.F9D9FE5792CE2P-912, -0X3.F00FC8CE24ADCP-1016]; sinh [-0X7.D5A28EF80D6B0P-176, +0XC.5D2B8FFCB2AD8P-756] = [-0X7.D5A28EF80D6B4P-176, +0XC.5D2B8FFCB2AE0P-756]; sinh [-0X5.B5DCAA821A628P-784, -0X1.48532232C10FDP-940] = [-0X5.B5DCAA821A62CP-784, -0X1.48532232C10FDP-940]; sinh [0X3.8110D13AB0378P-720, 0X2.77422E18981C2P-44] = [0X3.8110D13AB0378P-720, 0X2.77422E18981C4P-44]; sinh [-0X1.4AD562C0B5178P-380, +0X3.CEB34F40EA9BAP-792] = [-0X1.4AD562C0B5179P-380, +0X3.CEB34F40EA9BCP-792]; sinh [-0X7.ED02EF56E40B0P-92, -0X1.8C80275A696B0P-552] = [-0X7.ED02EF56E40B4P-92, -0X1.8C80275A696B0P-552]; sinh [-0X1.56FBE834FC822P-296, -0X3.66041558BACA8P-516] = [-0X1.56FBE834FC823P-296, -0X3.66041558BACA8P-516]; sinh [-0X6.44524F6FCCF8CP-340, -0X5.3E8ED576A1334P-896] = [-0X6.44524F6FCCF90P-340, -0X5.3E8ED576A1334P-896]; sinh [-0X8.92F5BEDA59C78P-268, +0X2.51B11C2EC76BAP-612] = [-0X8.92F5BEDA59C80P-268, +0X2.51B11C2EC76BCP-612]; sinh [-0X4.785C46BDC2A50P-244, -0X1.BA5C062DE8F00P-432] = [-0X4.785C46BDC2A54P-244, -0X1.BA5C062DE8F00P-432]; cosh [-0X3.53DC9496DE0A0P-160, -0XC.287E0E10EC1B8P-960] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0X1.CF3637DCBCC9AP-452, -0X5.E4846462FF33CP-636] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0X1.0362421843787P+0, -0X3.3D2CCEF698A5AP-972] = [0X1.0000000000000P+0, 0X1.8F0A39674B193P+0]; cosh [-0X1.494A24A7585D1P-380, +0X1.A0790A9E3013EP-604] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0X2.B64BC5E999866P-368, -0XF.0633041110C28P-572] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0X7.56F52F4FED854P-336, -0X4.F40A3934B3354P-416] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0XA.0E33C2BA95C88P-48, -0X1.1927CA3847669P-808] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0X1.1BBBD6FE8B950P-208, -0X1.463A32DBA649DP-220] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [0X5.290FE84915530P-268, 0X1.8C9AF520C22C3P-96] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0X2.E7332C654ABB6P-384, -0X1.4363967367F55P-932] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0X1.55EBB1D70A46EP-592, +0X4.733FA51468530P-20] = [0X1.0000000000000P+0, 0X1.0000000009E6FP+0]; cosh [-0X1.1B4B8388A3D92P-340, -0XD.51D4A3CE4C490P-600] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0X4.21B73745BC4C0P-952, +0XD.E40D83923C3E0P-404] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0X1.73D14FA7DA1CBP-504, +0X1.5B3AFEEB17A85P-28] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0X3.3CD34997DF066P-320, -0X1.606C7BCE75819P-852] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0XC.5356A56E59748P-516, -0X1.33B9A95C55513P-772] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0X5.FA887950A63CCP-588, -0X2.B707741B15478P-800] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0X2.9476464AAE5BAP-548, +0X4.0734E17C026D4P-784] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0XF.A46AC05B0EAA8P-68, +0X1.EFA89F34F4188P-684] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0X9.9488CB205AFA8P-124, -0X2.940180D1AA2AEP-556] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0X3.F9D9FE5792CE0P-912, -0X3.F00FC8CE24ADCP-1016] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0X7.D5A28EF80D6B0P-176, +0XC.5D2B8FFCB2AD8P-756] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0X5.B5DCAA821A628P-784, -0X1.48532232C10FDP-940] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [0X3.8110D13AB0378P-720, 0X2.77422E18981C2P-44] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0X1.4AD562C0B5178P-380, +0X3.CEB34F40EA9BAP-792] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0X7.ED02EF56E40B0P-92, -0X1.8C80275A696B0P-552] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0X1.56FBE834FC822P-296, -0X3.66041558BACA8P-516] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0X6.44524F6FCCF8CP-340, -0X5.3E8ED576A1334P-896] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0X8.92F5BEDA59C78P-268, +0X2.51B11C2EC76BAP-612] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; cosh [-0X4.785C46BDC2A50P-244, -0X1.BA5C062DE8F00P-432] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; tanh [0X1.7A77BFCCF5A9EP-232, 0X2.8457BC029986EP+112] = [0X1.7A77BFCCF5A9DP-232, 0X1.0000000000000P+0]; tanh [0X3.C5EC30FBB68C8P-508, 0X6.05C0BB1BCB730P-220] = [0X3.C5EC30FBB68C6P-508, 0X6.05C0BB1BCB730P-220]; tanh [0XE.20FF41BD18058P-204, 0X2.9B09919BF9D9EP+272] = [0XE.20FF41BD18050P-204, 0X1.0000000000000P+0]; tanh [0X2.075DF98B2478CP-456, 0X1.1503444763FC5P-416] = [0X2.075DF98B2478AP-456, 0X1.1503444763FC5P-416]; tanh [0X1.5444E676976F1P+252, 0X2.7C064F6929234P+292] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; tanh [0X1.3A01905E36F84P+0, 0X4.ECBC855871080P+332] = [0XD.772335E624B98P-4, 0X1.0000000000000P+0]; tanh [0X2.404E44C49C644P-440, 0X7.32EDAB7F60A50P+236] = [0X2.404E44C49C642P-440, 0X1.0000000000000P+0]; tanh [0X1.63A15E999EB64P-344, 0X6.5263CF84EF388P+172] = [0X1.63A15E999EB63P-344, 0X1.0000000000000P+0]; tanh [0X6.941F470A70074P-756, 0X1.4171976A1CA54P-288] = [0X6.941F470A70070P-756, 0X1.4171976A1CA54P-288]; tanh [0X7.78A1F475A306CP-564, 0X4.69BB1D34B9570P-76] = [0X7.78A1F475A3068P-564, 0X4.69BB1D34B9570P-76]; tanh [0X1.BA04D452BBB35P+180, 0X1.F0D19ADCB5D74P+312] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; tanh [0X2.6ABC15579B2B2P-48, 0X2.E046DB554037CP+256] = [0X2.6ABC15579B2B0P-48, 0X1.0000000000000P+0]; tanh [0X8.297A99ED9ED08P+8, 0XE.33C49CF5B8790P+652] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; tanh [0X3.436DFE8F08194P+48, 0X2.A69A969772FDEP+688] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; tanh [0X6.3E590E626451CP-172, 0X1.7AAA15EBBD3F2P+8] = [0X6.3E590E6264518P-172, 0X1.0000000000000P+0]; tanh [0X6.ACFA418D8F92CP-544, 0X2.8F9204BC4041EP+988] = [0X6.ACFA418D8F928P-544, 0X1.0000000000000P+0]; tanh [0X2.BB570B356C6CAP-440, 0X2.B00450A48D586P-148] = [0X2.BB570B356C6C8P-440, 0X2.B00450A48D586P-148]; tanh [0XC.41329461A0C30P-512, 0X1.9E7DDBBE00F75P+352] = [0XC.41329461A0C28P-512, 0X1.0000000000000P+0]; tanh [0X6.6978492A3064CP+188, 0XD.5E2045CEE9720P+236] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; tanh [0X7.DEA605DEC97CCP-316, 0X1.5BD629B25AA23P-236] = [0X7.DEA605DEC97C8P-316, 0X1.5BD629B25AA23P-236]; tanh [0XD.05E9CCF66CF58P+424, 0XB.A944253373080P+564] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; tanh [0X6.65D7E0A247778P-56, 0X3.AE1DC13A652CAP+168] = [0X6.65D7E0A247774P-56, 0X1.0000000000000P+0]; tanh [0X5.2B55801231EC8P-344, 0XA.27B4555158148P-68] = [0X5.2B55801231EC4P-344, 0XA.27B4555158148P-68]; tanh [0X6.36B661DCE2688P-236, 0X1.D68A6BA7E617FP+12] = [0X6.36B661DCE2684P-236, 0X1.0000000000000P+0]; tanh [0X1.EB0E1AB78F314P-480, 0X1.98EF0C6A8BD66P+132] = [0X1.EB0E1AB78F313P-480, 0X1.0000000000000P+0]; tanh [0X7.4CF193131FA64P-192, 0X1.C08152CC09416P+220] = [0X7.4CF193131FA60P-192, 0X1.0000000000000P+0]; tanh [0X1.7036C237D5B00P-672, 0X6.F70E0DA4D2BA0P-140] = [0X1.7036C237D5AFFP-672, 0X6.F70E0DA4D2BA0P-140]; tanh [0X1.D283CF8F05665P+252, 0XB.24D19E00C8460P+324] = [0XF.FFFFFFFFFFFF8P-4, 0X1.0000000000000P+0]; tanh [0X3.A0EE84451C92CP-324, 0XF.CC937FA330E40P+648] = [0X3.A0EE84451C92AP-324, 0X1.0000000000000P+0]; tanh [0X1.8BCA641025A83P-124, 0X5.F775993940188P-120] = [0X1.8BCA641025A82P-124, 0X5.F775993940188P-120]; coth [0X5.9D7EEEA9B9EE0P-264, 0X3.F03D06503CAA2P+92] = [0X1.0000000000000P+0, 0X2.D97240157D2C8P+260]; coth [-0X3.F03D06503CAA2P+92, -0X5.9D7EEEA9B9EE0P-264] = [-0X2.D97240157D2C8P+260, -0X1.0000000000000P+0]; coth [0XB.6600F238FE060P-520, 0X1.BB63631B595B0P-224] = [0X9.3CEA8A8C76FC0P+220, 0X1.6758D7D180F69P+516]; coth [-0X1.BB63631B595B0P-224, -0XB.6600F238FE060P-520] = [-0X1.6758D7D180F69P+516, -0X9.3CEA8A8C76FC0P+220]; coth [0X4.DC89ED0034C6CP-240, 0XD.A1D118A3891E8P+232] = [0X1.0000000000000P+0, 0X3.4A8AB6B06359AP+236]; coth [-0XD.A1D118A3891E8P+232, -0X4.DC89ED0034C6CP-240] = [-0X3.4A8AB6B06359AP+236, -0X1.0000000000000P+0]; coth [0X4.7F93F879A61A4P-492, 0X1.BDC6388153882P-452] = [0X9.3041F45FA3D78P+448, 0X3.8E8E46D77A03EP+488]; coth [-0X1.BDC6388153882P-452, -0X4.7F93F879A61A4P-492] = [-0X3.8E8E46D77A03EP+488, -0X9.3041F45FA3D78P+448]; coth [0XF.C7C928D9BB718P+192, 0X8.41A7954605A98P+224] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; coth [-0X8.41A7954605A98P+224, -0XF.C7C928D9BB718P+192] = [-0X1.0000000000001P+0, -0X1.0000000000000P+0]; coth [0X3.F07C0B8005270P-44, 0X2.DD3C8580FCBE0P+276] = [0X1.0000000000000P+0, 0X4.0FC1103283A70P+40]; coth [-0X2.DD3C8580FCBE0P+276, -0X3.F07C0B8005270P-44] = [-0X4.0FC1103283A70P+40, -0X1.0000000000000P+0]; coth [0XA.A97DED29FFF30P-480, 0X5.35EEA9C504860P+196] = [0X1.0000000000000P+0, 0X1.802A4F4EFE3B2P+476]; coth [-0X5.35EEA9C504860P+196, -0XA.A97DED29FFF30P-480] = [-0X1.802A4F4EFE3B2P+476, -0X1.0000000000000P+0]; coth [0X3.CF4B727451402P-376, 0X1.759F6C21DAF9AP+140] = [0X1.0000000000000P+0, 0X4.33233873998C8P+372]; coth [-0X1.759F6C21DAF9AP+140, -0X3.CF4B727451402P-376] = [-0X4.33233873998C8P+372, -0X1.0000000000000P+0]; coth [0X6.55376F4C1C50CP-772, 0X1.0120DD4EBC019P-328] = [0XF.EE06735C6D910P+324, 0X2.86C88F09A2CBEP+768]; coth [-0X1.0120DD4EBC019P-328, -0X6.55376F4C1C50CP-772] = [-0X2.86C88F09A2CBEP+768, -0XF.EE06735C6D910P+324]; coth [0X1.B63F1F7AED49EP-580, 0X2.245AF5BCB3356P-132] = [0X7.7838528478BF8P+128, 0X9.58A984202B8E8P+576]; coth [-0X2.245AF5BCB3356P-132, -0X1.B63F1F7AED49EP-580] = [-0X9.58A984202B8E8P+576, -0X7.7838528478BF8P+128]; coth [0X2.73B23CC8D8F76P+116, 0X1.F1E4F59403FC3P+276] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; coth [-0X1.F1E4F59403FC3P+276, -0X2.73B23CC8D8F76P+116] = [-0X1.0000000000001P+0, -0X1.0000000000000P+0]; coth [0X2.5B4F5F71CA5FCP-100, 0X1.5C244CE1AC6B3P+204] = [0X1.0000000000000P+0, 0X6.CA09D0DDC330CP+96]; coth [-0X1.5C244CE1AC6B3P+204, -0X2.5B4F5F71CA5FCP-100] = [-0X6.CA09D0DDC330CP+96, -0X1.0000000000000P+0]; coth [0X1.4E7212DD5ABB9P+4, 0XD.9F35E61FDF7E8P+592] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; coth [-0XD.9F35E61FDF7E8P+592, -0X1.4E7212DD5ABB9P+4] = [-0X1.0000000000001P+0, -0X1.0000000000000P+0]; coth [0X1.271B33491E515P+20, 0X2.B3031CF3AF4ECP+628] = [0X1.0000000000000P+0, 0X1.0000000000001P+0]; coth [-0X2.B3031CF3AF4ECP+628, -0X1.271B33491E515P+20] = [-0X1.0000000000001P+0, -0X1.0000000000000P+0]; coth [0X9.DB635E2FF52B0P-180, 0X2.AF04176524D06P-24] = [0X5.F646A7779F114P+20, 0X1.9F8AFAA8DBFF9P+176]; coth [-0X2.AF04176524D06P-24, -0X9.DB635E2FF52B0P-180] = [-0X1.9F8AFAA8DBFF9P+176, -0X5.F646A7779F114P+20]; asinh [0X1.7A77BFCCF5A9EP-232, 0X2.8457BC029986EP+112] = [0X1.7A77BFCCF5A9DP-232, 0X4.F3FA9CD060658P+4]; asinh [0X3.C5EC30FBB68C8P-508, 0X6.05C0BB1BCB730P-220] = [0X3.C5EC30FBB68C6P-508, 0X6.05C0BB1BCB730P-220]; asinh [0XE.20FF41BD18058P-204, 0X2.9B09919BF9D9EP+272] = [0XE.20FF41BD18050P-204, 0XB.E2FD554E373E0P+4]; asinh [0X2.075DF98B2478CP-456, 0X1.1503444763FC5P-416] = [0X2.075DF98B2478AP-456, 0X1.1503444763FC5P-416]; asinh [0X1.5444E676976F1P+252, 0X2.7C064F6929234P+292] = [0XA.FA69A93525138P+4, 0XC.C008F1DBA8390P+4]; asinh [0X1.3A01905E36F84P+0, 0X4.ECBC855871080P+332] = [0X1.086AFFAE230B6P+0, 0XE.8698B81E22AB0P+4]; asinh [0X2.404E44C49C644P-440, 0X7.32EDAB7F60A50P+236] = [0X2.404E44C49C642P-440, 0XA.63FF3E7D6B730P+4]; asinh [0X1.63A15E999EB64P-344, 0X6.5263CF84EF388P+172] = [0X1.63A15E999EB63P-344, 0X7.9C22B35B1CEE0P+4]; asinh [0X6.941F470A70074P-756, 0X1.4171976A1CA54P-288] = [0X6.941F470A70070P-756, 0X1.4171976A1CA54P-288]; asinh [0X7.78A1F475A306CP-564, 0X4.69BB1D34B9570P-76] = [0X7.78A1F475A3068P-564, 0X4.69BB1D34B9570P-76]; asinh [0X1.BA04D452BBB35P+180, 0X1.F0D19ADCB5D74P+312] = [0X7.E017D1421AED4P+4, 0XD.99E3CCF428D70P+4]; asinh [0X2.6ABC15579B2B2P-48, 0X2.E046DB554037CP+256] = [0X2.6ABC15579B2B0P-48, 0XB.331FC2BC20E70P+4]; //asinh [0X8.297A99ED9ED08P+8, 0XE.33C49CF5B8790P+652] = [0X8.567B3095B8380P+0, 0X1.C7474C3E00682P+8]; //asinh [0X3.436DFE8F08194P+48, 0X2.A69A969772FDEP+688] = [0X2.325A084AF897EP+4, 0X1.DE8DA2F064858P+8]; asinh [0X6.3E590E626451CP-172, 0X1.7AAA15EBBD3F2P+8] = [0X6.3E590E6264518P-172, 0X6.A13A85E654788P+0]; asinh [0X6.ACFA418D8F92CP-544, 0X2.8F9204BC4041EP+988] = [0X6.ACFA418D8F928P-544, 0X2.AE767FF2330E0P+8]; asinh [0X2.BB570B356C6CAP-440, 0X2.B00450A48D586P-148] = [0X2.BB570B356C6C8P-440, 0X2.B00450A48D586P-148]; asinh [0XC.41329461A0C30P-512, 0X1.9E7DDBBE00F75P+352] = [0XC.41329461A0C28P-512, 0XF.529AF3B8107E0P+4]; asinh [0X6.6978492A3064CP+188, 0XD.5E2045CEE9720P+236] = [0X8.4DCECB852E1E8P+4, 0XA.6DE648AA01A20P+4]; asinh [0X7.DEA605DEC97CCP-316, 0X1.5BD629B25AA23P-236] = [0X7.DEA605DEC97C8P-316, 0X1.5BD629B25AA23P-236]; //asinh [0XD.05E9CCF66CF58P+424, 0XB.A944253373080P+564] = [0X1.29277EA798036P+8, 0X1.8A159CCBD552AP+8]; asinh [0X6.65D7E0A247778P-56, 0X3.AE1DC13A652CAP+168] = [0X6.65D7E0A247774P-56, 0X7.671E008768830P+4]; asinh [0X5.2B55801231EC8P-344, 0XA.27B4555158148P-68] = [0X5.2B55801231EC4P-344, 0XA.27B4555158148P-68]; asinh [0X6.36B661DCE2688P-236, 0X1.D68A6BA7E617FP+12] = [0X6.36B661DCE2684P-236, 0X9.9E9F4F5A56088P+0]; asinh [0X1.EB0E1AB78F314P-480, 0X1.98EF0C6A8BD66P+132] = [0X1.EB0E1AB78F313P-480, 0X5.CA82DEDB3D320P+4]; asinh [0X7.4CF193131FA64P-192, 0X1.C08152CC09416P+220] = [0X7.4CF193131FA60P-192, 0X9.9BF0B87669850P+4]; asinh [0X1.7036C237D5B00P-672, 0X6.F70E0DA4D2BA0P-140] = [0X1.7036C237D5AFFP-672, 0X6.F70E0DA4D2BA0P-140]; asinh [0X1.D283CF8F05665P+252, 0XB.24D19E00C8460P+324] = [0XA.FF762A8B30EA0P+4, 0XE.3AF0836B2F5B0P+4]; //asinh [0X3.A0EE84451C92CP-324, 0XF.CC937FA330E40P+648] = [0X3.A0EE84451C92AP-324, 0X1.C49CCB25BBD50P+8]; asinh [0X1.8BCA641025A83P-124, 0X5.F775993940188P-120] = [0X1.8BCA641025A82P-124, 0X5.F775993940188P-120]; acosh [0X5.AD89AD14DDC74P+272, 0X2.6EC5D31670A5EP+860] = [0XB.EF73BF42C19D8P+4, 0X2.55B05064B6C2AP+8]; acosh [0X4.A457C35864940P+344, 0X2.3ADEFB54BC048P+444] = [0XF.0ABC113DB1AF0P+4, 0X1.3540A29BC6B5EP+8]; acosh [0X6.941C8B9506D90P+56, 0X3.B11D8083AE958P+744] = [0X2.964A9197BF832P+4, 0X2.05B3663FAE652P+8]; acosh [0X1.09A940A083EE3P+132, 0X1.047FD514ADF08P+384] = [0X5.C39C22D7AA908P+4, 0X1.0AE10BDF7FE81P+8]; acosh [0X7.710740B71A0D4P+256, 0XF.C0798D156BFA0P+560] = [0XB.42559B5CF34E8P+4, 0X1.879CCE87EE3A1P+8]; acosh [0X2.3721A01F70456P+564, 0X9.C62BBF31FD290P+728] = [0X1.886C6F1DDDFF7P+8, 0X1.FB958311209BFP+8]; acosh [0X6.F06D452BDCEF0P+44, 0X2.4825931366BBCP+520] = [0X2.120F95BD1F706P+4, 0X1.69F464545899AP+8]; acosh [0X5.D326D4B0883D8P+76, 0X1.77175C5A113ADP+528] = [0X3.7226BF0157930P+4, 0X1.6F0E8DBF98710P+8]; acosh [0X1.05ADFE119D4C2P+296, 0X2.6BCDF50E05E34P+1020] = [0XC.DE2FBE78FEC28P+4, 0X2.C49666459E1A4P+8]; acosh [0XA.7F5D255B81268P+408, 0X1.9D1EDDC132B36P+864] = [0X1.1DD92C82827A1P+8, 0X2.580D06072BF20P+8]; acosh [0XC.FBE4E2C6D0A80P+484, 0X4.DF75BDC17C330P+868] = [0X1.52BD770642386P+8, 0X2.5BEDB7E376E18P+8]; acosh [0XB.241032F9700A0P+380, 0X1.04A65B06B2920P+640] = [0X1.0A7FEC190CCEEP+8, 0X1.BC5349B021815P+8]; acosh [0X5.F207EAF5F8BB4P+608, 0XA.BC87C6F90AEE0P+648] = [0X1.A7E8C5069EA32P+8, 0X1.C439E5E8A511CP+8]; acosh [0X1.BCD62C46ADFD7P+16, 0XA.CD289B35ECD00P+564] = [0XC.56062C0C41518P+0, 0X1.8A0201556D85AP+8]; acosh [0X6.534BBA40A0B44P+224, 0X1.8DE35856E91FBP+452] = [0X9.DCD7CC0C7FFB8P+4, 0X1.3A6FC95911674P+8]; acosh [0X2.C4F59012F4E48P+508, 0X1.1854765A9A205P+688] = [0X1.61D49DF92AB79P+8, 0X1.DDAB5081E5A0EP+8]; acosh [0X8.6F890522C18B0P+44, 0X3.F87592D71E06CP+220] = [0X2.152F7D2DBF2BCP+4, 0X9.A907E7C701690P+4]; acosh [0X9.2A9035A578970P+124, 0X1.35EE42DCA8B75P+608] = [0X5.8DBE2A7E96990P+4, 0X1.A6515B9ECF2F1P+8]; acosh [0X5.2641115F86D38P+204, 0X7.BE33D080E6584P+252] = [0X8.FBBEB3B84C708P+4, 0XB.169BBE1313F68P+4]; acosh [0XA.8746F72A1BD90P+72, 0X5.6ABE29A315520P+872] = [0X3.4F42DBFC0E4B4P+4, 0X2.5ECE9922C7894P+8]; acosh [0XB.D0973FF704000P+224, 0X2.2FD9ABBD09D34P+976] = [0X9.E6D6EA0633070P+4, 0X2.A5FCBEDD15F2CP+8]; acosh [0XA.C15D51DB7D9F0P+536, 0X1.7207A70831D7AP+796] = [0X1.76986E964982DP+8, 0X2.28CE847F69DCAP+8]; acosh [0X4.280BEC7911E7CP+180, 0X6.B4F11E86ECA38P+792] = [0X7.EE261446DD5F8P+4, 0X2.27919F48F2C20P+8]; acosh [0X3.4B22674960B0EP+468, 0XA.505A061DF4CD8P+808] = [0X1.4647297977E4EP+8, 0X2.3316ED57009D4P+8]; acosh [0X2.383FC27D5E4E4P+756, 0X5.88E9C96565E54P+920] = [0X2.0D82822002358P+8, 0X2.801980299550CP+8]; acosh [0X1.20E762C8AAB55P+72, 0X1.DBB7B8FE35847P+960] = [0X3.2B87D37C9EAFAP+4, 0X2.9ABBED2A77E62P+8]; acosh [0X1.1265074E9E3DFP+792, 0X2.229B285A709C0P+920] = [0X2.25BC2FC876EBCP+8, 0X2.7F25A89FE16E6P+8]; acosh [0X1.054DCDEF21349P+436, 0X1.618994D07D9A7P+636] = [0X1.2EED02D819A15P+8, 0X1.B9DB8970CC5ECP+8]; acosh [0X4.5BE0D9A7FF0CCP+460, 0X2.6F2C55F16354AP+568] = [0X1.4103588C86AB6P+8, 0X1.8B4A572E180D4P+8]; acosh [0X9.BD8B9A7FB6630P+80, 0X2.AD5F8458C8722P+768] = [0X3.A6BD416FCCF70P+4, 0X2.1603D4EDCB36AP+8]; atanh [-0X3.11A309475E762P-164, -0XC.3784302E15500P-680] = [-0X3.11A309475E764P-164, -0XC.3784302E15500P-680]; atanh [-0X5.7DD17A4248D38P-280, -0X2.898FC0F386F74P-640] = [-0X5.7DD17A4248D3CP-280, -0X2.898FC0F386F74P-640]; atanh [-0XE.D83DCD7F564A0P-296, -0X1.62F61FBA0F40FP-764] = [-0XE.D83DCD7F564A8P-296, -0X1.62F61FBA0F40FP-764]; atanh [-0X1.67712A1E64C2CP-944, -0X1.C0102C4D258EFP-976] = [-0X1.67712A1E64C2DP-944, -0X1.C0102C4D258EFP-976]; atanh [0X2.E3D991AE84668P-728, 0X1.92C3C728CCF4AP-612] = [0X2.E3D991AE84668P-728, 0X1.92C3C728CCF4BP-612]; atanh [-0X1.BCD3FEB3B0175P-640, +0X1.BEBE69E3BF3C2P-536] = [-0X1.BCD3FEB3B0176P-640, +0X1.BEBE69E3BF3C3P-536]; atanh [-0X1.2469575189327P-372, -0X7.51C0C39F58A4CP-1008] = [-0X1.2469575189328P-372, -0X7.51C0C39F58A4CP-1008]; atanh [-0X1.C4D163A6CCCD9P-336, -0X1.3BEE6DAB70397P-796] = [-0X1.C4D163A6CCCDAP-336, -0X1.3BEE6DAB70397P-796]; atanh [-0X2.0FAE5DE90C98CP-896, -0X2.2079777EC2418P-976] = [-0X2.0FAE5DE90C98EP-896, -0X2.2079777EC2418P-976]; atanh [-0X1.08C248C37E53BP-816, +0X2.8C9F04EE5DE84P-948] = [-0X1.08C248C37E53CP-816, +0X2.8C9F04EE5DE86P-948]; atanh [-0X2.0002542B01474P-228, +0X2.4D59F217BF74CP-796] = [-0X2.0002542B01476P-228, +0X2.4D59F217BF74EP-796]; atanh [0XD.D4033889729A0P-844, 0X7.44451BF919D78P-556] = [0XD.D4033889729A0P-844, 0X7.44451BF919D7CP-556]; atanh [-0X2.08918B016995CP-64, +0X3.3FC26450C6E4AP-268] = [-0X2.08918B016995EP-64, +0X3.3FC26450C6E4CP-268]; atanh [-0X2.66C95BD8D7716P-388, +0X1.7E16B310F878AP-232] = [-0X2.66C95BD8D7718P-388, +0X1.7E16B310F878BP-232]; atanh [-0X3.D9C66BD30B774P-256, -0X4.A8C30F678CB68P-456] = [-0X3.D9C66BD30B776P-256, -0X4.A8C30F678CB68P-456]; atanh [-0X1.AA045CCB15AEDP-804, +0XD.450C473265610P-24] = [-0X1.AA045CCB15AEEP-804, +0XD.450C4732686C0P-24]; atanh [-0X2.23ADFA571FC3CP-344, -0X1.30D1074DC059EP-868] = [-0X2.23ADFA571FC3EP-344, -0X1.30D1074DC059EP-868]; atanh [-0X3.DFBC1A4BF3888P-68, -0X4.A89E39B247C84P-840] = [-0X3.DFBC1A4BF388AP-68, -0X4.A89E39B247C84P-840]; atanh [0X9.583064525D370P-496, 0X2.C67652F06A55EP-408] = [0X9.583064525D370P-496, 0X2.C67652F06A560P-408]; atanh [-0X3.38BF880EC3082P-304, -0X7.7B19877E536ACP-512] = [-0X3.38BF880EC3084P-304, -0X7.7B19877E536ACP-512]; atanh [-0X2.ADBF037238702P-44, +0X1.98DC940C3AE1EP-564] = [-0X2.ADBF037238704P-44, +0X1.98DC940C3AE1FP-564]; atanh [-0X4.E4A79C48B3A58P-328, +0XA.28B02E59D39D8P-856] = [-0X4.E4A79C48B3A5CP-328, +0XA.28B02E59D39E0P-856]; atanh [-0X6.80D3E87B911D8P-232, -0X2.3DF54212C46E4P-520] = [-0X6.80D3E87B911DCP-232, -0X2.3DF54212C46E4P-520]; atanh [-0X1.4E54C309C46F8P-480, +0X9.47E982AC83F98P-688] = [-0X1.4E54C309C46F9P-480, +0X9.47E982AC83FA0P-688]; atanh [-0X2.276202227A6DEP-808, +0X1.C53E9BA64FADFP-768] = [-0X2.276202227A6E0P-808, +0X1.C53E9BA64FAE0P-768]; atanh [-0X4.8E4B4D7BA6DD0P-212, -0X1.4B35284C1064BP-548] = [-0X4.8E4B4D7BA6DD4P-212, -0X1.4B35284C1064BP-548]; atanh [-0X3.5C52B8D9FF582P-248, -0X2.AF868D652B866P-912] = [-0X3.5C52B8D9FF584P-248, -0X2.AF868D652B866P-912]; atanh [0X1.6938CC5EE183AP-692, 0XB.F7A583AC38168P-664] = [0X1.6938CC5EE183AP-692, 0XB.F7A583AC38170P-664]; atanh [-0X3.68B35F23B2506P-560, +0X9.F9C9246D05138P-304] = [-0X3.68B35F23B2508P-560, +0X9.F9C9246D05140P-304]; atanh [-0XA.BDE70B6850EA0P-516, +0X2.BB76D5BF703FAP-1020] = [-0XA.BDE70B6850EA8P-516, +0X2.BB76D5BF703FCP-1020]; acoth [0X5.AD89AD14DDC78P+272, 0X2.6EC5D31670A60P+860] = [0X6.93B8C1A4ADA4CP-864, 0X2.D165505974CDCP-276]; acoth [-0X2.6EC5D31670A60P+860, -0X5.AD89AD14DDC78P+272] = [-0X2.D165505974CDCP-276, -0X6.93B8C1A4ADA4CP-864]; acoth [0X4.A457C35864944P+344, 0X2.3ADEFB54BC04AP+444] = [0X7.2CCCD8F3E4D84P-448, 0X3.726295CD6E028P-348]; acoth [-0X2.3ADEFB54BC04AP+444, -0X4.A457C35864944P+344] = [-0X3.726295CD6E028P-348, -0X7.2CCCD8F3E4D84P-448]; acoth [0X6.941C8B9506D98P+56, 0X3.B11D8083AE95CP+744] = [0X4.55780C09BB248P-748, 0X2.6EA0EC606D92CP-60]; acoth [-0X3.B11D8083AE95CP+744, -0X6.941C8B9506D98P+56] = [-0X2.6EA0EC606D92CP-60, -0X4.55780C09BB248P-748]; acoth [0X1.09A940A083EE4P+132, 0X1.047FD514ADF09P+384] = [0XF.B940FE60125C0P-388, 0XF.6B0B0DCA2D740P-136]; acoth [-0X1.047FD514ADF09P+384, -0X1.09A940A083EE4P+132] = [-0XF.6B0B0DCA2D740P-136, -0XF.B940FE60125C0P-388]; acoth [0X7.710740B71A0DCP+256, 0XF.C0798D156BFB0P+560] = [0X1.04086A3447A55P-564, 0X2.266CE7A905524P-260]; acoth [-0XF.C0798D156BFB0P+560, -0X7.710740B71A0DCP+256] = [-0X2.266CE7A905524P-260, -0X1.04086A3447A55P-564]; acoth [0X2.3721A01F70458P+564, 0X9.C62BBF31FD298P+728] = [0X1.A3110641EF7BCP-732, 0X7.38E97DB7ABD94P-568]; acoth [-0X9.C62BBF31FD298P+728, -0X2.3721A01F70458P+564] = [-0X7.38E97DB7ABD94P-568, -0X1.A3110641EF7BCP-732]; acoth [0X6.F06D452BDCEF8P+44, 0X2.4825931366BBEP+520] = [0X7.030E427A5F700P-524, 0X2.4E45C5E18EA0EP-48]; acoth [-0X2.4825931366BBEP+520, -0X6.F06D452BDCEF8P+44] = [-0X2.4E45C5E18EA0EP-48, -0X7.030E427A5F700P-524]; acoth [0X5.D326D4B0883DCP+76, 0X1.77175C5A113AEP+528] = [0XA.EB85BC1375C18P-532, 0X2.BF32E14DB1D26P-80]; acoth [-0X1.77175C5A113AEP+528, -0X5.D326D4B0883DCP+76] = [-0X2.BF32E14DB1D26P-80, -0XA.EB85BC1375C18P-532]; acoth [0X1.05ADFE119D4C3P+296, 0X2.6BCDF50E05E36P+1020] = [0X6.9BC8F6BE69A84P-1024, 0XF.A7190DED61120P-300]; acoth [-0X2.6BCDF50E05E36P+1020, -0X1.05ADFE119D4C3P+296] = [-0XF.A7190DED61120P-300, -0X6.9BC8F6BE69A84P-1024]; acoth [0XA.7F5D255B81270P+408, 0X1.9D1EDDC132B38P+864] = [0X9.EA2F16D4B51A8P-868, 0X1.8630054C790C6P-412]; acoth [-0X1.9D1EDDC132B38P+864, -0XA.7F5D255B81270P+408] = [-0X1.8630054C790C6P-412, -0X9.EA2F16D4B51A8P-868]; acoth [0XC.FBE4E2C6D0A90P+484, 0X4.DF75BDC17C334P+868] = [0X3.4891A2770DF7CP-872, 0X1.3B7754395DD7FP-488]; acoth [-0X4.DF75BDC17C334P+868, -0XC.FBE4E2C6D0A90P+484] = [-0X1.3B7754395DD7FP-488, -0X3.4891A2770DF7CP-872]; acoth [0XB.241032F9700A8P+380, 0X1.04A65B06B2921P+640] = [0XF.B6EE12E44E478P-644, 0X1.6FA7BD9AAC5D2P-384]; acoth [-0X1.04A65B06B2921P+640, -0XB.241032F9700A8P+380] = [-0X1.6FA7BD9AAC5D2P-384, -0XF.B6EE12E44E478P-644]; acoth [0X5.F207EAF5F8BB8P+608, 0XA.BC87C6F90AEE8P+648] = [0X1.7D8116060016CP-652, 0X2.B0EE9FA61C0DAP-612]; acoth [-0XA.BC87C6F90AEE8P+648, -0X5.F207EAF5F8BB8P+608] = [-0X2.B0EE9FA61C0DAP-612, -0X1.7D8116060016CP-652]; acoth [0X1.BCD62C46ADFD9P+16, 0XA.CD289B35ECD08P+564] = [0X1.7B35C74EEC020P-568, 0X9.35374E76B1BE8P-20]; acoth [-0XA.CD289B35ECD08P+564, -0X1.BCD62C46ADFD9P+16] = [-0X9.35374E76B1BE8P-20, -0X1.7B35C74EEC020P-568]; acoth [0X6.534BBA40A0B4CP+224, 0X1.8DE35856E91FDP+452] = [0XA.4B5AAEDFCE6A8P-456, 0X2.878CF52E5FBF8P-228]; acoth [-0X1.8DE35856E91FDP+452, -0X6.534BBA40A0B4CP+224] = [-0X2.878CF52E5FBF8P-228, -0XA.4B5AAEDFCE6A8P-456]; expm1 [-0X1.16CC0DF1540F5P+112, -0X1.B3E4076622F04P-232] = [-0X1.0000000000000P+0, -0X1.B3E4076622F03P-232]; expm1 [-0X2.42042B9A88438P-220, -0X2.A213429DB0508P-508] = [-0X2.42042B9A88438P-220, -0X2.A213429DB0506P-508]; expm1 [-0X2.0E2E40B15D814P+272, -0X1.5D74CFDA6B292P-200] = [-0X1.0000000000000P+0, -0X1.5D74CFDA6B291P-200]; expm1 [-0X2.0EA791886F712P-416, -0X3.FE66A8D1A3472P-456] = [-0X2.0EA791886F712P-416, -0X3.FE66A8D1A3470P-456]; //expm1 [-0X6.FF424CB26239CP+292, -0X2.89F6682121BA8P+252] = [-0X1.0000000000000P+0, -0X1.0000000000000P+0]; expm1 [-0X8.80EEFDF700148P+332, -0X1.C4E85E50A626DP+0] = [-0X1.0000000000000P+0, -0XD.45BCBA84EE268P-4]; expm1 [-0X6.CA83546563A5CP+236, -0X4.F0F28370909FCP-440] = [-0X1.0000000000000P+0, -0X4.F0F28370909F8P-440]; expm1 [-0X4.E60572D4FCFD0P+172, -0X1.EB095183538C8P-344] = [-0X1.0000000000000P+0, -0X1.EB095183538C7P-344]; expm1 [-0X2.7ED8954764B12P-288, -0X8.71DC22117BE90P-756] = [-0X2.7ED8954764B12P-288, -0X8.71DC22117BE88P-756]; expm1 [-0XD.CF39B8DD68B98P-76, -0X8.0205C5B1357B0P-564] = [-0XD.CF39B8DD68B98P-76, -0X8.0205C5B1357A8P-564]; //expm1 [-0X1.582D3AFB2C63DP+312, -0X5.08DC843E57ED4P+180] = [-0X1.0000000000000P+0, -0X1.0000000000000P+0]; expm1 [-0X4.AF296DD37FD74P+256, -0X5.CBE2BD423B02CP-48] = [-0X1.0000000000000P+0, -0X5.CBE2BD423AF1CP-48]; expm1 [-0X1.1FBA2D1252D2BP+656, -0X2.4B7A4095C91B4P+8] = [-0X1.0000000000000P+0, -0XF.FFFFFFFFFFFF8P-4]; //expm1 [-0X3.2FD3FDE325402P+688, -0X2.738623C238270P+48] = [-0X1.0000000000000P+0, -0X1.0000000000000P+0]; expm1 [-0X1.44F2134E1901EP+8, -0X2.581DAD9AFE6DCP-172] = [-0X1.0000000000000P+0, -0X2.581DAD9AFE6DAP-172]; expm1 [-0X2.9529E333F2ABAP+988, -0X7.19390F862F49CP-544] = [-0X1.0000000000000P+0, -0X7.19390F862F498P-544]; expm1 [-0X1.58391FD92C387P-148, -0X4.0C12426A57194P-440] = [-0X1.58391FD92C387P-148, -0X4.0C12426A57190P-440]; expm1 [-0XB.FADC4FB83E140P+348, -0XF.13E388B2165F0P-512] = [-0X1.0000000000000P+0, -0XF.13E388B2165E8P-512]; //expm1 [-0XD.F2552B8F60978P+236, -0X7.FBDBC320979A4P+188] = [-0X1.0000000000000P+0, -0X1.0000000000000P+0]; expm1 [-0X8.86826CE1AB700P-240, -0X4.FEA8D3A3ED018P-316] = [-0X8.86826CE1AB700P-240, -0X4.FEA8D3A3ED014P-316]; expm1 [0X1.0000000000000P+0, 0X2.0000000000000P+0] = [0X1.B7E151628AED2P+0, 0X6.63992E35376B8P+0]; expm1 [-0X1.0000000000000P+0, +0X2.0000000000000P+0] = [-0XA.1D2A7274C4328P-4, +0X6.63992E35376B8P+0]; expm1 [-0X5.0000000000000P+0, -0X3.0000000000000P+0] = [-0XF.E466C01FF2AD0P-4, -0XF.341279998A7A8P-4]; expm1 [-0X2.0000000000000P+0, +0X9.9999999999998P-4] = [-0XD.D5AAAB880FC70P-4, +0XD.27660B11A9EF8P-4]; expm1 [0X4.0000000000000P-1076, 0X4.4444400000000P-1056] = [0X4.0000000000000P-1076, 0X4.4444800000000P-1056]; expm1 [0X4.4440000000000P-1064, 0X1.0000000000000P+0] = [0X4.4440000000000P-1064, 0X1.B7E151628AED3P+0]; expm1 [-0X4.4444000000000P-1060, +0X4.4444000000000P-1060] = [-0X4.4444000000000P-1060, +0X4.4448000000000P-1060]; expm1 [-0X4.4400000000000P-1068, +0X1.FFF0000000000P+0] = [-0X4.4400000000000P-1068, +0X6.6322F8540CFB4P+0]; expm1 [-0X1.FFFF000000000P+0, -0X8.8888880000000P-1052] = [-0XD.D5A88131A6240P-4, -0X8.8888840000000P-1052]; expm1 [-0X1.FFFFFFF000000P+0, +0X8.CD11555400000P-1044] = [-0XD.D5AAAB656A718P-4, +0X8.CD11555800000P-1044]; logp1 [0XC.4B4A6EB6B3AF0P-264, 0XA.DD2C4C1BE4B30P+92] = [0XC.4B4A6EB6B3AE8P-264, 0X4.227AD8183FB70P+4]; logp1 [0X2.6213E21B14894P-516, 0X6.6606F0995E5F4P-224] = [0X2.6213E21B14892P-516, 0X6.6606F0995E5F4P-224]; logp1 [0X9.0FF2CAA1B3048P-240, 0X1.95F14B9BA7449P+236] = [0X9.0FF2CAA1B3040P-240, 0XA.40B346F454218P+4]; logp1 [0X8.E2ADA8DFBE938P-492, 0X3.67CB3BE0BB146P-452] = [0X8.E2ADA8DFBE930P-492, 0X3.67CB3BE0BB146P-452]; logp1 [0X1.394270BBCBA7EP+196, 0X8.4976F0BF45A40P+224] = [0X8.80F0717A1DC40P+4, 0X9.D6130F01F8B78P+4]; logp1 [0X6.A000A12839A50P-44, 0X3.86DC59439415AP+276] = [0X6.A000A1283845CP-44, 0XC.091AAD1207058P+4]; logp1 [0X1.3C84E4F9C80CEP-476, 0X9.1E9439C3B4358P+196] = [0X1.3C84E4F9C80CDP-476, 0X8.A1137BDE55CF8P+4]; logp1 [0X8.41D2DB6D93548P-376, 0X2.EDCF4A7919034P+140] = [0X8.41D2DB6D93540P-376, 0X6.21D80D9193AB8P+4]; logp1 [0X1.2C18FEEBCAEAEP-768, 0X1.C369E759DF5E3P-328] = [0X1.2C18FEEBCAEADP-768, 0X1.C369E759DF5E3P-328]; logp1 [0X4.D94E91619D3F0P-580, 0X2.9F6CAF6B5513EP-132] = [0X4.D94E91619D3ECP-580, 0X2.9F6CAF6B5513EP-132]; logp1 [0X2.9CD12C1D0AAC4P+116, 0X3.BF7E0E52DC1AAP+276] = [0X5.15D8B410E0A5CP+4, 0XC.0A13DC536CD58P+4]; logp1 [0X3.36DE5C55594EEP-100, 0X1.D0460177B1553P+204] = [0X3.36DE5C55594ECP-100, 0X8.DFF506FE0D9F8P+4]; logp1 [0X4.BD4031736F7A8P+4, 0XF.A10BB3C91C7B0P+592] = [0X4.5771391F308D8P+0, 0X1.9D179EA5204D0P+8]; logp1 [0X2.8E258DB3C44F8P+20, 0X3.1A4EDE719A4C0P+628] = [0XE.CD14C501247C0P+0, 0X1.B46DC0D02B874P+8]; logp1 [0X2.33950F38F830EP-176, 0X5.BE0388619B018P-24] = [0X2.33950F38F830CP-176, 0X5.BE0377E504F78P-24]; logp1 [0X3.24F03DF33568CP-560, 0XE.67255823421E8P+920] = [0X3.24F03DF33568AP-560, 0X2.805CE2DC91036P+8]; logp1 [0X2.D572639DC5FA8P-468, 0X1.95CF42AA171CDP-160] = [0X2.D572639DC5FA6P-468, 0X1.95CF42AA171CDP-160]; logp1 [0X4.705A028302DB0P-532, 0X2.E57341C14970CP+324] = [0X4.705A028302DACP-532, 0XE.1A4A3523F2658P+4]; logp1 [0X4.DBA1D21D6F308P+144, 0X3.667988C57865AP+196] = [0X6.564D09AD1D214P+4, 0X8.914A9531FD118P+4]; logp1 [0X4.9FA5A1E4DF740P-328, 0X1.11B85141B78F6P-240] = [0X4.9FA5A1E4DF73CP-328, 0X1.11B85141B78F6P-240]; logp1 [0XA.0CDE9DC015B08P+360, 0XF.99D84F862AC58P+524] = [0XF.BD7308ED73FF0P+4, 0X1.6DF4DA39DC5DDP+8]; logp1 [0X6.88441038D56B8P-108, 0X3.3D65C09938132P+136] = [0X6.88441038D56B4P-108, 0X5.F718BBF0CE2F8P+4]; logp1 [0X7.1761CAB055134P-356, 0X1.92EFD09488689P-76] = [0X7.1761CAB055130P-356, 0X1.92EFD09488689P-76]; logp1 [0X6.2085E427413C8P-252, 0XB.8CDD3B024EA10P-36] = [0X6.2085E427413C4P-252, 0XB.8CDD3AFE235D0P-36]; logp1 [0XB.F5F1C0FA33978P-504, 0X4.924DD8D50B1CCP+72] = [0XB.F5F1C0FA33970P-504, 0X3.36D2B121508A8P+4]; logp1 [0XB.BC7E37EB2D388P-216, 0X1.CFE27BB53DEBBP+192] = [0XB.BC7E37EB2D380P-216, 0X8.5ADC069F618A8P+4]; logp1 [0X1.E139DD116F868P-688, 0XD.2545346D68FD0P-148] = [0X1.E139DD116F867P-688, 0XD.2545346D68FD0P-148]; logp1 [0X2.E0C8E64A890ACP+192, 0X2.6A898D2CAA9A4P+260] = [0X8.6243148F46208P+4, 0XB.519B6E544F898P+4]; logp1 [0X5.9C4642ED78BC8P-340, 0X4.631BD2232F0C0P+588] = [0X5.9C4642ED78BC4P-340, 0X1.990C99B6124FEP+8]; logp1 [0XF.C05EA810DFE88P-180, 0XA.05884FBED5F48P-152] = [0XF.C05EA810DFE80P-180, 0XA.05884FBED5F48P-152]; sqrt [0XC.4B4A6EB6B3AF0P-264, 0XA.DD2C4C1BE4B30P+92] = [0X3.819C8C44FCAE8P-132, 0XD.2F2830FA93228P+44]; sqrt [0X2.6213E21B14894P-516, 0X6.6606F0995E5F4P-224] = [0X6.2CC8B5D1B7648P-260, 0X2.878F8E10E2752P-112]; sqrt [0X9.0FF2CAA1B3048P-240, 0X1.95F14B9BA7449P+236] = [0X3.02A74AB0BBF36P-120, 0X5.0979194446A10P+116]; sqrt [0X8.E2ADA8DFBE938P-492, 0X3.67CB3BE0BB146P-452] = [0XB.EC63BFE10BCC8P-248, 0X7.61AC89CF17804P-228]; sqrt [0X1.394270BBCBA7EP+196, 0X8.4976F0BF45A40P+224] = [0X4.6CBEB2D8F6718P+96, 0X2.E0F32319AC30AP+112]; sqrt [0X6.A000A12839A50P-44, 0X3.86DC59439415AP+276] = [0XA.4BAEE7F482900P-24, 0X7.830C8D5A5F3D8P+136]; sqrt [0X1.3C84E4F9C80CEP-476, 0X9.1E9439C3B4358P+196] = [0X4.729F7C344CE30P-240, 0XC.14519D6697FF0P+96]; sqrt [0X8.41D2DB6D93548P-376, 0X2.EDCF4A7919034P+140] = [0X2.DF9F14A64C77AP-188, 0X6.D87D667089BD8P+68]; sqrt [0X1.2C18FEEBCAEAEP-768, 0X1.C369E759DF5E3P-328] = [0X1.152C585EDDB6AP-384, 0X1.53F1A81CAA4A0P-164]; sqrt [0X4.D94E91619D3F0P-580, 0X2.9F6CAF6B5513EP-132] = [0X8.CEDC2135E05E8P-292, 0X6.7A5BEF2579C34P-68]; sqrt [0X2.9CD12C1D0AAC4P+116, 0X3.BF7E0E52DC1AAP+276] = [0X6.7722C88D985D8P+56, 0X7.BE7173245A668P+136]; sqrt [0X3.36DE5C55594EEP-100, 0X1.D0460177B1553P+204] = [0X7.2BE248A308D24P-52, 0X5.630224B50BCF8P+100]; sqrt [0X4.BD4031736F7A8P+4, 0XF.A10BB3C91C7B0P+592] = [0X8.B53B61217B4F8P+0, 0X3.F40FA54A699E2P+296]; sqrt [0X2.8E258DB3C44F8P+20, 0X3.1A4EDE719A4C0P+628] = [0X6.64E1F64817930P+8, 0X7.0BBE006E8934CP+312]; sqrt [0X2.33950F38F830EP-176, 0X5.BE0388619B018P-24] = [0X1.7BD69462CDAD2P-88, 0X2.6573BFB248EF0P-12]; sqrt [0X3.24F03DF33568CP-560, 0XE.67255823421E8P+920] = [0X1.C5F168118C2B1P-280, 0X3.CB8CCAD62ED10P+460]; sqrt [0X2.D572639DC5FA8P-468, 0X1.95CF42AA171CDP-160] = [0X6.BBC8A036CC930P-236, 0X1.4250C275A7B2BP-80]; sqrt [0X4.705A028302DB0P-532, 0X2.E57341C14970CP+324] = [0X8.6D6D9A3EA2160P-268, 0X6.CEB17F56F1B50P+160]; sqrt [0X4.DBA1D21D6F308P+144, 0X3.667988C57865AP+196] = [0X2.343E215EB2264P+72, 0X7.603E67F0E1DD0P+96]; sqrt [0X4.9FA5A1E4DF740P-328, 0X1.11B85141B78F6P-240] = [0X2.26777C4E368BEP-164, 0X1.08B63617A4210P-120]; sqrt [0XA.0CDE9DC015B08P+360, 0XF.99D84F862AC58P+524] = [0X3.2B934CDCC29E0P+180, 0XF.CC99981010AD0P+260]; sqrt [0X6.88441038D56B8P-108, 0X3.3D65C09938132P+136] = [0XA.392C9B2283838P-56, 0X1.CCC9C68E6B873P+68]; sqrt [0X7.1761CAB055134P-356, 0X1.92EFD09488689P-76] = [0XA.A6DE001E1A878P-180, 0X5.04B0B42B185F4P-40]; sqrt [0X6.2085E427413C8P-252, 0XB.8CDD3B024EA10P-36] = [0X9.E6B17DD90B818P-128, 0XD.9821AE0A3F288P-20]; sqrt [0XB.F5F1C0FA33978P-504, 0X4.924DD8D50B1CCP+72] = [0X3.755B7F9B147FCP-252, 0X2.235AF64AA2532P+36]; sqrt [0XB.BC7E37EB2D388P-216, 0X1.CFE27BB53DEBBP+192] = [0X3.6D0318CB65970P-108, 0X1.589B93C7CC280P+96]; sqrt [0X1.E139DD116F868P-688, 0XD.2545346D68FD0P-148] = [0X1.5EFD65C23F515P-344, 0XE.80B36809CA340P-76]; sqrt [0X2.E0C8E64A890ACP+192, 0X2.6A898D2CAA9A4P+260] = [0X1.B24CEBB3D4B84P+96, 0X6.37B4CD9068634P+128]; sqrt [0X5.9C4642ED78BC8P-340, 0X4.631BD2232F0C0P+588] = [0X9.797C4D6802170P-172, 0X8.60D1F01F1A8D8P+292]; sqrt [0XF.C05EA810DFE88P-180, 0XA.05884FBED5F48P-152] = [0XF.E00F72E6C82F8P-92, 0X3.2A6AD8ACFCBB0P-76]; sqr [-0XA.644C9D88EA8C8P-152, -0XD.8EC7927926F18P-944] = [0X0.0000000000000P+0, 0X6.BFD4840B33478P-300]; sqr [-0X1.9EE1A9DB994F5P-436, -0X6.D914701C82FECP-624] = [0X0.0000000000000P+0, 0X2.A05EA84E4893CP-872]; sqr [-0X5.65057F3EFFC60P+4, -0X2.3617CF5815ECAP-960] = [0X0.0000000000000P+0, 0X1.D1A144EFBEB44P+12]; sqr [-0X1.975299CCB0E08P-372, +0XB.BEC7D35B45B00P-588] = [0X0.0000000000000P+0, 0X2.8817BFAFBDF18P-744]; sqr [-0X3.51D388D47AED2P-356, -0X1.C3A9CD7025105P-564] = [0X0.0000000000000P+0, 0XB.051CC05C2EBE0P-712]; sqr [-0XC.DB363268CF708P-332, -0X2.171B7D7BFE4E0P-412] = [0X4.5E83E96FF693CP-824, 0XA.548CA7F8C13A0P-660]; sqr [-0X1.32690AAC2472DP-40, -0X8.706EBDCF39C88P-792] = [0X0.0000000000000P+0, 0X1.6EBF489D48CA5P-80]; sqr [-0X5.0145AF0C53324P-200, -0X2.F5A0CB3301856P-204] = [0X8.C23056BA480A8P-408, 0X1.90CBA74D12CF4P-396]; sqr [0XF.4077C7E8CD6A0P-268, 0X3.753426098AC5AP-80] = [0XE.89E458947EFA8P-532, 0XB.F4E1999D73020P-160]; sqr [-0XB.B25F8D8BB7FB8P-376, -0X2.017A332F9B05CP-916] = [0X0.0000000000000P+0, 0X8.8D07F2E827770P-748]; sqr [-0XD.947CA427FDFE0P-592, +0XE.3BE493B5BC8E8P-16] = [0X0.0000000000000P+0, 0XC.A9B03500DD578P-28]; sqr [-0X9.C46198B2471F0P-336, -0X1.65ED85DF2D4B7P-576] = [0X0.0000000000000P+0, 0X5.F6582538F0F44P-668]; sqr [-0X3.2C867C027DB44P-936, +0X6.1883EA827AB6CP-388] = [0X0.0000000000000P+0, 0X2.52887FE100FF0P-772]; sqr [-0X3.560EF91C47DEAP-492, +0X5.413664DD17ABCP-20] = [0X0.0000000000000P+0, 0X1.B9CBC9B69E7BFP-36]; sqr [-0X8.36BFCD74A6D68P-304, -0X3.2C20EB130D510P-836] = [0X0.0000000000000P+0, 0X4.377B251ABDCC0P-604]; sqr [-0X6.BCEC84603958CP-500, -0X1.068B13DA99666P-760] = [0X0.0000000000000P+0, 0X2.D668271745A42P-996]; sqr [-0X1.2789C2D583BCDP-568, -0X1.F2BD89DAD0665P-780] = [0X0.0000000000000P+0, 0X4.0000000000000P-1076]; sqr [-0XC.FE4E8D857E3E0P-548, +0X1.580844B9DC45CP-780] = [0X0.0000000000000P+0, 0X4.0000000000000P-1076]; sqr [-0XC.508D29ACB01B8P-52, +0X1.B1E6B793078DDP-664] = [0X0.0000000000000P+0, 0X9.7A69470135FA8P-100]; sqr [-0XA.12F7783880A78P-124, -0X3.765DF69EE106EP-548] = [0X0.0000000000000P+0, 0X6.57CBD208B34ACP-244]; sqr [-0X6.3A58D52FDF844P-896, -0X1.039E2518CF503P-1008] = [0X0.0000000000000P+0, 0X4.0000000000000P-1076]; sqr [-0XB.DD3171FDEEC18P-168, +0X1.069E434EE9E0FP-740] = [0X0.0000000000000P+0, 0X8.CC15E342FC8D8P-332]; sqr [-0X3.CF0053257533AP-776, -0X1.7883A587654E5P-928] = [0X0.0000000000000P+0, 0X4.0000000000000P-1076]; sqr [0X1.455801D3D2B63P-704, 0X3.A4C915783D07AP-28] = [0X0.0000000000000P+0, 0XD.46C8C24634FC8P-56]; sqr [-0X2.097D06F4DE3E2P-376, +0X2.2E7561FD9255EP-772] = [0X0.0000000000000P+0, 0X4.264E23607BEA8P-752]; sqr [-0X1.7E13DBB66E5A3P-84, -0X6.BC8F45D6A8F48P-540] = [0X0.0000000000000P+0, 0X2.3A3F453ECAFB4P-168]; sqr [-0X4.1F50C5F2CDA54P-276, -0X3.DF16F79756422P-496] = [0XE.FCF2D2F52B4C0P-992, 0X1.0FE5AD9038BC9P-548]; sqr [-0X7.ECC4C5EEC4CACP-328, -0X2.E02E1DB7A08F6P-876] = [0X0.0000000000000P+0, 0X3.ECDBE373EAC94P-652]; sqr [-0XC.1BC7A4C89D440P-256, +0X2.A7F56252D1D34P-608] = [0X0.0000000000000P+0, 0X9.29DBB2B42A988P-508]; sqr [-0XB.CE50D7B2F2868P-236, -0XE.6B08988339B80P-432] = [0XC.FE1B0DE21E568P-860, 0X8.B6138BE0C5B78P-468]; } interval-1.4.1/test/libieeep1788_tests_bool.itl0000644000000000000000000004437112657475772017562 0ustar 00000000000000/* Copyright 2013-2015 Marco Nehmeier (nehmeier@informatik.uni-wuerzburg.de) Copyright 2015-2016 Oliver Heimlich Original author: Marco Nehmeier (unit tests in libieeep1788, original license: Apache License 2.0) Converted into portable ITL format by Oliver Heimlich with minor corrections. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ testcase minimal_empty_test { isEmpty [empty] = true; isEmpty [-infinity,+infinity] = false; isEmpty [1.0,2.0] = false; isEmpty [-1.0,2.0] = false; isEmpty [-3.0,-2.0] = false; isEmpty [-infinity,2.0] = false; isEmpty [-infinity,0.0] = false; isEmpty [-infinity,-0.0] = false; isEmpty [0.0,infinity] = false; isEmpty [-0.0,infinity] = false; isEmpty [-0.0,0.0] = false; isEmpty [0.0,-0.0] = false; isEmpty [0.0,0.0] = false; isEmpty [-0.0,-0.0] = false; } testcase minimal_empty_dec_test { isEmpty [empty]_trv = true; isEmpty [-infinity,+infinity]_def = false; isEmpty [1.0,2.0]_com = false; isEmpty [-1.0,2.0]_trv = false; isEmpty [-3.0,-2.0]_dac = false; isEmpty [-infinity,2.0]_trv = false; isEmpty [-infinity,0.0]_trv = false; isEmpty [-infinity,-0.0]_trv = false; isEmpty [0.0,infinity]_def = false; isEmpty [-0.0,infinity]_trv = false; isEmpty [-0.0,0.0]_com = false; isEmpty [0.0,-0.0]_trv = false; isEmpty [0.0,0.0]_trv = false; isEmpty [-0.0,-0.0]_trv = false; } testcase minimal_entire_test { isEntire [empty] = false; isEntire [-infinity,+infinity] = true; isEntire [1.0,2.0] = false; isEntire [-1.0,2.0] = false; isEntire [-3.0,-2.0] = false; isEntire [-infinity,2.0] = false; isEntire [-infinity,0.0] = false; isEntire [-infinity,-0.0] = false; isEntire [0.0,infinity] = false; isEntire [-0.0,infinity] = false; isEntire [-0.0,0.0] = false; isEntire [0.0,-0.0] = false; isEntire [0.0,0.0] = false; isEntire [-0.0,-0.0] = false; } testcase minimal_entire_dec_test { isEntire [empty]_trv = false; isEntire [-infinity,+infinity]_trv = true; isEntire [-infinity,+infinity]_def = true; isEntire [-infinity,+infinity]_dac = true; isEntire [1.0,2.0]_com = false; isEntire [-1.0,2.0]_trv = false; isEntire [-3.0,-2.0]_dac = false; isEntire [-infinity,2.0]_trv = false; isEntire [-infinity,0.0]_trv = false; isEntire [-infinity,-0.0]_trv = false; isEntire [0.0,infinity]_def = false; isEntire [-0.0,infinity]_trv = false; isEntire [-0.0,0.0]_com = false; isEntire [0.0,-0.0]_trv = false; isEntire [0.0,0.0]_trv = false; isEntire [-0.0,-0.0]_trv = false; } testcase minimal_nai_dec_test { isNaI [-infinity,+infinity]_trv = false; isNaI [-infinity,+infinity]_def = false; isNaI [-infinity,+infinity]_dac = false; isNaI [1.0,2.0]_com = false; isNaI [-1.0,2.0]_trv = false; isNaI [-3.0,-2.0]_dac = false; isNaI [-infinity,2.0]_trv = false; isNaI [-infinity,0.0]_trv = false; isNaI [-infinity,-0.0]_trv = false; isNaI [0.0,infinity]_def = false; isNaI [-0.0,infinity]_trv = false; isNaI [-0.0,0.0]_com = false; isNaI [0.0,-0.0]_trv = false; isNaI [0.0,0.0]_trv = false; isNaI [-0.0,-0.0]_trv = false; } testcase minimal_equal_test { equal [1.0,2.0] [1.0,2.0] = true; equal [1.0,2.1] [1.0,2.0] = false; equal [empty] [empty] = true; equal [empty] [1.0,2.0] = false; equal [-infinity,+infinity] [-infinity,+infinity] = true; equal [1.0,2.4] [-infinity,+infinity] = false; equal [1.0,infinity] [1.0,infinity] = true; equal [1.0,2.4] [1.0,infinity] = false; equal [-infinity,2.0] [-infinity,2.0] = true; equal [-infinity,2.4] [-infinity,2.0] = false; equal [-2.0,0.0] [-2.0,0.0] = true; equal [-0.0,2.0] [0.0,2.0] = true; equal [-0.0,-0.0] [0.0,0.0] = true; equal [-0.0,0.0] [0.0,0.0] = true; equal [0.0,-0.0] [0.0,0.0] = true; } testcase minimal_equal_dec_test { equal [1.0,2.0]_def [1.0,2.0]_trv = true; equal [1.0,2.1]_trv [1.0,2.0]_trv = false; equal [empty]_trv [empty]_trv = true; equal [empty]_trv [1.0,2.0]_trv = false; equal [empty]_trv [1.0,2.0]_trv = false; equal [-infinity,+infinity]_def [-infinity,+infinity]_trv = true; equal [1.0,2.4]_trv [-infinity,+infinity]_trv = false; equal [1.0,infinity]_trv [1.0,infinity]_trv = true; equal [1.0,2.4]_def [1.0,infinity]_trv = false; equal [-infinity,2.0]_trv [-infinity,2.0]_trv = true; equal [-infinity,2.4]_def [-infinity,2.0]_trv = false; equal [-2.0,0.0]_trv [-2.0,0.0]_trv = true; equal [-0.0,2.0]_def [0.0,2.0]_trv = true; equal [-0.0,-0.0]_trv [0.0,0.0]_trv = true; equal [-0.0,0.0]_def [0.0,0.0]_trv = true; equal [0.0,-0.0]_trv [0.0,0.0]_trv = true; } testcase minimal_subset_test { subset [empty] [empty] = true; subset [empty] [0.0,4.0] = true; subset [empty] [-0.0,4.0] = true; subset [empty] [-0.1,1.0] = true; subset [empty] [-0.1,0.0] = true; subset [empty] [-0.1,-0.0] = true; subset [empty] [-infinity,+infinity] = true; subset [0.0,4.0] [empty] = false; subset [-0.0,4.0] [empty] = false; subset [-0.1,1.0] [empty] = false; subset [-infinity,+infinity] [empty] = false; subset [0.0,4.0] [-infinity,+infinity] = true; subset [-0.0,4.0] [-infinity,+infinity] = true; subset [-0.1,1.0] [-infinity,+infinity] = true; subset [-infinity,+infinity] [-infinity,+infinity] = true; subset [1.0,2.0] [1.0,2.0] = true; subset [1.0,2.0] [0.0,4.0] = true; subset [1.0,2.0] [-0.0,4.0] = true; subset [0.1,0.2] [0.0,4.0] = true; subset [0.1,0.2] [-0.0,4.0] = true; subset [-0.1,-0.1] [-4.0, 3.4] = true; subset [0.0,0.0] [-0.0,-0.0] = true; subset [-0.0,-0.0] [0.0,0.0] = true; subset [-0.0,0.0] [0.0,0.0] = true; subset [-0.0,0.0] [0.0,-0.0] = true; subset [0.0,-0.0] [0.0,0.0] = true; subset [0.0,-0.0] [-0.0,0.0] = true; } testcase minimal_subset_dec_test { subset [empty]_trv [0.0,4.0]_trv = true; subset [empty]_trv [-0.0,4.0]_def = true; subset [empty]_trv [-0.1,1.0]_trv = true; subset [empty]_trv [-0.1,0.0]_trv = true; subset [empty]_trv [-0.1,-0.0]_trv = true; subset [empty]_trv [-infinity,+infinity]_trv = true; subset [0.0,4.0]_trv [empty]_trv = false; subset [-0.0,4.0]_def [empty]_trv = false; subset [-0.1,1.0]_trv [empty]_trv = false; subset [-infinity,+infinity]_trv [empty]_trv = false; subset [0.0,4.0]_trv [-infinity,+infinity]_trv = true; subset [-0.0,4.0]_trv [-infinity,+infinity]_trv = true; subset [-0.1,1.0]_trv [-infinity,+infinity]_trv = true; subset [-infinity,+infinity]_trv [-infinity,+infinity]_trv = true; subset [1.0,2.0]_trv [1.0,2.0]_trv = true; subset [1.0,2.0]_trv [0.0,4.0]_trv = true; subset [1.0,2.0]_def [-0.0,4.0]_def = true; subset [0.1,0.2]_trv [0.0,4.0]_trv = true; subset [0.1,0.2]_trv [-0.0,4.0]_def = true; subset [-0.1,-0.1]_trv [-4.0, 3.4]_trv = true; subset [0.0,0.0]_trv [-0.0,-0.0]_trv = true; subset [-0.0,-0.0]_trv [0.0,0.0]_def = true; subset [-0.0,0.0]_trv [0.0,0.0]_trv = true; subset [-0.0,0.0]_trv [0.0,-0.0]_trv = true; subset [0.0,-0.0]_def [0.0,0.0]_trv = true; subset [0.0,-0.0]_trv [-0.0,0.0]_trv = true; } testcase minimal_less_test { less [empty] [empty] = true; less [1.0,2.0] [empty] = false; less [empty] [1.0,2.0] = false; less [-infinity,+infinity] [-infinity,+infinity] = true; less [1.0,2.0] [-infinity,+infinity] = false; less [0.0,2.0] [-infinity,+infinity] = false; less [-0.0,2.0] [-infinity,+infinity] = false; less [-infinity,+infinity] [1.0,2.0] = false; less [-infinity,+infinity] [0.0,2.0] = false; less [-infinity,+infinity] [-0.0,2.0] = false; less [0.0,2.0] [0.0,2.0] = true; less [0.0,2.0] [-0.0,2.0] = true; less [0.0,2.0] [1.0,2.0] = true; less [-0.0,2.0] [1.0,2.0] = true; less [1.0,2.0] [1.0,2.0] = true; less [1.0,2.0] [3.0,4.0] = true; less [1.0,3.5] [3.0,4.0] = true; less [1.0,4.0] [3.0,4.0] = true; less [-2.0,-1.0] [-2.0,-1.0] = true; less [-3.0,-1.5] [-2.0,-1.0] = true; less [0.0,0.0] [-0.0,-0.0] = true; less [-0.0,-0.0] [0.0,0.0] = true; less [-0.0,0.0] [0.0,0.0] = true; less [-0.0,0.0] [0.0,-0.0] = true; less [0.0,-0.0] [0.0,0.0] = true; less [0.0,-0.0] [-0.0,0.0] = true; } testcase minimal_less_dec_test { less [1.0,2.0]_trv [empty]_trv = false; less [empty]_trv [1.0,2.0]_def = false; less [1.0,2.0]_trv [empty]_trv = false; less [empty]_trv [1.0,2.0]_trv = false; less [-infinity,+infinity]_trv [-infinity,+infinity]_trv = true; less [1.0,2.0]_def [-infinity,+infinity]_trv = false; less [0.0,2.0]_trv [-infinity,+infinity]_trv = false; less [-0.0,2.0]_trv [-infinity,+infinity]_trv = false; less [-infinity,+infinity]_trv [1.0,2.0]_trv = false; less [-infinity,+infinity]_trv [0.0,2.0]_def = false; less [-infinity,+infinity]_trv [-0.0,2.0]_trv = false; less [0.0,2.0]_trv [0.0,2.0]_trv = true; less [0.0,2.0]_trv [-0.0,2.0]_trv = true; less [0.0,2.0]_def [1.0,2.0]_def = true; less [-0.0,2.0]_trv [1.0,2.0]_trv = true; less [1.0,2.0]_trv [1.0,2.0]_trv = true; less [1.0,2.0]_trv [3.0,4.0]_def = true; less [1.0,3.5]_trv [3.0,4.0]_trv = true; less [1.0,4.0]_trv [3.0,4.0]_trv = true; less [-2.0,-1.0]_trv [-2.0,-1.0]_trv = true; less [-3.0,-1.5]_trv [-2.0,-1.0]_trv = true; less [0.0,0.0]_trv [-0.0,-0.0]_trv = true; less [-0.0,-0.0]_trv [0.0,0.0]_def = true; less [-0.0,0.0]_trv [0.0,0.0]_trv = true; less [-0.0,0.0]_trv [0.0,-0.0]_trv = true; less [0.0,-0.0]_def [0.0,0.0]_trv = true; less [0.0,-0.0]_trv [-0.0,0.0]_trv = true; } testcase minimal_precedes_test { precedes [empty] [3.0,4.0] = true; precedes [3.0,4.0] [empty] = true; precedes [empty] [empty] = true; precedes [1.0,2.0] [-infinity,+infinity] = false; precedes [0.0,2.0] [-infinity,+infinity] = false; precedes [-0.0,2.0] [-infinity,+infinity] = false; precedes [-infinity,+infinity] [1.0,2.0] = false; precedes [-infinity,+infinity] [-infinity,+infinity] = false; precedes [1.0,2.0] [3.0,4.0] = true; precedes [1.0,3.0] [3.0,4.0] = true; precedes [-3.0, -1.0] [-1.0,0.0] = true; precedes [-3.0, -1.0] [-1.0,-0.0] = true; precedes [1.0,3.5] [3.0,4.0] = false; precedes [1.0,4.0] [3.0,4.0] = false; precedes [-3.0, -0.1] [-1.0,0.0] = false; precedes [0.0,0.0] [-0.0,-0.0] = true; precedes [-0.0,-0.0] [0.0,0.0] = true; precedes [-0.0,0.0] [0.0,0.0] = true; precedes [-0.0,0.0] [0.0,-0.0] = true; precedes [0.0,-0.0] [0.0,0.0] = true; precedes [0.0,-0.0] [-0.0,0.0] = true; } testcase minimal_precedes_dec_test { precedes [empty]_trv [3.0,4.0]_def = true; precedes [3.0,4.0]_trv [empty]_trv = true; precedes [empty]_trv [3.0,4.0]_trv = true; precedes [3.0,4.0]_trv [empty]_trv = true; precedes [1.0,2.0]_trv [-infinity,+infinity]_trv = false; precedes [0.0,2.0]_trv [-infinity,+infinity]_trv = false; precedes [-0.0,2.0]_trv [-infinity,+infinity]_trv = false; precedes [-infinity,+infinity]_trv [1.0,2.0]_trv = false; precedes [-infinity,+infinity]_trv [-infinity,+infinity]_trv = false; precedes [1.0,2.0]_trv [3.0,4.0]_trv = true; precedes [1.0,3.0]_trv [3.0,4.0]_def = true; precedes [-3.0, -1.0]_def [-1.0,0.0]_trv = true; precedes [-3.0, -1.0]_trv [-1.0,-0.0]_trv = true; precedes [1.0,3.5]_trv [3.0,4.0]_trv = false; precedes [1.0,4.0]_trv [3.0,4.0]_trv = false; precedes [-3.0, -0.1]_trv [-1.0,0.0]_trv = false; precedes [0.0,0.0]_trv [-0.0,-0.0]_trv = true; precedes [-0.0,-0.0]_trv [0.0,0.0]_def = true; precedes [-0.0,0.0]_trv [0.0,0.0]_trv = true; precedes [-0.0,0.0]_def [0.0,-0.0]_trv = true; precedes [0.0,-0.0]_trv [0.0,0.0]_trv = true; precedes [0.0,-0.0]_trv [-0.0,0.0]_trv = true; } testcase minimal_interior_test { interior [empty] [empty] = true; interior [empty] [0.0,4.0] = true; interior [0.0,4.0] [empty] = false; interior [-infinity,+infinity] [-infinity,+infinity] = true; interior [0.0,4.0] [-infinity,+infinity] = true; interior [empty] [-infinity,+infinity] = true; interior [-infinity,+infinity] [0.0,4.0] = false; interior [0.0,4.0] [0.0,4.0] = false; interior [1.0,2.0] [0.0,4.0] = true; interior [-2.0,2.0] [-2.0,4.0] = false; interior [-0.0,-0.0] [-2.0,4.0] = true; interior [0.0,0.0] [-2.0,4.0] = true; interior [0.0,0.0] [-0.0,-0.0] = false; interior [0.0,4.4] [0.0,4.0] = false; interior [-1.0,-1.0] [0.0,4.0] = false; interior [2.0,2.0] [-2.0,-1.0] = false; } testcase minimal_interior_dec_test { interior [empty]_trv [0.0,4.0]_trv = true; interior [0.0,4.0]_def [empty]_trv = false; interior [0.0,4.0]_trv [empty]_trv = false; interior [-infinity,+infinity]_trv [-infinity,+infinity]_trv = true; interior [0.0,4.0]_trv [-infinity,+infinity]_trv = true; interior [empty]_trv [-infinity,+infinity]_trv = true; interior [-infinity,+infinity]_trv [0.0,4.0]_trv = false; interior [0.0,4.0]_trv [0.0,4.0]_trv = false; interior [1.0,2.0]_def [0.0,4.0]_trv = true; interior [-2.0,2.0]_trv [-2.0,4.0]_def = false; interior [-0.0,-0.0]_trv [-2.0,4.0]_trv = true; interior [0.0,0.0]_def [-2.0,4.0]_trv = true; interior [0.0,0.0]_trv [-0.0,-0.0]_trv = false; interior [0.0,4.4]_trv [0.0,4.0]_trv = false; interior [-1.0,-1.0]_trv [0.0,4.0]_def = false; interior [2.0,2.0]_def [-2.0,-1.0]_trv = false; } testcase minimal_strictLess_test { strictLess [empty] [empty] = true; strictLess [1.0,2.0] [empty] = false; strictLess [empty] [1.0,2.0] = false; strictLess [-infinity,+infinity] [-infinity,+infinity] = true; strictLess [1.0,2.0] [-infinity,+infinity] = false; strictLess [-infinity,+infinity] [1.0,2.0] = false; strictLess [1.0,2.0] [1.0,2.0] = false; strictLess [1.0,2.0] [3.0,4.0] = true; strictLess [1.0,3.5] [3.0,4.0] = true; strictLess [1.0,4.0] [3.0,4.0] = false; strictLess [0.0,4.0] [0.0,4.0] = false; strictLess [-0.0,4.0] [0.0,4.0] = false; strictLess [-2.0,-1.0] [-2.0,-1.0] = false; strictLess [-3.0,-1.5] [-2.0,-1.0] = true; } testcase minimal_strictLess_dec_test { strictLess [1.0,2.0]_trv [empty]_trv = false; strictLess [empty]_trv [1.0,2.0]_def = false; strictLess [1.0,2.0]_def [empty]_trv = false; strictLess [empty]_trv [1.0,2.0]_def = false; strictLess [-infinity,+infinity]_trv [-infinity,+infinity]_trv = true; strictLess [1.0,2.0]_trv [-infinity,+infinity]_trv = false; strictLess [-infinity,+infinity]_trv [1.0,2.0]_trv = false; strictLess [1.0,2.0]_trv [1.0,2.0]_trv = false; strictLess [1.0,2.0]_trv [3.0,4.0]_trv = true; strictLess [1.0,3.5]_def [3.0,4.0]_trv = true; strictLess [1.0,4.0]_trv [3.0,4.0]_def = false; strictLess [0.0,4.0]_trv [0.0,4.0]_def = false; strictLess [-0.0,4.0]_def [0.0,4.0]_trv = false; strictLess [-2.0,-1.0]_def [-2.0,-1.0]_def = false; strictLess [-3.0,-1.5]_trv [-2.0,-1.0]_trv = true; } testcase minimal_strictPrecedes_test { strictPrecedes [empty] [3.0,4.0] = true; strictPrecedes [3.0,4.0] [empty] = true; strictPrecedes [empty] [empty] = true; strictPrecedes [1.0,2.0] [-infinity,+infinity] = false; strictPrecedes [-infinity,+infinity] [1.0,2.0] = false; strictPrecedes [-infinity,+infinity] [-infinity,+infinity] = false; strictPrecedes [1.0,2.0] [3.0,4.0] = true; strictPrecedes [1.0,3.0] [3.0,4.0] = false; strictPrecedes [-3.0, -1.0] [-1.0,0.0] = false; strictPrecedes [-3.0, -0.0] [0.0,1.0] = false; strictPrecedes [-3.0, 0.0] [-0.0,1.0] = false; strictPrecedes [1.0,3.5] [3.0,4.0] = false; strictPrecedes [1.0,4.0] [3.0,4.0] = false; strictPrecedes [-3.0, -0.1] [-1.0,0.0] = false; } testcase minimal_strictPrecedes_dec_test { strictPrecedes [empty]_trv [3.0,4.0]_trv = true; strictPrecedes [3.0,4.0]_def [empty]_trv = true; strictPrecedes [empty]_trv [3.0,4.0]_trv = true; strictPrecedes [3.0,4.0]_def [empty]_trv = true; strictPrecedes [1.0,2.0]_trv [-infinity,+infinity]_trv = false; strictPrecedes [-infinity,+infinity]_trv [1.0,2.0]_trv = false; strictPrecedes [-infinity,+infinity]_trv [-infinity,+infinity]_trv = false; strictPrecedes [1.0,2.0]_trv [3.0,4.0]_trv = true; strictPrecedes [1.0,3.0]_def [3.0,4.0]_trv = false; strictPrecedes [-3.0, -1.0]_trv [-1.0,0.0]_def = false; strictPrecedes [-3.0, -0.0]_def [0.0,1.0]_trv = false; strictPrecedes [-3.0, 0.0]_trv [-0.0,1.0]_trv = false; strictPrecedes [1.0,3.5]_trv [3.0,4.0]_trv = false; strictPrecedes [1.0,4.0]_trv [3.0,4.0]_def = false; strictPrecedes [-3.0, -0.1]_trv [-1.0,0.0]_trv = false; } testcase minimal_disjoint_test { disjoint [empty] [3.0,4.0] = true; disjoint [3.0,4.0] [empty] = true; disjoint [empty] [empty] = true; disjoint [3.0,4.0] [1.0,2.0] = true; disjoint [0.0,0.0] [-0.0,-0.0] = false; disjoint [0.0,-0.0] [-0.0,0.0] = false; disjoint [3.0,4.0] [1.0,7.0] = false; disjoint [3.0,4.0] [-infinity,+infinity] = false; disjoint [-infinity,+infinity] [1.0,7.0] = false; disjoint [-infinity,+infinity] [-infinity,+infinity] = false; } testcase minimal_disjoint_dec_test { disjoint [empty]_trv [3.0,4.0]_def = true; disjoint [3.0,4.0]_trv [empty]_trv = true; disjoint [empty]_trv [3.0,4.0]_trv = true; disjoint [3.0,4.0]_trv [empty]_trv = true; disjoint [3.0,4.0]_trv [1.0,2.0]_def = true; disjoint [0.0,0.0]_trv [-0.0,-0.0]_trv = false; disjoint [0.0,-0.0]_trv [-0.0,0.0]_trv = false; disjoint [3.0,4.0]_def [1.0,7.0]_def = false; disjoint [3.0,4.0]_trv [-infinity,+infinity]_trv = false; disjoint [-infinity,+infinity]_trv [1.0,7.0]_trv = false; disjoint [-infinity,+infinity]_trv [-infinity,+infinity]_trv = false; } interval-1.4.1/test/libieeep1788_tests_cancel.itl0000644000000000000000000004633312657475772020054 0ustar 00000000000000/* Copyright 2013-2015 Marco Nehmeier (nehmeier@informatik.uni-wuerzburg.de) Copyright 2015-2016 Oliver Heimlich Original author: Marco Nehmeier (unit tests in libieeep1788, original license: Apache License 2.0) Converted into portable ITL format by Oliver Heimlich with minor corrections. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ testcase minimal_cancelPlus_test { cancelPlus [-infinity, -1.0] [empty] = [entire]; cancelPlus [-1.0, infinity] [empty] = [entire]; cancelPlus [entire] [empty] = [entire]; cancelPlus [-infinity, -1.0] [-5.0,1.0] = [entire]; cancelPlus [-1.0, infinity] [-5.0,1.0] = [entire]; cancelPlus [entire] [-5.0,1.0] = [entire]; cancelPlus [-infinity, -1.0] [entire] = [entire]; cancelPlus [-1.0, infinity] [entire] = [entire]; cancelPlus [empty] [1.0, infinity] = [entire]; cancelPlus [empty] [-infinity,1.0] = [entire]; cancelPlus [empty] [entire] = [entire]; cancelPlus [-1.0,5.0] [1.0,infinity] = [entire]; cancelPlus [-1.0,5.0] [-infinity,1.0] = [entire]; cancelPlus [-1.0,5.0] [entire] = [entire]; cancelPlus [entire] [1.0,infinity] = [entire]; cancelPlus [entire] [-infinity,1.0] = [entire]; cancelPlus [entire] [entire] = [entire]; cancelPlus [-5.0, -1.0] [1.0,5.1] = [entire]; cancelPlus [-5.0, -1.0] [0.9,5.0] = [entire]; cancelPlus [-5.0, -1.0] [0.9,5.1] = [entire]; cancelPlus [-10.0, 5.0] [-5.0,10.1] = [entire]; cancelPlus [-10.0, 5.0] [-5.1,10.0] = [entire]; cancelPlus [-10.0, 5.0] [-5.1,10.1] = [entire]; cancelPlus [1.0, 5.0] [-5.0,-0.9] = [entire]; cancelPlus [1.0, 5.0] [-5.1,-1.0] = [entire]; cancelPlus [1.0, 5.0] [-5.1,-0.9] = [entire]; cancelPlus [-10.0, -1.0] [empty] = [entire]; cancelPlus [-10.0, 5.0] [empty] = [entire]; cancelPlus [1.0, 5.0] [empty] = [entire]; cancelPlus [empty] [empty] = [empty]; cancelPlus [empty] [1.0,10.0] = [empty]; cancelPlus [empty] [-5.0,10.0] = [empty]; cancelPlus [empty] [-5.0,-1.0] = [empty]; cancelPlus [-5.1,-0.0] [0.0,5.0] = [-0X1.999999999998P-4,0.0]; cancelPlus [-5.1,-1.0] [1.0,5.0] = [-0X1.999999999998P-4,0.0]; cancelPlus [-5.0,-0.9] [1.0,5.0] = [0.0, 0X1.9999999999998P-4]; cancelPlus [-5.1,-0.9] [1.0,5.0] = [-0X1.999999999998P-4,0X1.9999999999998P-4]; cancelPlus [-5.0,-1.0] [1.0,5.0] = [0.0,0.0]; cancelPlus [-10.1, 5.0] [-5.0,10.0] = [-0X1.999999999998P-4,0.0]; cancelPlus [-10.0, 5.1] [-5.0,10.0] = [0.0,0X1.999999999998P-4]; cancelPlus [-10.1, 5.1] [-5.0,10.0] = [-0X1.999999999998P-4,0X1.999999999998P-4]; cancelPlus [-10.0, 5.0] [-5.0,10.0] = [0.0,0.0]; cancelPlus [0.9, 5.0] [-5.0,-1.0] = [-0X1.9999999999998P-4,0.0]; cancelPlus [1.0, 5.1] [-5.0,-1.0] = [0.0,0X1.999999999998P-4]; cancelPlus [0.0, 5.1] [-5.0,-0.0] = [0.0,0X1.999999999998P-4]; cancelPlus [0.9, 5.1] [-5.0,-1.0] = [-0X1.9999999999998P-4,0X1.999999999998P-4]; cancelPlus [1.0, 5.0] [-5.0,-1.0] = [0.0,0.0]; cancelPlus [0.0, 5.0] [-5.0,-0.0] = [0.0,0.0]; cancelPlus [0X1.FFFFFFFFFFFFP+0,0X1.FFFFFFFFFFFFP+0] [-0X1.999999999999AP-4,-0X1.999999999999AP-4] = [0X1.E666666666656P+0,0X1.E666666666657P+0]; cancelPlus [-0X1.999999999999AP-4,0X1.FFFFFFFFFFFFP+0] [-0X1.999999999999AP-4,0.01] = [-0X1.70A3D70A3D70BP-4,0X1.E666666666657P+0]; cancelPlus [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] = [0x1.FFFFFFFFFFFFFp1023,infinity]; cancelPlus [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] = [0.0,0.0]; cancelPlus [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] [-0X1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023] = [0.0,0X1P+971]; cancelPlus [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] [-0x1.FFFFFFFFFFFFFp1023,0X1.FFFFFFFFFFFFEP+1023] = [-0X1P+971,0.0]; cancelPlus [-0x1.FFFFFFFFFFFFFp1023,0X1.FFFFFFFFFFFFEP+1023] [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] = [entire]; cancelPlus [-0X1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023] [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] = [entire]; cancelPlus [-0X1P+0,0X1.FFFFFFFFFFFFFP-53] [-0X1P+0,0X1.FFFFFFFFFFFFEP-53] = [-0X1.FFFFFFFFFFFFFP-1,-0X1.FFFFFFFFFFFFEP-1]; cancelPlus [-0X1P+0,0X1.FFFFFFFFFFFFEP-53] [-0X1P+0,0X1.FFFFFFFFFFFFFP-53] = [entire]; } testcase minimal_cancelPlus_dec_test { cancelPlus [-infinity, -1.0]_dac [empty]_trv = [entire]_trv; cancelPlus [-1.0, infinity]_def [empty]_trv = [entire]_trv; cancelPlus [entire]_def [empty]_trv = [entire]_trv; cancelPlus [-infinity, -1.0]_dac [-5.0,1.0]_com = [entire]_trv; cancelPlus [-1.0, infinity]_trv [-5.0,1.0]_def = [entire]_trv; cancelPlus [entire]_def [-5.0,1.0]_def = [entire]_trv; cancelPlus [-infinity, -1.0]_dac [entire]_def = [entire]_trv; cancelPlus [-1.0, infinity]_def [entire]_def = [entire]_trv; cancelPlus [empty]_trv [1.0, infinity]_def = [entire]_trv; cancelPlus [empty]_trv [-infinity,1.0]_trv = [entire]_trv; cancelPlus [empty]_trv [entire]_def = [entire]_trv; cancelPlus [-1.0,5.0]_dac [1.0,infinity]_dac = [entire]_trv; cancelPlus [-1.0,5.0]_def [-infinity,1.0]_dac = [entire]_trv; cancelPlus [-1.0,5.0]_com [entire]_def = [entire]_trv; cancelPlus [entire]_def [1.0,infinity]_dac = [entire]_trv; cancelPlus [entire]_def [-infinity,1.0]_def = [entire]_trv; cancelPlus [entire]_def [entire]_def = [entire]_trv; cancelPlus [-5.0, -1.0]_com [1.0,5.1]_def = [entire]_trv; cancelPlus [-5.0, -1.0]_dac [0.9,5.0]_def = [entire]_trv; cancelPlus [-5.0, -1.0]_def [0.9,5.1]_def = [entire]_trv; cancelPlus [-10.0, 5.0]_trv [-5.0,10.1]_dac = [entire]_trv; cancelPlus [-10.0, 5.0]_com [-5.1,10.0]_dac = [entire]_trv; cancelPlus [-10.0, 5.0]_dac [-5.1,10.1]_dac = [entire]_trv; cancelPlus [1.0, 5.0]_def [-5.0,-0.9]_com = [entire]_trv; cancelPlus [1.0, 5.0]_trv [-5.1,-1.0]_com = [entire]_trv; cancelPlus [1.0, 5.0]_dac [-5.1,-0.9]_com = [entire]_trv; cancelPlus [-10.0, -1.0]_trv [empty]_trv = [entire]_trv; cancelPlus [-10.0, 5.0]_def [empty]_trv = [entire]_trv; cancelPlus [1.0, 5.0]_com [empty]_trv = [entire]_trv; cancelPlus [empty]_trv [empty]_trv = [empty]_trv; cancelPlus [empty]_trv [1.0,10.0]_dac = [empty]_trv; cancelPlus [empty]_trv [-5.0,10.0]_def = [empty]_trv; cancelPlus [empty]_trv [-5.0,-1.0]_com = [empty]_trv; cancelPlus [-5.1,-0.0]_com [0.0,5.0]_com = [-0X1.999999999998P-4,0.0]_trv; cancelPlus [-5.1,-1.0]_com [1.0,5.0]_dac = [-0X1.999999999998P-4,0.0]_trv; cancelPlus [-5.0,-0.9]_com [1.0,5.0]_def = [0.0, 0X1.9999999999998P-4]_trv; cancelPlus [-5.1,-0.9]_dac [1.0,5.0]_trv = [-0X1.999999999998P-4,0X1.9999999999998P-4]_trv; cancelPlus [-5.0,-1.0]_dac [1.0,5.0]_com = [0.0,0.0]_trv; cancelPlus [-10.1, 5.0]_dac [-5.0,10.0]_dac = [-0X1.999999999998P-4,0.0]_trv; cancelPlus [-10.0, 5.1]_def [-5.0,10.0]_def = [0.0,0X1.999999999998P-4]_trv; cancelPlus [-10.1, 5.1]_def [-5.0,10.0]_trv = [-0X1.999999999998P-4,0X1.999999999998P-4]_trv; cancelPlus [-10.0, 5.0]_def [-5.0,10.0]_com = [0.0,0.0]_trv; cancelPlus [0.9, 5.0]_trv [-5.0,-1.0]_dac = [-0X1.9999999999998P-4,0.0]_trv; cancelPlus [1.0, 5.1]_trv [-5.0,-1.0]_def = [0.0,0X1.999999999998P-4]_trv; cancelPlus [0.0, 5.1]_trv [-5.0,-0.0]_trv = [0.0,0X1.999999999998P-4]_trv; cancelPlus [0.9, 5.1]_com [-5.0,-1.0]_com = [-0X1.9999999999998P-4,0X1.999999999998P-4]_trv; cancelPlus [1.0, 5.0]_dac [-5.0,-1.0]_dac = [0.0,0.0]_trv; cancelPlus [0.0, 5.0]_def [-5.0,-0.0]_trv = [0.0,0.0]_trv; cancelPlus [0X1.FFFFFFFFFFFFP+0,0X1.FFFFFFFFFFFFP+0]_com [-0X1.999999999999AP-4,-0X1.999999999999AP-4]_com = [0X1.E666666666656P+0,0X1.E666666666657P+0]_trv; cancelPlus [-0X1.999999999999AP-4,0X1.FFFFFFFFFFFFP+0]_dac [-0X1.999999999999AP-4,0.01]_com = [-0X1.70A3D70A3D70BP-4,0X1.E666666666657P+0]_trv; cancelPlus [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_com [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_com = [0x1.FFFFFFFFFFFFFp1023,infinity]_trv; cancelPlus [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_com [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_com = [0.0,0.0]_trv; cancelPlus [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_dac [-0X1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023]_com = [0.0,0X1P+971]_trv; cancelPlus [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_dac [-0x1.FFFFFFFFFFFFFp1023,0X1.FFFFFFFFFFFFEP+1023]_com = [-0X1P+971,0.0]_trv; cancelPlus [-0x1.FFFFFFFFFFFFFp1023,0X1.FFFFFFFFFFFFEP+1023]_com [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_com = [entire]_trv; cancelPlus [-0X1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023]_com [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_com = [entire]_trv; cancelPlus [-0X1P+0,0X1.FFFFFFFFFFFFFP-53]_dac [-0X1P+0,0X1.FFFFFFFFFFFFEP-53]_com = [-0X1.FFFFFFFFFFFFFP-1,-0X1.FFFFFFFFFFFFEP-1]_trv; cancelPlus [-0X1P+0,0X1.FFFFFFFFFFFFEP-53]_def [-0X1P+0,0X1.FFFFFFFFFFFFFP-53]_com = [entire]_trv; } testcase minimal_cancelMinus_test { cancelMinus [-infinity, -1.0] [empty] = [entire]; cancelMinus [-1.0, infinity] [empty] = [entire]; cancelMinus [entire] [empty] = [entire]; cancelMinus [-infinity, -1.0] [-1.0,5.0] = [entire]; cancelMinus [-1.0, infinity] [-1.0,5.0] = [entire]; cancelMinus [entire] [-1.0,5.0] = [entire]; cancelMinus [-infinity, -1.0] [entire] = [entire]; cancelMinus [-1.0, infinity] [entire] = [entire]; cancelMinus [empty] [-infinity, -1.0] = [entire]; cancelMinus [empty] [-1.0, infinity] = [entire]; cancelMinus [empty] [entire] = [entire]; cancelMinus [-1.0,5.0] [-infinity, -1.0] = [entire]; cancelMinus [-1.0,5.0] [-1.0, infinity] = [entire]; cancelMinus [-1.0,5.0] [entire] = [entire]; cancelMinus [entire] [-infinity, -1.0] = [entire]; cancelMinus [entire] [-1.0, infinity] = [entire]; cancelMinus [entire] [entire] = [entire]; cancelMinus [-5.0, -1.0] [-5.1,-1.0] = [entire]; cancelMinus [-5.0, -1.0] [-5.0,-0.9] = [entire]; cancelMinus [-5.0, -1.0] [-5.1,-0.9] = [entire]; cancelMinus [-10.0, 5.0] [-10.1, 5.0] = [entire]; cancelMinus [-10.0, 5.0] [-10.0, 5.1] = [entire]; cancelMinus [-10.0, 5.0] [-10.1, 5.1] = [entire]; cancelMinus [1.0, 5.0] [0.9, 5.0] = [entire]; cancelMinus [1.0, 5.0] [1.0, 5.1] = [entire]; cancelMinus [1.0, 5.0] [0.9, 5.1] = [entire]; cancelMinus [-10.0, -1.0] [empty] = [entire]; cancelMinus [-10.0, 5.0] [empty] = [entire]; cancelMinus [1.0, 5.0] [empty] = [entire]; cancelMinus [empty] [empty] = [empty]; cancelMinus [empty] [-10.0, -1.0] = [empty]; cancelMinus [empty] [-10.0, 5.0] = [empty]; cancelMinus [empty] [1.0, 5.0] = [empty]; cancelMinus [-5.1,-0.0] [-5.0, 0.0] = [-0X1.999999999998P-4,0.0]; cancelMinus [-5.1,-1.0] [-5.0, -1.0] = [-0X1.999999999998P-4,0.0]; cancelMinus [-5.0,-0.9] [-5.0, -1.0] = [0.0, 0X1.9999999999998P-4]; cancelMinus [-5.1,-0.9] [-5.0, -1.0] = [-0X1.999999999998P-4,0X1.9999999999998P-4]; cancelMinus [-5.0,-1.0] [-5.0, -1.0] = [0.0,0.0]; cancelMinus [-10.1, 5.0] [-10.0, 5.0] = [-0X1.999999999998P-4,0.0]; cancelMinus [-10.0, 5.1] [-10.0, 5.0] = [0.0,0X1.999999999998P-4]; cancelMinus [-10.1, 5.1] [-10.0, 5.0] = [-0X1.999999999998P-4,0X1.999999999998P-4]; cancelMinus [-10.0, 5.0] [-10.0, 5.0] = [0.0,0.0]; cancelMinus [0.9, 5.0] [1.0, 5.0] = [-0X1.9999999999998P-4,0.0]; cancelMinus [-0.0, 5.1] [0.0, 5.0] = [0.0,0X1.999999999998P-4]; cancelMinus [1.0, 5.1] [1.0, 5.0] = [0.0,0X1.999999999998P-4]; cancelMinus [0.9, 5.1] [1.0, 5.0] = [-0X1.9999999999998P-4,0X1.999999999998P-4]; cancelMinus [1.0, 5.0] [1.0, 5.0] = [0.0,0.0]; cancelMinus [-5.0, 1.0] [-1.0, 5.0] = [-4.0,-4.0]; cancelMinus [-5.0, 0.0] [-0.0, 5.0] = [-5.0,-5.0]; cancelMinus [0X1.FFFFFFFFFFFFP+0,0X1.FFFFFFFFFFFFP+0] [0X1.999999999999AP-4,0X1.999999999999AP-4] = [0X1.E666666666656P+0,0X1.E666666666657P+0]; cancelMinus [-0X1.999999999999AP-4,0X1.FFFFFFFFFFFFP+0] [-0.01,0X1.999999999999AP-4] = [-0X1.70A3D70A3D70BP-4,0X1.E666666666657P+0]; cancelMinus [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] [-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023] = [0x1.FFFFFFFFFFFFFp1023,infinity]; cancelMinus [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] = [0.0,0.0]; cancelMinus [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] [-0x1.FFFFFFFFFFFFFp1023,0X1.FFFFFFFFFFFFEP+1023] = [0.0,0X1P+971]; cancelMinus [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] [-0X1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023] = [-0X1P+971,0.0]; cancelMinus [-0x1.FFFFFFFFFFFFFp1023,0X1.FFFFFFFFFFFFEP+1023] [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] = [entire]; cancelMinus [-0X1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023] [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] = [entire]; cancelMinus [0x0.0000000000001p-1022,0x0.0000000000001p-1022] [0x0.0000000000001p-1022,0x0.0000000000001p-1022] = [0.0,0.0]; cancelMinus [0x0.0000000000001p-1022,0x0.0000000000001p-1022] [-0x0.0000000000001p-1022,-0x0.0000000000001p-1022] = [0x0.0000000000002p-1022,0x0.0000000000002p-1022]; cancelMinus [0X1P-1022,0X1.0000000000002P-1022] [0X1P-1022,0X1.0000000000001P-1022] = [0.0,0X0.0000000000001P-1022]; cancelMinus [0X1P-1022,0X1.0000000000001P-1022] [0X1P-1022,0X1.0000000000002P-1022] = [entire]; cancelMinus [-0X1P+0,0X1.FFFFFFFFFFFFFP-53] [-0X1.FFFFFFFFFFFFEP-53,0X1P+0] = [-0X1.FFFFFFFFFFFFFP-1,-0X1.FFFFFFFFFFFFEP-1]; cancelMinus [-0X1P+0,0X1.FFFFFFFFFFFFEP-53] [-0X1.FFFFFFFFFFFFFP-53,0X1P+0] = [entire]; } testcase minimal_cancelMinus_dec_test { cancelMinus [-infinity, -1.0]_dac [empty]_trv = [entire]_trv; cancelMinus [-1.0, infinity]_def [empty]_trv = [entire]_trv; cancelMinus [entire]_def [empty]_trv = [entire]_trv; cancelMinus [-infinity, -1.0]_trv [-1.0,5.0]_dac = [entire]_trv; cancelMinus [-1.0, infinity]_dac [-1.0,5.0]_com = [entire]_trv; cancelMinus [entire]_def [-1.0,5.0]_def = [entire]_trv; cancelMinus [-infinity, -1.0]_def [entire]_def = [entire]_trv; cancelMinus [-1.0, infinity]_trv [entire]_def = [entire]_trv; cancelMinus [empty]_trv [-infinity, -1.0]_dac = [entire]_trv; cancelMinus [empty]_trv [-1.0, infinity]_dac = [entire]_trv; cancelMinus [empty]_trv [entire]_def = [entire]_trv; cancelMinus [-1.0,5.0]_dac [-infinity, -1.0]_def = [entire]_trv; cancelMinus [-1.0,5.0]_def [-1.0, infinity]_trv = [entire]_trv; cancelMinus [-1.0,5.0]_com [entire]_def = [entire]_trv; cancelMinus [entire]_def [-infinity, -1.0]_dac = [entire]_trv; cancelMinus [entire]_def [-1.0, infinity]_def = [entire]_trv; cancelMinus [entire]_def [entire]_def = [entire]_trv; cancelMinus [-5.0, -1.0]_com [-5.1,-1.0]_trv = [entire]_trv; cancelMinus [-5.0, -1.0]_dac [-5.0,-0.9]_def = [entire]_trv; cancelMinus [-5.0, -1.0]_def [-5.1,-0.9]_dac = [entire]_trv; cancelMinus [-10.0, 5.0]_trv [-10.1, 5.0]_com = [entire]_trv; cancelMinus [-10.0, 5.0]_com [-10.0, 5.1]_com = [entire]_trv; cancelMinus [-10.0, 5.0]_dac [-10.1, 5.1]_trv = [entire]_trv; cancelMinus [1.0, 5.0]_def [0.9, 5.0]_def = [entire]_trv; cancelMinus [1.0, 5.0]_trv [1.0, 5.1]_dac = [entire]_trv; cancelMinus [1.0, 5.0]_com [0.9, 5.1]_dac = [entire]_trv; cancelMinus [-10.0, -1.0]_com [empty]_trv = [entire]_trv; cancelMinus [-10.0, 5.0]_dac [empty]_trv = [entire]_trv; cancelMinus [1.0, 5.0]_def [empty]_trv = [entire]_trv; cancelMinus [empty]_trv [empty]_trv = [empty]_trv; cancelMinus [empty]_trv [-10.0, -1.0]_com = [empty]_trv; cancelMinus [empty]_trv [-10.0, 5.0]_dac = [empty]_trv; cancelMinus [empty]_trv [1.0, 5.0]_def = [empty]_trv; cancelMinus [-5.1,-0.0]_com [-5.0, 0.0]_com = [-0X1.999999999998P-4,0.0]_trv; cancelMinus [-5.1,-1.0]_dac [-5.0, -1.0]_com = [-0X1.999999999998P-4,0.0]_trv; cancelMinus [-5.0,-0.9]_def [-5.0, -1.0]_com = [0.0, 0X1.9999999999998P-4]_trv; cancelMinus [-5.1,-0.9]_trv [-5.0, -1.0]_com = [-0X1.999999999998P-4,0X1.9999999999998P-4]_trv; cancelMinus [-5.0,-1.0]_com [-5.0, -1.0]_dac = [0.0,0.0]_trv; cancelMinus [-10.1, 5.0]_dac [-10.0, 5.0]_dac = [-0X1.999999999998P-4,0.0]_trv; cancelMinus [-10.0, 5.1]_def [-10.0, 5.0]_dac = [0.0,0X1.999999999998P-4]_trv; cancelMinus [-10.1, 5.1]_trv [-10.0, 5.0]_def = [-0X1.999999999998P-4,0X1.999999999998P-4]_trv; cancelMinus [-10.0, 5.0]_com [-10.0, 5.0]_def = [0.0,0.0]_trv; cancelMinus [0.9, 5.0]_dac [1.0, 5.0]_def = [-0X1.9999999999998P-4,0.0]_trv; cancelMinus [-0.0, 5.1]_def [0.0, 5.0]_def = [0.0,0X1.999999999998P-4]_trv; cancelMinus [1.0, 5.1]_trv [1.0, 5.0]_trv = [0.0,0X1.999999999998P-4]_trv; cancelMinus [0.9, 5.1]_com [1.0, 5.0]_trv = [-0X1.9999999999998P-4,0X1.999999999998P-4]_trv; cancelMinus [1.0, 5.0]_dac [1.0, 5.0]_com = [0.0,0.0]_trv; cancelMinus [-5.0, 1.0]_def [-1.0, 5.0]_def = [-4.0,-4.0]_trv; cancelMinus [-5.0, 0.0]_trv [-0.0, 5.0]_trv = [-5.0,-5.0]_trv; cancelMinus [0X1.FFFFFFFFFFFFP+0,0X1.FFFFFFFFFFFFP+0]_com [0X1.999999999999AP-4,0X1.999999999999AP-4]_com = [0X1.E666666666656P+0,0X1.E666666666657P+0]_trv; cancelMinus [-0X1.999999999999AP-4,0X1.FFFFFFFFFFFFP+0]_def [-0.01,0X1.999999999999AP-4]_dac = [-0X1.70A3D70A3D70BP-4,0X1.E666666666657P+0]_trv; cancelMinus [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_com [-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023]_com = [0x1.FFFFFFFFFFFFFp1023,infinity]_trv; cancelMinus [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_com [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_com = [0.0,0.0]_trv; cancelMinus [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_com [-0x1.FFFFFFFFFFFFFp1023,0X1.FFFFFFFFFFFFEP+1023]_com = [0.0,0X1P+971]_trv; cancelMinus [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_com [-0X1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023]_com = [-0X1P+971,0.0]_trv; cancelMinus [-0x1.FFFFFFFFFFFFFp1023,0X1.FFFFFFFFFFFFEP+1023]_com [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_com = [entire]_trv; cancelMinus [-0X1.FFFFFFFFFFFFEP+1023,0x1.FFFFFFFFFFFFFp1023]_com [-0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_com = [entire]_trv; cancelMinus [0x0.0000000000001p-1022,0x0.0000000000001p-1022]_com [0x0.0000000000001p-1022,0x0.0000000000001p-1022]_com = [0.0,0.0]_trv; cancelMinus [0x0.0000000000001p-1022,0x0.0000000000001p-1022]_com [-0x0.0000000000001p-1022,-0x0.0000000000001p-1022]_dac = [0x0.0000000000002p-1022,0x0.0000000000002p-1022]_trv; cancelMinus [0X1P-1022,0X1.0000000000002P-1022]_dac [0X1P-1022,0X1.0000000000001P-1022]_dac = [0.0,0X0.0000000000001P-1022]_trv; cancelMinus [0X1P-1022,0X1.0000000000001P-1022]_def [0X1P-1022,0X1.0000000000002P-1022]_com = [entire]_trv; cancelMinus [-0X1P+0,0X1.FFFFFFFFFFFFFP-53]_com [-0X1.FFFFFFFFFFFFEP-53,0X1P+0]_dac = [-0X1.FFFFFFFFFFFFFP-1,-0X1.FFFFFFFFFFFFEP-1]_trv; cancelMinus [-0X1P+0,0X1.FFFFFFFFFFFFEP-53]_def [-0X1.FFFFFFFFFFFFFP-53,0X1P+0]_dac = [entire]_trv; } interval-1.4.1/test/libieeep1788_tests_elem.itl0000644000000000000000000065352212657475772017555 0ustar 00000000000000/* Copyright 2013-2015 Marco Nehmeier (nehmeier@informatik.uni-wuerzburg.de) Copyright 2015-2016 Oliver Heimlich Original author: Marco Nehmeier (unit tests in libieeep1788, original license: Apache License 2.0) Converted into portable ITL format by Oliver Heimlich with minor corrections. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ testcase minimal_pos_test { pos [1.0,2.0] = [1.0,2.0]; pos [empty] = [empty]; pos [entire] = [entire]; pos [1.0,infinity] = [1.0,infinity]; pos [-infinity,-1.0] = [-infinity,-1.0]; pos [0.0,2.0] = [0.0,2.0]; pos [-0.0,2.0] = [0.0,2.0]; pos [-2.5,-0.0] = [-2.5,0.0]; pos [-2.5,0.0] = [-2.5,0.0]; pos [-0.0,-0.0] = [0.0,0.0]; pos [0.0,0.0] = [0.0,0.0]; } testcase minimal_pos_dec_test { pos [empty]_trv = [empty]_trv; pos [entire]_def = [entire]_def; pos [1.0, 2.0]_com = [1.0, 2.0]_com; } testcase minimal_neg_test { neg [1.0,2.0] = [-2.0,-1.0]; neg [empty] = [empty]; neg [entire] = [entire]; neg [1.0,infinity] = [-infinity,-1.0]; neg [-infinity,1.0] = [-1.0,infinity]; neg [0.0,2.0] = [-2.0,0.0]; neg [-0.0,2.0] = [-2.0,0.0]; neg [-2.0,0.0] = [0.0,2.0]; neg [-2.0,-0.0] = [0.0,2.0]; neg [0.0,-0.0] = [0.0,0.0]; neg [-0.0,-0.0] = [0.0,0.0]; } testcase minimal_neg_dec_test { neg [empty]_trv = [empty]_trv; neg [entire]_def = [entire]_def; neg [1.0, 2.0]_com = [-2.0, -1.0]_com; } testcase minimal_add_test { add [empty] [empty] = [empty]; add [-1.0,1.0] [empty] = [empty]; add [empty] [-1.0,1.0] = [empty]; add [empty] [entire] = [empty]; add [entire] [empty] = [empty]; add [entire] [-infinity,1.0] = [entire]; add [entire] [-1.0,1.0] = [entire]; add [entire] [-1.0,infinity] = [entire]; add [entire] [entire] = [entire]; add [-infinity,1.0] [entire] = [entire]; add [-1.0,1.0] [entire] = [entire]; add [-1.0,infinity] [entire] = [entire]; add [-infinity,2.0] [-infinity,4.0] = [-infinity,6.0]; add [-infinity,2.0] [3.0,4.0] = [-infinity,6.0]; add [-infinity,2.0] [3.0,infinity] = [entire]; add [1.0,2.0] [-infinity,4.0] = [-infinity,6.0]; add [1.0,2.0] [3.0,4.0] = [4.0,6.0]; add [1.0,2.0] [3.0,infinity] = [4.0,infinity]; add [1.0,infinity] [-infinity,4.0] = [entire]; add [1.0,infinity] [3.0,4.0] = [4.0,infinity]; add [1.0,infinity] [3.0,infinity] = [4.0,infinity]; add [1.0,0x1.FFFFFFFFFFFFFp1023] [3.0,4.0] = [4.0,infinity]; add [-0x1.FFFFFFFFFFFFFp1023,2.0] [-3.0,4.0] = [-infinity,6.0]; add [-0x1.FFFFFFFFFFFFFp1023,2.0] [-3.0,0x1.FFFFFFFFFFFFFp1023] = [entire]; add [1.0,0x1.FFFFFFFFFFFFFp1023] [0.0,0.0] = [1.0,0x1.FFFFFFFFFFFFFp1023]; add [1.0,0x1.FFFFFFFFFFFFFp1023] [-0.0,-0.0] = [1.0,0x1.FFFFFFFFFFFFFp1023]; add [0.0,0.0] [-3.0,4.0] = [-3.0,4.0]; add [-0.0,-0.0] [-3.0,0x1.FFFFFFFFFFFFFp1023] = [-3.0,0x1.FFFFFFFFFFFFFp1023]; add [0X1.FFFFFFFFFFFFP+0,0X1.FFFFFFFFFFFFP+0] [0X1.999999999999AP-4,0X1.999999999999AP-4] = [0X1.0CCCCCCCCCCC4P+1,0X1.0CCCCCCCCCCC5P+1]; add [0X1.FFFFFFFFFFFFP+0,0X1.FFFFFFFFFFFFP+0] [-0X1.999999999999AP-4,-0X1.999999999999AP-4] = [0X1.E666666666656P+0,0X1.E666666666657P+0]; add [-0X1.FFFFFFFFFFFFP+0,0X1.FFFFFFFFFFFFP+0] [0X1.999999999999AP-4,0X1.999999999999AP-4] = [-0X1.E666666666657P+0,0X1.0CCCCCCCCCCC5P+1]; } testcase minimal_add_dec_test { add [1.0,2.0]_com [5.0,7.0]_com = [6.0,9.0]_com; add [1.0,2.0]_com [5.0,7.0]_def = [6.0,9.0]_def; add [1.0,2.0]_com [5.0,0x1.FFFFFFFFFFFFFp1023]_com = [6.0,infinity]_dac; add [-0x1.FFFFFFFFFFFFFp1023,2.0]_com [-0.1, 5.0]_com = [-infinity,7.0]_dac; add [1.0,2.0]_trv [empty]_trv = [empty]_trv; } testcase minimal_sub_test { sub [empty] [empty] = [empty]; sub [-1.0,1.0] [empty] = [empty]; sub [empty] [-1.0,1.0] = [empty]; sub [empty] [entire] = [empty]; sub [entire] [empty] = [empty]; sub [entire] [-infinity,1.0] = [entire]; sub [entire] [-1.0,1.0] = [entire]; sub [entire] [-1.0,infinity] = [entire]; sub [entire] [entire] = [entire]; sub [-infinity,1.0] [entire] = [entire]; sub [-1.0,1.0] [entire] = [entire]; sub [-1.0,infinity] [entire] = [entire]; sub [-infinity,2.0] [-infinity,4.0] = [entire]; sub [-infinity,2.0] [3.0,4.0] = [-infinity,-1.0]; sub [-infinity,2.0] [3.0,infinity] = [-infinity,-1.0]; sub [1.0,2.0] [-infinity,4.0] = [-3.0,infinity]; sub [1.0,2.0] [3.0,4.0] = [-3.0,-1.0]; sub [1.0,2.0] [3.0,infinity] = [-infinity,-1.0]; sub [1.0,infinity] [-infinity,4.0] = [-3.0,infinity]; sub [1.0,infinity] [3.0,4.0] = [-3.0,infinity]; sub [1.0,infinity] [3.0,infinity] = [entire]; sub [1.0,0x1.FFFFFFFFFFFFFp1023] [-3.0,4.0] = [-3.0,infinity]; sub [-0x1.FFFFFFFFFFFFFp1023,2.0] [3.0,4.0] = [-infinity,-1.0]; sub [-0x1.FFFFFFFFFFFFFp1023,2.0] [-0x1.FFFFFFFFFFFFFp1023,4.0] = [entire]; sub [1.0,0x1.FFFFFFFFFFFFFp1023] [0.0,0.0] = [1.0,0x1.FFFFFFFFFFFFFp1023]; sub [1.0,0x1.FFFFFFFFFFFFFp1023] [-0.0,-0.0] = [1.0,0x1.FFFFFFFFFFFFFp1023]; sub [0.0,0.0] [-3.0,4.0] = [-4.0,3.0]; sub [-0.0,-0.0] [-3.0,0x1.FFFFFFFFFFFFFp1023] = [-0x1.FFFFFFFFFFFFFp1023,3.0]; sub [0X1.FFFFFFFFFFFFP+0,0X1.FFFFFFFFFFFFP+0] [0X1.999999999999AP-4,0X1.999999999999AP-4] = [0X1.E666666666656P+0,0X1.E666666666657P+0]; sub [0X1.FFFFFFFFFFFFP+0,0X1.FFFFFFFFFFFFP+0] [-0X1.999999999999AP-4,-0X1.999999999999AP-4] = [0X1.0CCCCCCCCCCC4P+1,0X1.0CCCCCCCCCCC5P+1]; sub [-0X1.FFFFFFFFFFFFP+0,0X1.FFFFFFFFFFFFP+0] [0X1.999999999999AP-4,0X1.999999999999AP-4] = [-0X1.0CCCCCCCCCCC5P+1,0X1.E666666666657P+0]; } testcase minimal_sub_dec_test { sub [1.0,2.0]_com [5.0,7.0]_com = [-6.0,-3.0]_com; sub [1.0,2.0]_com [5.0,7.0]_def = [-6.0,-3.0]_def; sub [-1.0,2.0]_com [5.0,0x1.FFFFFFFFFFFFFp1023]_com = [-infinity,-3.0]_dac; sub [-0x1.FFFFFFFFFFFFFp1023,2.0]_com [-1.0, 5.0]_com = [-infinity,3.0]_dac; sub [1.0,2.0]_trv [empty]_trv = [empty]_trv; } testcase minimal_mul_test { mul [empty] [empty] = [empty]; mul [-1.0,1.0] [empty] = [empty]; mul [empty] [-1.0,1.0] = [empty]; mul [empty] [entire] = [empty]; mul [entire] [empty] = [empty]; mul [0.0,0.0] [empty] = [empty]; mul [empty] [0.0,0.0] = [empty]; mul [-0.0,-0.0] [empty] = [empty]; mul [empty] [-0.0,-0.0] = [empty]; mul [entire] [0.0,0.0] = [0.0,0.0]; mul [entire] [-0.0,-0.0] = [0.0,0.0]; mul [entire] [-5.0, -1.0] = [entire]; mul [entire] [-5.0, 3.0] = [entire]; mul [entire] [1.0, 3.0] = [entire]; mul [entire] [-infinity, -1.0] = [entire]; mul [entire] [-infinity, 3.0] = [entire]; mul [entire] [-5.0, infinity] = [entire]; mul [entire] [1.0, infinity] = [entire]; mul [entire] [entire] = [entire]; mul [1.0,infinity] [0.0,0.0] = [0.0,0.0]; mul [1.0,infinity] [-0.0,-0.0] = [0.0,0.0]; mul [1.0,infinity] [-5.0, -1.0] = [-infinity,-1.0]; mul [1.0,infinity] [-5.0, 3.0] = [entire]; mul [1.0,infinity] [1.0, 3.0] = [1.0,infinity]; mul [1.0,infinity] [-infinity, -1.0] = [-infinity,-1.0]; mul [1.0,infinity] [-infinity, 3.0] = [entire]; mul [1.0,infinity] [-5.0, infinity] = [entire]; mul [1.0,infinity] [1.0, infinity] = [1.0,infinity]; mul [1.0,infinity] [entire] = [entire]; mul [-1.0,infinity] [0.0,0.0] = [0.0,0.0]; mul [-1.0,infinity] [-0.0,-0.0] = [0.0,0.0]; mul [-1.0,infinity] [-5.0, -1.0] = [-infinity,5.0]; mul [-1.0,infinity] [-5.0, 3.0] = [entire]; mul [-1.0,infinity] [1.0, 3.0] = [-3.0,infinity]; mul [-1.0,infinity] [-infinity, -1.0] = [entire]; mul [-1.0,infinity] [-infinity, 3.0] = [entire]; mul [-1.0,infinity] [-5.0, infinity] = [entire]; mul [-1.0,infinity] [1.0, infinity] = [entire]; mul [-1.0,infinity] [entire] = [entire]; mul [-infinity,3.0] [0.0,0.0] = [0.0,0.0]; mul [-infinity,3.0] [-0.0,-0.0] = [0.0,0.0]; mul [-infinity,3.0] [-5.0, -1.0] = [-15.0,infinity]; mul [-infinity,3.0] [-5.0, 3.0] = [entire]; mul [-infinity,3.0] [1.0, 3.0] = [-infinity,9.0]; mul [-infinity,3.0] [-infinity, -1.0] = [entire]; mul [-infinity,3.0] [-infinity, 3.0] = [entire]; mul [-infinity,3.0] [-5.0, infinity] = [entire]; mul [-infinity,3.0] [1.0, infinity] = [entire]; mul [-infinity,3.0] [entire] = [entire]; mul [-infinity,-3.0] [0.0,0.0] = [0.0,0.0]; mul [-infinity,-3.0] [-0.0,-0.0] = [0.0,0.0]; mul [-infinity,-3.0] [-5.0, -1.0] = [3.0,infinity]; mul [-infinity,-3.0] [-5.0, 3.0] = [entire]; mul [-infinity,-3.0] [1.0, 3.0] = [-infinity,-3.0]; mul [-infinity,-3.0] [-infinity, -1.0] = [3.0,infinity]; mul [-infinity,-3.0] [-infinity, 3.0] = [entire]; mul [-infinity,-3.0] [-5.0, infinity] = [entire]; mul [-infinity,-3.0] [1.0, infinity] = [-infinity,-3.0]; mul [-infinity,-3.0] [entire] = [entire]; mul [0.0,0.0] [0.0,0.0] = [0.0,0.0]; mul [0.0,0.0] [-0.0,-0.0] = [0.0,0.0]; mul [0.0,0.0] [-5.0, -1.0] = [0.0,0.0]; mul [0.0,0.0] [-5.0, 3.0] = [0.0,0.0]; mul [0.0,0.0] [1.0, 3.0] = [0.0,0.0]; mul [0.0,0.0] [-infinity, -1.0] = [0.0,0.0]; mul [0.0,0.0] [-infinity, 3.0] = [0.0,0.0]; mul [0.0,0.0] [-5.0, infinity] = [0.0,0.0]; mul [0.0,0.0] [1.0, infinity] = [0.0,0.0]; mul [0.0,0.0] [entire] = [0.0,0.0]; mul [-0.0,-0.0] [0.0,0.0] = [0.0,0.0]; mul [-0.0,-0.0] [-0.0,-0.0] = [0.0,0.0]; mul [-0.0,-0.0] [-5.0, -1.0] = [0.0,0.0]; mul [-0.0,-0.0] [-5.0, 3.0] = [0.0,0.0]; mul [-0.0,-0.0] [1.0, 3.0] = [0.0,0.0]; mul [-0.0,-0.0] [-infinity, -1.0] = [0.0,0.0]; mul [-0.0,-0.0] [-infinity, 3.0] = [0.0,0.0]; mul [-0.0,-0.0] [-5.0, infinity] = [0.0,0.0]; mul [-0.0,-0.0] [1.0, infinity] = [0.0,0.0]; mul [-0.0,-0.0] [entire] = [0.0,0.0]; mul [1.0,5.0] [0.0,0.0] = [0.0,0.0]; mul [1.0,5.0] [-0.0,-0.0] = [0.0,0.0]; mul [1.0,5.0] [-5.0, -1.0] = [-25.0,-1.0]; mul [1.0,5.0] [-5.0, 3.0] = [-25.0,15.0]; mul [1.0,5.0] [1.0, 3.0] = [1.0,15.0]; mul [1.0,5.0] [-infinity, -1.0] = [-infinity,-1.0]; mul [1.0,5.0] [-infinity, 3.0] = [-infinity,15.0]; mul [1.0,5.0] [-5.0, infinity] = [-25.0,infinity]; mul [1.0,5.0] [1.0, infinity] = [1.0,infinity]; mul [1.0,5.0] [entire] = [entire]; mul [-1.0,5.0] [0.0,0.0] = [0.0,0.0]; mul [-1.0,5.0] [-0.0,-0.0] = [0.0,0.0]; mul [-1.0,5.0] [-5.0, -1.0] = [-25.0,5.0]; //min max mul [-1.0,5.0] [-5.0, 3.0] = [-25.0,15.0]; mul [-10.0,2.0] [-5.0, 3.0] = [-30.0,50.0]; mul [-1.0,5.0] [-1.0, 10.0] = [-10.0,50.0]; mul [-2.0,2.0] [-5.0, 3.0] = [-10.0,10.0]; //end min max mul [-1.0,5.0] [1.0, 3.0] = [-3.0,15.0]; mul [-1.0,5.0] [-infinity, -1.0] = [entire]; mul [-1.0,5.0] [-infinity, 3.0] = [entire]; mul [-1.0,5.0] [-5.0, infinity] = [entire]; mul [-1.0,5.0] [1.0, infinity] = [entire]; mul [-1.0,5.0] [entire] = [entire]; mul [-10.0,-5.0] [0.0,0.0] = [0.0,0.0]; mul [-10.0,-5.0] [-0.0,-0.0] = [0.0,0.0]; mul [-10.0,-5.0] [-5.0, -1.0] = [5.0,50.0]; mul [-10.0,-5.0] [-5.0, 3.0] = [-30.0,50.0]; mul [-10.0,-5.0] [1.0, 3.0] = [-30.0,-5.0]; mul [-10.0,-5.0] [-infinity, -1.0] = [5.0,infinity]; mul [-10.0,-5.0] [-infinity, 3.0] = [-30.0,infinity]; mul [-10.0,-5.0] [-5.0, infinity] = [-infinity,50.0]; mul [-10.0,-5.0] [1.0, infinity] = [-infinity,-5.0]; mul [-10.0,-5.0] [entire] = [entire]; mul [0X1.999999999999AP-4,0X1.FFFFFFFFFFFFP+0] [-0X1.FFFFFFFFFFFFP+0, infinity] = [-0X1.FFFFFFFFFFFE1P+1,infinity]; mul [-0X1.999999999999AP-4,0X1.FFFFFFFFFFFFP+0] [-0X1.FFFFFFFFFFFFP+0,-0X1.999999999999AP-4] = [-0X1.FFFFFFFFFFFE1P+1,0X1.999999999998EP-3]; mul [-0X1.999999999999AP-4,0X1.999999999999AP-4] [-0X1.FFFFFFFFFFFFP+0,0X1.999999999999AP-4] = [-0X1.999999999998EP-3,0X1.999999999998EP-3]; mul [-0X1.FFFFFFFFFFFFP+0,-0X1.999999999999AP-4] [0X1.999999999999AP-4,0X1.FFFFFFFFFFFFP+0] = [-0X1.FFFFFFFFFFFE1P+1,-0X1.47AE147AE147BP-7]; } testcase minimal_mul_dec_test { mul [1.0,2.0]_com [5.0,7.0]_com = [5.0,14.0]_com; mul [1.0,2.0]_com [5.0,7.0]_def = [5.0,14.0]_def; mul [1.0,2.0]_com [5.0,0x1.FFFFFFFFFFFFFp1023]_com = [5.0,infinity]_dac; mul [-0x1.FFFFFFFFFFFFFp1023,2.0]_com [-1.0, 5.0]_com = [-infinity,0x1.FFFFFFFFFFFFFp1023]_dac; mul [1.0,2.0]_trv [empty]_trv = [empty]_trv; } testcase minimal_div_test { div [empty] [empty] = [empty]; div [-1.0,1.0] [empty] = [empty]; div [empty] [-1.0,1.0] = [empty]; div [empty] [0.1,1.0] = [empty]; div [empty] [-1.0,-0.1] = [empty]; div [empty] [entire] = [empty]; div [entire] [empty] = [empty]; div [0.0,0.0] [empty] = [empty]; div [empty] [0.0,0.0] = [empty]; div [-0.0,-0.0] [empty] = [empty]; div [empty] [-0.0,-0.0] = [empty]; div [entire] [-5.0, -3.0] = [entire]; div [entire] [3.0, 5.0] = [entire]; div [entire] [-infinity, -3.0] = [entire]; div [entire] [3.0,infinity] = [entire]; div [entire] [0.0,0.0] = [empty]; div [entire] [-0.0,-0.0] = [empty]; div [entire] [-3.0, 0.0] = [entire]; div [entire] [-3.0, -0.0] = [entire]; div [entire] [-3.0, 3.0] = [entire]; div [entire] [0.0, 3.0] = [entire]; div [entire] [-infinity, 0.0] = [entire]; div [entire] [-0.0, 3.0] = [entire]; div [entire] [-infinity, -0.0] = [entire]; div [entire] [-infinity, 3.0] = [entire]; div [entire] [-3.0, infinity] = [entire]; div [entire] [0.0, infinity] = [entire]; div [entire] [-0.0, infinity] = [entire]; div [entire] [entire] = [entire]; div [-30.0,-15.0] [-5.0, -3.0] = [3.0,10.0]; div [-30.0,-15.0] [3.0, 5.0] = [-10.0,-3.0]; div [-30.0,-15.0] [-infinity, -3.0] = [0.0,10.0]; div [-30.0,-15.0] [3.0,infinity] = [-10.0,0.0]; div [-30.0,-15.0] [0.0,0.0] = [empty]; div [-30.0,-15.0] [-3.0, 0.0] = [5.0,infinity]; div [-30.0,-15.0] [-0.0,-0.0] = [empty]; div [-30.0,-15.0] [-3.0, -0.0] = [5.0,infinity]; div [-30.0,-15.0] [-3.0, 3.0] = [entire]; div [-30.0,-15.0] [0.0, 3.0] = [-infinity,-5.0]; div [-30.0,-15.0] [-infinity, 0.0] = [0.0,infinity]; div [-30.0,-15.0] [-0.0, 3.0] = [-infinity,-5.0]; div [-30.0,-15.0] [-infinity, -0.0] = [0.0,infinity]; div [-30.0,-15.0] [-infinity, 3.0] = [entire]; div [-30.0,-15.0] [-3.0, infinity] = [entire]; div [-30.0,-15.0] [0.0, infinity] = [-infinity,0.0]; div [-30.0,-15.0] [-0.0, infinity] = [-infinity,0.0]; div [-30.0,-15.0] [entire] = [entire]; div [-30.0,15.0] [-5.0, -3.0] = [-5.0,10.0]; div [-30.0,15.0] [3.0, 5.0] = [-10.0,5.0]; div [-30.0,15.0] [-infinity, -3.0] = [-5.0,10.0]; div [-30.0,15.0] [3.0,infinity] = [-10.0,5.0]; div [-30.0,15.0] [0.0,0.0] = [empty]; div [-30.0,15.0] [-0.0,-0.0] = [empty]; div [-30.0,15.0] [-3.0, 0.0] = [entire]; div [-30.0,15.0] [-3.0, -0.0] = [entire]; div [-30.0,15.0] [-3.0, 3.0] = [entire]; div [-30.0,15.0] [0.0, 3.0] = [entire]; div [-30.0,15.0] [-infinity, 0.0] = [entire]; div [-30.0,15.0] [-0.0, 3.0] = [entire]; div [-30.0,15.0] [-infinity, -0.0] = [entire]; div [-30.0,15.0] [-infinity, 3.0] = [entire]; div [-30.0,15.0] [-3.0, infinity] = [entire]; div [-30.0,15.0] [0.0, infinity] = [entire]; div [-30.0,15.0] [-0.0, infinity] = [entire]; div [-30.0,15.0] [entire] = [entire]; div [15.0,30.0] [-5.0, -3.0] = [-10.0,-3.0]; div [15.0,30.0] [3.0, 5.0] = [3.0,10.0]; div [15.0,30.0] [-infinity, -3.0] = [-10.0,0.0]; div [15.0,30.0] [3.0,infinity] = [0.0,10.0]; div [15.0,30.0] [0.0,0.0] = [empty]; div [15.0,30.0] [-3.0, 0.0] = [-infinity,-5.0]; div [15.0,30.0] [-0.0,-0.0] = [empty]; div [15.0,30.0] [-3.0, -0.0] = [-infinity,-5.0]; div [15.0,30.0] [-3.0, 3.0] = [entire]; div [15.0,30.0] [0.0, 3.0] = [5.0,infinity]; div [15.0,30.0] [-infinity, 0.0] = [-infinity,0.0]; div [15.0,30.0] [-0.0, 3.0] = [5.0,infinity]; div [15.0,30.0] [-infinity, -0.0] = [-infinity,0.0]; div [15.0,30.0] [-infinity, 3.0] = [entire]; div [15.0,30.0] [-3.0, infinity] = [entire]; div [15.0,30.0] [0.0, infinity] = [0.0,infinity]; div [15.0,30.0] [-0.0, infinity] = [0.0,infinity]; div [15.0,30.0] [entire] = [entire]; div [0.0,0.0] [-5.0, -3.0] = [0.0,0.0]; div [0.0,0.0] [3.0, 5.0] = [0.0,0.0]; div [0.0,0.0] [-infinity, -3.0] = [0.0,0.0]; div [0.0,0.0] [3.0,infinity] = [0.0,0.0]; div [0.0,0.0] [0.0,0.0] = [empty]; div [0.0,0.0] [-3.0, 0.0] = [0.0,0.0]; div [0.0,0.0] [-0.0,-0.0] = [empty]; div [0.0,0.0] [-3.0, -0.0] = [0.0,0.0]; div [0.0,0.0] [-3.0, 3.0] = [0.0,0.0]; div [0.0,0.0] [0.0, 3.0] = [0.0,0.0]; div [0.0,0.0] [-infinity, 0.0] = [0.0,0.0]; div [0.0,0.0] [-0.0, 3.0] = [0.0,0.0]; div [0.0,0.0] [-infinity, -0.0] = [0.0,0.0]; div [0.0,0.0] [-infinity, 3.0] = [0.0,0.0]; div [0.0,0.0] [-3.0, infinity] = [0.0,0.0]; div [0.0,0.0] [0.0, infinity] = [0.0,0.0]; div [0.0,0.0] [-0.0, infinity] = [0.0,0.0]; div [0.0,0.0] [entire] = [0.0,0.0]; div [-0.0,-0.0] [-5.0, -3.0] = [0.0,0.0]; div [-0.0,-0.0] [3.0, 5.0] = [0.0,0.0]; div [-0.0,-0.0] [-infinity, -3.0] = [0.0,0.0]; div [-0.0,-0.0] [3.0,infinity] = [0.0,0.0]; div [-0.0,-0.0] [0.0,0.0] = [empty]; div [-0.0,-0.0] [-3.0, 0.0] = [0.0,0.0]; div [-0.0,-0.0] [-0.0,-0.0] = [empty]; div [-0.0,-0.0] [-3.0, -0.0] = [0.0,0.0]; div [-0.0,-0.0] [-3.0, 3.0] = [0.0,0.0]; div [-0.0,-0.0] [0.0, 3.0] = [0.0,0.0]; div [-0.0,-0.0] [-infinity, 0.0] = [0.0,0.0]; div [-0.0,-0.0] [-0.0, 3.0] = [0.0,0.0]; div [-0.0,-0.0] [-infinity, -0.0] = [0.0,0.0]; div [-0.0,-0.0] [-infinity, 3.0] = [0.0,0.0]; div [-0.0,-0.0] [-3.0, infinity] = [0.0,0.0]; div [-0.0,-0.0] [0.0, infinity] = [0.0,0.0]; div [-0.0,-0.0] [-0.0, infinity] = [0.0,0.0]; div [-0.0,-0.0] [entire] = [0.0,0.0]; div [-infinity,-15.0] [-5.0, -3.0] = [3.0,infinity]; div [-infinity,-15.0] [3.0, 5.0] = [-infinity,-3.0]; div [-infinity,-15.0] [-infinity, -3.0] = [0.0,infinity]; div [-infinity,-15.0] [3.0,infinity] = [-infinity,0.0]; div [-infinity,-15.0] [0.0,0.0] = [empty]; div [-infinity,-15.0] [-3.0, 0.0] = [5.0,infinity]; div [-infinity,-15.0] [-0.0,-0.0] = [empty]; div [-infinity,-15.0] [-3.0, -0.0] = [5.0,infinity]; div [-infinity,-15.0] [-3.0, 3.0] = [entire]; div [-infinity,-15.0] [0.0, 3.0] = [-infinity,-5.0]; div [-infinity,-15.0] [-infinity, 0.0] = [0.0,infinity]; div [-infinity,-15.0] [-0.0, 3.0] = [-infinity,-5.0]; div [-infinity,-15.0] [-infinity, -0.0] = [0.0,infinity]; div [-infinity,-15.0] [-infinity, 3.0] = [entire]; div [-infinity,-15.0] [-3.0, infinity] = [entire]; div [-infinity,-15.0] [0.0, infinity] = [-infinity,0.0]; div [-infinity,-15.0] [-0.0, infinity] = [-infinity,0.0]; div [-infinity,-15.0] [entire] = [entire]; div [-infinity,15.0] [-5.0, -3.0] = [-5.0,infinity]; div [-infinity,15.0] [3.0, 5.0] = [-infinity,5.0]; div [-infinity,15.0] [-infinity, -3.0] = [-5.0,infinity]; div [-infinity,15.0] [3.0,infinity] = [-infinity,5.0]; div [-infinity,15.0] [0.0,0.0] = [empty]; div [-infinity,15.0] [-3.0, 0.0] = [entire]; div [-infinity,15.0] [-0.0,-0.0] = [empty]; div [-infinity,15.0] [-3.0, -0.0] = [entire]; div [-infinity,15.0] [-3.0, 3.0] = [entire]; div [-infinity,15.0] [0.0, 3.0] = [entire]; div [-infinity,15.0] [-infinity, 0.0] = [entire]; div [-infinity,15.0] [-0.0, 3.0] = [entire]; div [-infinity,15.0] [-infinity, -0.0] = [entire]; div [-infinity,15.0] [-infinity, 3.0] = [entire]; div [-infinity,15.0] [-3.0, infinity] = [entire]; div [-infinity,15.0] [0.0, infinity] = [entire]; div [-infinity,15.0] [-0.0, infinity] = [entire]; div [-infinity,15.0] [entire] = [entire]; div [-15.0,infinity] [-5.0, -3.0] = [-infinity,5.0]; div [-15.0,infinity] [3.0, 5.0] = [-5.0,infinity]; div [-15.0,infinity] [-infinity, -3.0] = [-infinity,5.0]; div [-15.0,infinity] [3.0,infinity] = [-5.0,infinity]; div [-15.0,infinity] [0.0,0.0] = [empty]; div [-15.0,infinity] [-3.0, 0.0] = [entire]; div [-15.0,infinity] [-0.0,-0.0] = [empty]; div [-15.0,infinity] [-3.0, -0.0] = [entire]; div [-15.0,infinity] [-3.0, 3.0] = [entire]; div [-15.0,infinity] [0.0, 3.0] = [entire]; div [-15.0,infinity] [-infinity, 0.0] = [entire]; div [-15.0,infinity] [-0.0, 3.0] = [entire]; div [-15.0,infinity] [-infinity, -0.0] = [entire]; div [-15.0,infinity] [-infinity, 3.0] = [entire]; div [-15.0,infinity] [-3.0, infinity] = [entire]; div [-15.0,infinity] [0.0, infinity] = [entire]; div [-15.0,infinity] [-0.0, infinity] = [entire]; div [-15.0,infinity] [entire] = [entire]; div [15.0,infinity] [-5.0, -3.0] = [-infinity,-3.0]; div [15.0,infinity] [3.0, 5.0] = [3.0,infinity]; div [15.0,infinity] [-infinity, -3.0] = [-infinity,0.0]; div [15.0,infinity] [3.0,infinity] = [0.0,infinity]; div [15.0,infinity] [0.0,0.0] = [empty]; div [15.0,infinity] [-3.0, 0.0] = [-infinity,-5.0]; div [15.0,infinity] [-0.0,-0.0] = [empty]; div [15.0,infinity] [-3.0, -0.0] = [-infinity,-5.0]; div [15.0,infinity] [-3.0, 3.0] = [entire]; div [15.0,infinity] [0.0, 3.0] = [5.0,infinity]; div [15.0,infinity] [-infinity, 0.0] = [-infinity,0.0]; div [15.0,infinity] [-0.0, 3.0] = [5.0,infinity]; div [15.0,infinity] [-infinity, -0.0] = [-infinity,0.0]; div [15.0,infinity] [-infinity, 3.0] = [entire]; div [15.0,infinity] [-3.0, infinity] = [entire]; div [15.0,infinity] [0.0, infinity] = [0.0,infinity]; div [15.0,infinity] [-0.0, infinity] = [0.0,infinity]; div [15.0,infinity] [entire] = [entire]; div [-30.0,0.0] [-5.0, -3.0] = [0.0,10.0]; div [-30.0,0.0] [3.0, 5.0] = [-10.0,0.0]; div [-30.0,0.0] [-infinity, -3.0] = [0.0,10.0]; div [-30.0,0.0] [3.0,infinity] = [-10.0,0.0]; div [-30.0,0.0] [0.0,0.0] = [empty]; div [-30.0,0.0] [-3.0, 0.0] = [0.0,infinity]; div [-30.0,0.0] [-0.0,-0.0] = [empty]; div [-30.0,0.0] [-3.0, -0.0] = [0.0,infinity]; div [-30.0,0.0] [-3.0, 3.0] = [entire]; div [-30.0,0.0] [0.0, 3.0] = [-infinity,0.0]; div [-30.0,0.0] [-infinity, 0.0] = [0.0,infinity]; div [-30.0,0.0] [-0.0, 3.0] = [-infinity,0.0]; div [-30.0,0.0] [-infinity, -0.0] = [0.0,infinity]; div [-30.0,0.0] [-infinity, 3.0] = [entire]; div [-30.0,0.0] [-3.0, infinity] = [entire]; div [-30.0,0.0] [0.0, infinity] = [-infinity,0.0]; div [-30.0,0.0] [-0.0, infinity] = [-infinity,0.0]; div [-30.0,0.0] [entire] = [entire]; div [-30.0,-0.0] [-5.0, -3.0] = [0.0,10.0]; div [-30.0,-0.0] [3.0, 5.0] = [-10.0,0.0]; div [-30.0,-0.0] [-infinity, -3.0] = [0.0,10.0]; div [-30.0,-0.0] [3.0,infinity] = [-10.0,0.0]; div [-30.0,-0.0] [0.0,0.0] = [empty]; div [-30.0,-0.0] [-3.0, 0.0] = [0.0,infinity]; div [-30.0,-0.0] [-0.0,-0.0] = [empty]; div [-30.0,-0.0] [-3.0, -0.0] = [0.0,infinity]; div [-30.0,-0.0] [-3.0, 3.0] = [entire]; div [-30.0,-0.0] [0.0, 3.0] = [-infinity,0.0]; div [-30.0,-0.0] [-infinity, 0.0] = [0.0,infinity]; div [-30.0,-0.0] [-0.0, 3.0] = [-infinity,0.0]; div [-30.0,-0.0] [-infinity, -0.0] = [0.0,infinity]; div [-30.0,-0.0] [-infinity, 3.0] = [entire]; div [-30.0,-0.0] [-3.0, infinity] = [entire]; div [-30.0,-0.0] [0.0, infinity] = [-infinity,0.0]; div [-30.0,-0.0] [-0.0, infinity] = [-infinity,0.0]; div [-30.0,-0.0] [entire] = [entire]; div [0.0,30.0] [-5.0, -3.0] = [-10.0,0.0]; div [0.0,30.0] [3.0, 5.0] = [0.0,10.0]; div [0.0,30.0] [-infinity, -3.0] = [-10.0,0.0]; div [0.0,30.0] [3.0,infinity] = [0.0,10.0]; div [0.0,30.0] [0.0,0.0] = [empty]; div [0.0,30.0] [-3.0, 0.0] = [-infinity,0.0]; div [0.0,30.0] [-0.0,-0.0] = [empty]; div [0.0,30.0] [-3.0, -0.0] = [-infinity,0.0]; div [0.0,30.0] [-3.0, 3.0] = [entire]; div [0.0,30.0] [0.0, 3.0] = [0.0,infinity]; div [0.0,30.0] [-infinity, 0.0] = [-infinity,0.0]; div [0.0,30.0] [-0.0, 3.0] = [0.0,infinity]; div [0.0,30.0] [-infinity, -0.0] = [-infinity,0.0]; div [0.0,30.0] [-infinity, 3.0] = [entire]; div [0.0,30.0] [-3.0, infinity] = [entire]; div [0.0,30.0] [0.0, infinity] = [0.0,infinity]; div [0.0,30.0] [-0.0, infinity] = [0.0,infinity]; div [0.0,30.0] [entire] = [entire]; div [-0.0,30.0] [-5.0, -3.0] = [-10.0,0.0]; div [-0.0,30.0] [3.0, 5.0] = [0.0,10.0]; div [-0.0,30.0] [-infinity, -3.0] = [-10.0,0.0]; div [-0.0,30.0] [3.0,infinity] = [0.0,10.0]; div [-0.0,30.0] [0.0,0.0] = [empty]; div [-0.0,30.0] [-3.0, 0.0] = [-infinity,0.0]; div [-0.0,30.0] [-0.0,-0.0] = [empty]; div [-0.0,30.0] [-3.0, -0.0] = [-infinity,0.0]; div [-0.0,30.0] [-3.0, 3.0] = [entire]; div [-0.0,30.0] [0.0, 3.0] = [0.0,infinity]; div [-0.0,30.0] [-infinity, 0.0] = [-infinity,0.0]; div [-0.0,30.0] [-0.0, 3.0] = [0.0,infinity]; div [-0.0,30.0] [-infinity, -0.0] = [-infinity,0.0]; div [-0.0,30.0] [-infinity, 3.0] = [entire]; div [-0.0,30.0] [-3.0, infinity] = [entire]; div [-0.0,30.0] [0.0, infinity] = [0.0,infinity]; div [-0.0,30.0] [-0.0, infinity] = [0.0,infinity]; div [-0.0,30.0] [entire] = [entire]; div [-infinity,0.0] [-5.0, -3.0] = [0.0,infinity]; div [-infinity,0.0] [3.0, 5.0] = [-infinity,0.0]; div [-infinity,0.0] [-infinity, -3.0] = [0.0,infinity]; div [-infinity,0.0] [3.0,infinity] = [-infinity,0.0]; div [-infinity,0.0] [0.0,0.0] = [empty]; div [-infinity,0.0] [-3.0, 0.0] = [0.0,infinity]; div [-infinity,0.0] [-0.0,-0.0] = [empty]; div [-infinity,0.0] [-3.0, -0.0] = [0.0,infinity]; div [-infinity,0.0] [-3.0, 3.0] = [entire]; div [-infinity,0.0] [0.0, 3.0] = [-infinity,0.0]; div [-infinity,0.0] [-infinity, 0.0] = [0.0,infinity]; div [-infinity,0.0] [-0.0, 3.0] = [-infinity,0.0]; div [-infinity,0.0] [-infinity, -0.0] = [0.0,infinity]; div [-infinity,0.0] [-infinity, 3.0] = [entire]; div [-infinity,0.0] [-3.0, infinity] = [entire]; div [-infinity,0.0] [0.0, infinity] = [-infinity,0.0]; div [-infinity,0.0] [-0.0, infinity] = [-infinity,0.0]; div [-infinity,0.0] [entire] = [entire]; div [-infinity,-0.0] [-5.0, -3.0] = [0.0,infinity]; div [-infinity,-0.0] [3.0, 5.0] = [-infinity,0.0]; div [-infinity,-0.0] [-infinity, -3.0] = [0.0,infinity]; div [-infinity,-0.0] [3.0,infinity] = [-infinity,0.0]; div [-infinity,-0.0] [0.0,0.0] = [empty]; div [-infinity,-0.0] [-3.0, 0.0] = [0.0,infinity]; div [-infinity,-0.0] [-0.0,-0.0] = [empty]; div [-infinity,-0.0] [-3.0, -0.0] = [0.0,infinity]; div [-infinity,-0.0] [-3.0, 3.0] = [entire]; div [-infinity,-0.0] [0.0, 3.0] = [-infinity,0.0]; div [-infinity,-0.0] [-infinity, 0.0] = [0.0,infinity]; div [-infinity,-0.0] [-0.0, 3.0] = [-infinity,0.0]; div [-infinity,-0.0] [-infinity, -0.0] = [0.0,infinity]; div [-infinity,-0.0] [-infinity, 3.0] = [entire]; div [-infinity,-0.0] [-3.0, infinity] = [entire]; div [-infinity,-0.0] [0.0, infinity] = [-infinity,0.0]; div [-infinity,-0.0] [-0.0, infinity] = [-infinity,0.0]; div [-infinity,-0.0] [entire] = [entire]; div [0.0,infinity] [-5.0, -3.0] = [-infinity,0.0]; div [0.0,infinity] [3.0, 5.0] = [0.0,infinity]; div [0.0,infinity] [-infinity, -3.0] = [-infinity,0.0]; div [0.0,infinity] [3.0,infinity] = [0.0,infinity]; div [0.0,infinity] [0.0,0.0] = [empty]; div [0.0,infinity] [-3.0, 0.0] = [-infinity,0.0]; div [0.0,infinity] [-0.0,-0.0] = [empty]; div [0.0,infinity] [-3.0, -0.0] = [-infinity,0.0]; div [0.0,infinity] [-3.0, 3.0] = [entire]; div [0.0,infinity] [0.0, 3.0] = [0.0,infinity]; div [0.0,infinity] [-infinity, 0.0] = [-infinity,0.0]; div [0.0,infinity] [-0.0, 3.0] = [0.0,infinity]; div [0.0,infinity] [-infinity, -0.0] = [-infinity,0.0]; div [0.0,infinity] [-infinity, 3.0] = [entire]; div [0.0,infinity] [-3.0, infinity] = [entire]; div [0.0,infinity] [0.0, infinity] = [0.0,infinity]; div [0.0,infinity] [-0.0, infinity] = [0.0,infinity]; div [0.0,infinity] [entire] = [entire]; div [-0.0,infinity] [-5.0, -3.0] = [-infinity,0.0]; div [-0.0,infinity] [3.0, 5.0] = [0.0,infinity]; div [-0.0,infinity] [-infinity, -3.0] = [-infinity,0.0]; div [-0.0,infinity] [3.0,infinity] = [0.0,infinity]; div [-0.0,infinity] [0.0,0.0] = [empty]; div [-0.0,infinity] [-3.0, 0.0] = [-infinity,0.0]; div [-0.0,infinity] [-0.0,-0.0] = [empty]; div [-0.0,infinity] [-3.0, -0.0] = [-infinity,0.0]; div [-0.0,infinity] [-3.0, 3.0] = [entire]; div [-0.0,infinity] [0.0, 3.0] = [0.0,infinity]; div [-0.0,infinity] [-infinity, 0.0] = [-infinity,0.0]; div [-0.0,infinity] [-0.0, 3.0] = [0.0,infinity]; div [-0.0,infinity] [-infinity, -0.0] = [-infinity,0.0]; div [-0.0,infinity] [-infinity, 3.0] = [entire]; div [-0.0,infinity] [-3.0, infinity] = [entire]; div [-0.0,infinity] [0.0, infinity] = [0.0,infinity]; div [-0.0,infinity] [-0.0, infinity] = [0.0,infinity]; div [-0.0,infinity] [entire] = [entire]; div [-2.0,-1.0] [-10.0, -3.0] = [0X1.9999999999999P-4,0X1.5555555555556P-1]; div [-2.0,-1.0] [0.0, 10.0] = [-infinity,-0X1.9999999999999P-4]; div [-2.0,-1.0] [-0.0, 10.0] = [-infinity,-0X1.9999999999999P-4]; div [-1.0,2.0] [10.0,infinity] = [-0X1.999999999999AP-4,0X1.999999999999AP-3]; div [1.0,3.0] [-infinity, -10.0] = [-0X1.3333333333334P-2,0.0]; div [-infinity,-1.0] [1.0, 3.0] = [-infinity,-0X1.5555555555555P-2]; } testcase minimal_div_dec_test { div [-2.0,-1.0]_com [-10.0, -3.0]_com = [0X1.9999999999999P-4,0X1.5555555555556P-1]_com; div [-200.0,-1.0]_com [0x0.0000000000001p-1022, 10.0]_com = [-infinity,-0X1.9999999999999P-4]_dac; div [-2.0,-1.0]_com [0.0, 10.0]_com = [-infinity,-0X1.9999999999999P-4]_trv; div [1.0,3.0]_def [-infinity, -10.0]_dac = [-0X1.3333333333334P-2,0.0]_def; div [1.0,2.0]_trv [empty]_trv = [empty]_trv; } testcase minimal_recip_test { recip [-50.0, -10.0] = [-0X1.999999999999AP-4,-0X1.47AE147AE147AP-6]; recip [10.0, 50.0] = [0X1.47AE147AE147AP-6,0X1.999999999999AP-4]; recip [-infinity, -10.0] = [-0X1.999999999999AP-4,0.0]; recip [10.0,infinity] = [0.0,0X1.999999999999AP-4]; recip [0.0,0.0] = [empty]; recip [-0.0,-0.0] = [empty]; recip [-10.0, 0.0] = [-infinity,-0X1.9999999999999P-4]; recip [-10.0, -0.0] = [-infinity,-0X1.9999999999999P-4]; recip [-10.0, 10.0] = [entire]; recip [0.0, 10.0] = [0X1.9999999999999P-4,infinity]; recip [-0.0, 10.0] = [0X1.9999999999999P-4,infinity]; recip [-infinity, 0.0] = [-infinity,0.0]; recip [-infinity, -0.0] = [-infinity,0.0]; recip [-infinity, 10.0] = [entire]; recip [-10.0, infinity] = [entire]; recip [0.0, infinity] = [0.0,infinity]; recip [-0.0, infinity] = [0.0,infinity]; recip [entire] = [entire]; } testcase minimal_recip_dec_test { recip [10.0, 50.0]_com = [0X1.47AE147AE147AP-6,0X1.999999999999AP-4]_com; recip [-infinity, -10.0]_dac = [-0X1.999999999999AP-4,0.0]_dac; recip [-0x1.FFFFFFFFFFFFFp1023, -0x0.0000000000001p-1022]_def = [-infinity,-0X0.4P-1022]_def; recip [0.0,0.0]_com = [empty]_trv; recip [-10.0, 0.0]_com = [-infinity,-0X1.9999999999999P-4]_trv; recip [-10.0, infinity]_dac = [entire]_trv; recip [-0.0, infinity]_dac = [0.0,infinity]_trv; recip [entire]_def = [entire]_trv; } testcase minimal_sqr_test { sqr [empty] = [empty]; sqr [entire] = [0.0,infinity]; sqr [-infinity,-0x0.0000000000001p-1022] = [0.0,infinity]; sqr [-1.0,1.0] = [0.0,1.0]; sqr [0.0,1.0] = [0.0,1.0]; sqr [-0.0,1.0] = [0.0,1.0]; sqr [-5.0,3.0] = [0.0,25.0]; sqr [-5.0,0.0] = [0.0,25.0]; sqr [-5.0,-0.0] = [0.0,25.0]; sqr [0X1.999999999999AP-4,0X1.999999999999AP-4] = [0X1.47AE147AE147BP-7,0X1.47AE147AE147CP-7]; sqr [-0X1.FFFFFFFFFFFFP+0,0X1.999999999999AP-4] = [0.0,0X1.FFFFFFFFFFFE1P+1]; sqr [-0X1.FFFFFFFFFFFFP+0,-0X1.FFFFFFFFFFFFP+0] = [0X1.FFFFFFFFFFFEP+1,0X1.FFFFFFFFFFFE1P+1]; } testcase minimal_sqr_dec_test { sqr [-0x1.FFFFFFFFFFFFFp1023,-0x0.0000000000001p-1022]_com = [0.0,infinity]_dac; sqr [-1.0,1.0]_def = [0.0,1.0]_def; sqr [-5.0,3.0]_com = [0.0,25.0]_com; sqr [0X1.999999999999AP-4,0X1.999999999999AP-4]_com = [0X1.47AE147AE147BP-7,0X1.47AE147AE147CP-7]_com; } testcase minimal_sqrt_test { sqrt [empty] = [empty]; sqrt [entire] = [0.0,infinity]; sqrt [-infinity,-0x0.0000000000001p-1022] = [empty]; sqrt [-1.0,1.0] = [0.0,1.0]; sqrt [0.0,1.0] = [0.0,1.0]; sqrt [-0.0,1.0] = [0.0,1.0]; sqrt [-5.0,25.0] = [0.0,5.0]; sqrt [0.0,25.0] = [0.0,5.0]; sqrt [-0.0,25.0] = [0.0,5.0]; sqrt [-5.0,infinity] = [0.0,infinity]; sqrt [0X1.999999999999AP-4,0X1.999999999999AP-4] = [0X1.43D136248490FP-2,0X1.43D136248491P-2]; sqrt [-0X1.FFFFFFFFFFFFP+0,0X1.999999999999AP-4] = [0.0,0X1.43D136248491P-2]; sqrt [0X1.999999999999AP-4,0X1.FFFFFFFFFFFFP+0] = [0X1.43D136248490FP-2,0X1.6A09E667F3BC7P+0]; } testcase minimal_sqrt_dec_test { sqrt [1.0,4.0]_com = [1.0,2.0]_com; sqrt [-5.0,25.0]_com = [0.0,5.0]_trv; sqrt [0.0,25.0]_def = [0.0,5.0]_def; sqrt [-5.0,infinity]_dac = [0.0,infinity]_trv; } testcase minimal_fma_test { fma [empty] [empty] [empty] = [empty]; fma [-1.0,1.0] [empty] [empty] = [empty]; fma [empty] [-1.0,1.0] [empty] = [empty]; fma [empty] [entire] [empty] = [empty]; fma [entire] [empty] [empty] = [empty]; fma [0.0,0.0] [empty] [empty] = [empty]; fma [-0.0,-0.0] [empty] [empty] = [empty]; fma [empty] [0.0,0.0] [empty] = [empty]; fma [empty] [-0.0,-0.0] [empty] = [empty]; fma [entire] [0.0,0.0] [empty] = [empty]; fma [entire] [-0.0,-0.0] [empty] = [empty]; fma [entire] [-5.0, -1.0] [empty] = [empty]; fma [entire] [-5.0, 3.0] [empty] = [empty]; fma [entire] [1.0, 3.0] [empty] = [empty]; fma [entire] [-infinity, -1.0] [empty] = [empty]; fma [entire] [-infinity, 3.0] [empty] = [empty]; fma [entire] [-5.0, infinity] [empty] = [empty]; fma [entire] [1.0, infinity] [empty] = [empty]; fma [entire] [entire] [empty] = [empty]; fma [1.0,infinity] [0.0,0.0] [empty] = [empty]; fma [1.0,infinity] [-0.0,-0.0] [empty] = [empty]; fma [1.0,infinity] [-5.0, -1.0] [empty] = [empty]; fma [1.0,infinity] [-5.0, 3.0] [empty] = [empty]; fma [1.0,infinity] [1.0, 3.0] [empty] = [empty]; fma [1.0,infinity] [-infinity, -1.0] [empty] = [empty]; fma [1.0,infinity] [-infinity, 3.0] [empty] = [empty]; fma [1.0,infinity] [-5.0, infinity] [empty] = [empty]; fma [1.0,infinity] [1.0, infinity] [empty] = [empty]; fma [1.0,infinity] [entire] [empty] = [empty]; fma [-1.0,infinity] [0.0,0.0] [empty] = [empty]; fma [-1.0,infinity] [-0.0,-0.0] [empty] = [empty]; fma [-1.0,infinity] [-5.0, -1.0] [empty] = [empty]; fma [-1.0,infinity] [-5.0, 3.0] [empty] = [empty]; fma [-1.0,infinity] [1.0, 3.0] [empty] = [empty]; fma [-1.0,infinity] [-infinity, -1.0] [empty] = [empty]; fma [-1.0,infinity] [-infinity, 3.0] [empty] = [empty]; fma [-1.0,infinity] [-5.0, infinity] [empty] = [empty]; fma [-1.0,infinity] [1.0, infinity] [empty] = [empty]; fma [-1.0,infinity] [entire] [empty] = [empty]; fma [-infinity,3.0] [0.0,0.0] [empty] = [empty]; fma [-infinity,3.0] [-0.0,-0.0] [empty] = [empty]; fma [-infinity,3.0] [-5.0, -1.0] [empty] = [empty]; fma [-infinity,3.0] [-5.0, 3.0] [empty] = [empty]; fma [-infinity,3.0] [1.0, 3.0] [empty] = [empty]; fma [-infinity,3.0] [-infinity, -1.0] [empty] = [empty]; fma [-infinity,3.0] [-infinity, 3.0] [empty] = [empty]; fma [-infinity,3.0] [-5.0, infinity] [empty] = [empty]; fma [-infinity,3.0] [1.0, infinity] [empty] = [empty]; fma [-infinity,3.0] [entire] [empty] = [empty]; fma [-infinity,-3.0] [0.0,0.0] [empty] = [empty]; fma [-infinity,-3.0] [-0.0,-0.0] [empty] = [empty]; fma [-infinity,-3.0] [-5.0, -1.0] [empty] = [empty]; fma [-infinity,-3.0] [-5.0, 3.0] [empty] = [empty]; fma [-infinity,-3.0] [1.0, 3.0] [empty] = [empty]; fma [-infinity,-3.0] [-infinity, -1.0] [empty] = [empty]; fma [-infinity,-3.0] [-infinity, 3.0] [empty] = [empty]; fma [-infinity,-3.0] [-5.0, infinity] [empty] = [empty]; fma [-infinity,-3.0] [1.0, infinity] [empty] = [empty]; fma [-infinity,-3.0] [entire] [empty] = [empty]; fma [0.0,0.0] [0.0,0.0] [empty] = [empty]; fma [0.0,0.0] [-0.0,-0.0] [empty] = [empty]; fma [0.0,0.0] [-5.0, -1.0] [empty] = [empty]; fma [0.0,0.0] [-5.0, 3.0] [empty] = [empty]; fma [0.0,0.0] [1.0, 3.0] [empty] = [empty]; fma [0.0,0.0] [-infinity, -1.0] [empty] = [empty]; fma [0.0,0.0] [-infinity, 3.0] [empty] = [empty]; fma [0.0,0.0] [-5.0, infinity] [empty] = [empty]; fma [0.0,0.0] [1.0, infinity] [empty] = [empty]; fma [0.0,0.0] [entire] [empty] = [empty]; fma [-0.0,-0.0] [0.0,0.0] [empty] = [empty]; fma [-0.0,-0.0] [-0.0,-0.0] [empty] = [empty]; fma [-0.0,-0.0] [-5.0, -1.0] [empty] = [empty]; fma [-0.0,-0.0] [-5.0, 3.0] [empty] = [empty]; fma [-0.0,-0.0] [1.0, 3.0] [empty] = [empty]; fma [-0.0,-0.0] [-infinity, -1.0] [empty] = [empty]; fma [-0.0,-0.0] [-infinity, 3.0] [empty] = [empty]; fma [-0.0,-0.0] [-5.0, infinity] [empty] = [empty]; fma [-0.0,-0.0] [1.0, infinity] [empty] = [empty]; fma [-0.0,-0.0] [entire] [empty] = [empty]; fma [1.0,5.0] [0.0,0.0] [empty] = [empty]; fma [1.0,5.0] [-0.0,-0.0] [empty] = [empty]; fma [1.0,5.0] [-5.0, -1.0] [empty] = [empty]; fma [1.0,5.0] [-5.0, 3.0] [empty] = [empty]; fma [1.0,5.0] [1.0, 3.0] [empty] = [empty]; fma [1.0,5.0] [-infinity, -1.0] [empty] = [empty]; fma [1.0,5.0] [-infinity, 3.0] [empty] = [empty]; fma [1.0,5.0] [-5.0, infinity] [empty] = [empty]; fma [1.0,5.0] [1.0, infinity] [empty] = [empty]; fma [1.0,5.0] [entire] [empty] = [empty]; fma [-1.0,5.0] [0.0,0.0] [empty] = [empty]; fma [-1.0,5.0] [-0.0,-0.0] [empty] = [empty]; fma [-1.0,5.0] [-5.0, -1.0] [empty] = [empty]; //min max fma [-1.0,5.0] [-5.0, 3.0] [empty] = [empty]; fma [-10.0,2.0] [-5.0, 3.0] [empty] = [empty]; fma [-1.0,5.0] [-1.0, 10.0] [empty] = [empty]; fma [-2.0,2.0] [-5.0, 3.0] [empty] = [empty]; //end min max fma [-1.0,5.0] [1.0, 3.0] [empty] = [empty]; fma [-1.0,5.0] [-infinity, -1.0] [empty] = [empty]; fma [-1.0,5.0] [-infinity, 3.0] [empty] = [empty]; fma [-1.0,5.0] [-5.0, infinity] [empty] = [empty]; fma [-1.0,5.0] [1.0, infinity] [empty] = [empty]; fma [-1.0,5.0] [entire] [empty] = [empty]; fma [-10.0,-5.0] [0.0,0.0] [empty] = [empty]; fma [-10.0,-5.0] [-0.0,-0.0] [empty] = [empty]; fma [-10.0,-5.0] [-5.0, -1.0] [empty] = [empty]; fma [-10.0,-5.0] [-5.0, 3.0] [empty] = [empty]; fma [-10.0,-5.0] [1.0, 3.0] [empty] = [empty]; fma [-10.0,-5.0] [-infinity, -1.0] [empty] = [empty]; fma [-10.0,-5.0] [-infinity, 3.0] [empty] = [empty]; fma [-10.0,-5.0] [-5.0, infinity] [empty] = [empty]; fma [-10.0,-5.0] [1.0, infinity] [empty] = [empty]; fma [-10.0,-5.0] [entire] [empty] = [empty]; fma [empty] [empty] [-infinity,2.0] = [empty]; fma [-1.0,1.0] [empty] [-infinity,2.0] = [empty]; fma [empty] [-1.0,1.0] [-infinity,2.0] = [empty]; fma [empty] [entire] [-infinity,2.0] = [empty]; fma [entire] [empty] [-infinity,2.0] = [empty]; fma [0.0,0.0] [empty] [-infinity,2.0] = [empty]; fma [-0.0,-0.0] [empty] [-infinity,2.0] = [empty]; fma [empty] [0.0,0.0] [-infinity,2.0] = [empty]; fma [empty] [-0.0,-0.0] [-infinity,2.0] = [empty]; fma [entire] [0.0,0.0] [-infinity,2.0] = [-infinity,2.0]; fma [entire] [-0.0,-0.0] [-infinity,2.0] = [-infinity,2.0]; fma [entire] [-5.0, -1.0] [-infinity,2.0] = [entire]; fma [entire] [-5.0, 3.0] [-infinity,2.0] = [entire]; fma [entire] [1.0, 3.0] [-infinity,2.0] = [entire]; fma [entire] [-infinity, -1.0] [-infinity,2.0] = [entire]; fma [entire] [-infinity, 3.0] [-infinity,2.0] = [entire]; fma [entire] [-5.0, infinity] [-infinity,2.0] = [entire]; fma [entire] [1.0, infinity] [-infinity,2.0] = [entire]; fma [entire] [entire] [-infinity,2.0] = [entire]; fma [1.0,infinity] [0.0,0.0] [-infinity,2.0] = [-infinity,2.0]; fma [1.0,infinity] [-0.0,-0.0] [-infinity,2.0] = [-infinity,2.0]; fma [1.0,infinity] [-5.0, -1.0] [-infinity,2.0] = [-infinity,1.0]; fma [1.0,infinity] [-5.0, 3.0] [-infinity,2.0] = [entire]; fma [1.0,infinity] [1.0, 3.0] [-infinity,2.0] = [entire]; fma [1.0,infinity] [-infinity, -1.0] [-infinity,2.0] = [-infinity,1.0]; fma [1.0,infinity] [-infinity, 3.0] [-infinity,2.0] = [entire]; fma [1.0,infinity] [-5.0, infinity] [-infinity,2.0] = [entire]; fma [1.0,infinity] [1.0, infinity] [-infinity,2.0] = [entire]; fma [1.0,infinity] [entire] [-infinity,2.0] = [entire]; fma [-1.0,infinity] [0.0,0.0] [-infinity,2.0] = [-infinity,2.0]; fma [-1.0,infinity] [-0.0,-0.0] [-infinity,2.0] = [-infinity,2.0]; fma [-1.0,infinity] [-5.0, -1.0] [-infinity,2.0] = [-infinity,7.0]; fma [-1.0,infinity] [-5.0, 3.0] [-infinity,2.0] = [entire]; fma [-1.0,infinity] [1.0, 3.0] [-infinity,2.0] = [entire]; fma [-1.0,infinity] [-infinity, -1.0] [-infinity,2.0] = [entire]; fma [-1.0,infinity] [-infinity, 3.0] [-infinity,2.0] = [entire]; fma [-1.0,infinity] [-5.0, infinity] [-infinity,2.0] = [entire]; fma [-1.0,infinity] [1.0, infinity] [-infinity,2.0] = [entire]; fma [-1.0,infinity] [entire] [-infinity,2.0] = [entire]; fma [-infinity,3.0] [0.0,0.0] [-infinity,2.0] = [-infinity,2.0]; fma [-infinity,3.0] [-0.0,-0.0] [-infinity,2.0] = [-infinity,2.0]; fma [-infinity,3.0] [-5.0, -1.0] [-infinity,2.0] = [entire]; fma [-infinity,3.0] [-5.0, 3.0] [-infinity,2.0] = [entire]; fma [-infinity,3.0] [1.0, 3.0] [-infinity,2.0] = [-infinity,11.0]; fma [-infinity,3.0] [-infinity, -1.0] [-infinity,2.0] = [entire]; fma [-infinity,3.0] [-infinity, 3.0] [-infinity,2.0] = [entire]; fma [-infinity,3.0] [-5.0, infinity] [-infinity,2.0] = [entire]; fma [-infinity,3.0] [1.0, infinity] [-infinity,2.0] = [entire]; fma [-infinity,3.0] [entire] [-infinity,2.0] = [entire]; fma [-infinity,-3.0] [0.0,0.0] [-infinity,2.0] = [-infinity,2.0]; fma [-infinity,-3.0] [-0.0,-0.0] [-infinity,2.0] = [-infinity,2.0]; fma [-infinity,-3.0] [-5.0, -1.0] [-infinity,2.0] = [entire]; fma [-infinity,-3.0] [-5.0, 3.0] [-infinity,2.0] = [entire]; fma [-infinity,-3.0] [1.0, 3.0] [-infinity,2.0] = [-infinity,-1.0]; fma [-infinity,-3.0] [-infinity, -1.0] [-infinity,2.0] = [entire]; fma [-infinity,-3.0] [-infinity, 3.0] [-infinity,2.0] = [entire]; fma [-infinity,-3.0] [-5.0, infinity] [-infinity,2.0] = [entire]; fma [-infinity,-3.0] [1.0, infinity] [-infinity,2.0] = [-infinity,-1.0]; fma [-infinity,-3.0] [entire] [-infinity,2.0] = [entire]; fma [0.0,0.0] [0.0,0.0] [-infinity,2.0] = [-infinity,2.0]; fma [0.0,0.0] [-0.0,-0.0] [-infinity,2.0] = [-infinity,2.0]; fma [0.0,0.0] [-5.0, -1.0] [-infinity,2.0] = [-infinity,2.0]; fma [0.0,0.0] [-5.0, 3.0] [-infinity,2.0] = [-infinity,2.0]; fma [0.0,0.0] [1.0, 3.0] [-infinity,2.0] = [-infinity,2.0]; fma [0.0,0.0] [-infinity, -1.0] [-infinity,2.0] = [-infinity,2.0]; fma [0.0,0.0] [-infinity, 3.0] [-infinity,2.0] = [-infinity,2.0]; fma [0.0,0.0] [-5.0, infinity] [-infinity,2.0] = [-infinity,2.0]; fma [0.0,0.0] [1.0, infinity] [-infinity,2.0] = [-infinity,2.0]; fma [0.0,0.0] [entire] [-infinity,2.0] = [-infinity,2.0]; fma [-0.0,-0.0] [0.0,0.0] [-infinity,2.0] = [-infinity,2.0]; fma [-0.0,-0.0] [-0.0,-0.0] [-infinity,2.0] = [-infinity,2.0]; fma [-0.0,-0.0] [-5.0, -1.0] [-infinity,2.0] = [-infinity,2.0]; fma [-0.0,-0.0] [-5.0, 3.0] [-infinity,2.0] = [-infinity,2.0]; fma [-0.0,-0.0] [1.0, 3.0] [-infinity,2.0] = [-infinity,2.0]; fma [-0.0,-0.0] [-infinity, -1.0] [-infinity,2.0] = [-infinity,2.0]; fma [-0.0,-0.0] [-infinity, 3.0] [-infinity,2.0] = [-infinity,2.0]; fma [-0.0,-0.0] [-5.0, infinity] [-infinity,2.0] = [-infinity,2.0]; fma [-0.0,-0.0] [1.0, infinity] [-infinity,2.0] = [-infinity,2.0]; fma [-0.0,-0.0] [entire] [-infinity,2.0] = [-infinity,2.0]; fma [1.0,5.0] [0.0,0.0] [-infinity,2.0] = [-infinity,2.0]; fma [1.0,5.0] [-0.0,-0.0] [-infinity,2.0] = [-infinity,2.0]; fma [1.0,5.0] [-5.0, -1.0] [-infinity,2.0] = [-infinity,1.0]; fma [1.0,5.0] [-5.0, 3.0] [-infinity,2.0] = [-infinity,17.0]; fma [1.0,5.0] [1.0, 3.0] [-infinity,2.0] = [-infinity,17.0]; fma [1.0,5.0] [-infinity, -1.0] [-infinity,2.0] = [-infinity,1.0]; fma [1.0,5.0] [-infinity, 3.0] [-infinity,2.0] = [-infinity,17.0]; fma [1.0,5.0] [-5.0, infinity] [-infinity,2.0] = [entire]; fma [1.0,5.0] [1.0, infinity] [-infinity,2.0] = [entire]; fma [1.0,5.0] [entire] [-infinity,2.0] = [entire]; fma [-1.0,5.0] [0.0,0.0] [-infinity,2.0] = [-infinity,2.0]; fma [-1.0,5.0] [-0.0,-0.0] [-infinity,2.0] = [-infinity,2.0]; fma [-1.0,5.0] [-5.0, -1.0] [-infinity,2.0] = [-infinity,7.0]; //min max fma [-1.0,5.0] [-5.0, 3.0] [-infinity,2.0] = [-infinity,17.0]; fma [-10.0,2.0] [-5.0, 3.0] [-infinity,2.0] = [-infinity,52.0]; fma [-1.0,5.0] [-1.0, 10.0] [-infinity,2.0] = [-infinity,52.0]; fma [-2.0,2.0] [-5.0, 3.0] [-infinity,2.0] = [-infinity,12.0]; //end min max fma [-1.0,5.0] [1.0, 3.0] [-infinity,2.0] = [-infinity,17.0]; fma [-1.0,5.0] [-infinity, -1.0] [-infinity,2.0] = [entire]; fma [-1.0,5.0] [-infinity, 3.0] [-infinity,2.0] = [entire]; fma [-1.0,5.0] [-5.0, infinity] [-infinity,2.0] = [entire]; fma [-1.0,5.0] [1.0, infinity] [-infinity,2.0] = [entire]; fma [-1.0,5.0] [entire] [-infinity,2.0] = [entire]; fma [-10.0,-5.0] [0.0,0.0] [-infinity,2.0] = [-infinity,2.0]; fma [-10.0,-5.0] [-0.0,-0.0] [-infinity,2.0] = [-infinity,2.0]; fma [-10.0,-5.0] [-5.0, -1.0] [-infinity,2.0] = [-infinity,52.0]; fma [-10.0,-5.0] [-5.0, 3.0] [-infinity,2.0] = [-infinity,52.0]; fma [-10.0,-5.0] [1.0, 3.0] [-infinity,2.0] = [-infinity,-3.0]; fma [-10.0,-5.0] [-infinity, -1.0] [-infinity,2.0] = [entire]; fma [-10.0,-5.0] [-infinity, 3.0] [-infinity,2.0] = [entire]; fma [-10.0,-5.0] [-5.0, infinity] [-infinity,2.0] = [-infinity,52.0]; fma [-10.0,-5.0] [1.0, infinity] [-infinity,2.0] = [-infinity,-3.0]; fma [-10.0,-5.0] [entire] [-infinity,2.0] = [entire]; fma [empty] [empty] [-2.0,2.0] = [empty]; fma [-1.0,1.0] [empty] [-2.0,2.0] = [empty]; fma [empty] [-1.0,1.0] [-2.0,2.0] = [empty]; fma [empty] [entire] [-2.0,2.0] = [empty]; fma [entire] [empty] [-2.0,2.0] = [empty]; fma [0.0,0.0] [empty] [-2.0,2.0] = [empty]; fma [-0.0,-0.0] [empty] [-2.0,2.0] = [empty]; fma [empty] [0.0,0.0] [-2.0,2.0] = [empty]; fma [empty] [-0.0,-0.0] [-2.0,2.0] = [empty]; fma [entire] [0.0,0.0] [-2.0,2.0] = [-2.0,2.0]; fma [entire] [-0.0,-0.0] [-2.0,2.0] = [-2.0,2.0]; fma [entire] [-5.0, -1.0] [-2.0,2.0] = [entire]; fma [entire] [-5.0, 3.0] [-2.0,2.0] = [entire]; fma [entire] [1.0, 3.0] [-2.0,2.0] = [entire]; fma [entire] [-infinity, -1.0] [-2.0,2.0] = [entire]; fma [entire] [-infinity, 3.0] [-2.0,2.0] = [entire]; fma [entire] [-5.0, infinity] [-2.0,2.0] = [entire]; fma [entire] [1.0, infinity] [-2.0,2.0] = [entire]; fma [entire] [entire] [-2.0,2.0] = [entire]; fma [1.0,infinity] [0.0,0.0] [-2.0,2.0] = [-2.0,2.0]; fma [1.0,infinity] [-0.0,-0.0] [-2.0,2.0] = [-2.0,2.0]; fma [1.0,infinity] [-5.0, -1.0] [-2.0,2.0] = [-infinity,1.0]; fma [1.0,infinity] [-5.0, 3.0] [-2.0,2.0] = [entire]; fma [1.0,infinity] [1.0, 3.0] [-2.0,2.0] = [-1.0,infinity]; fma [1.0,infinity] [-infinity, -1.0] [-2.0,2.0] = [-infinity,1.0]; fma [1.0,infinity] [-infinity, 3.0] [-2.0,2.0] = [entire]; fma [1.0,infinity] [-5.0, infinity] [-2.0,2.0] = [entire]; fma [1.0,infinity] [1.0, infinity] [-2.0,2.0] = [-1.0,infinity]; fma [1.0,infinity] [entire] [-2.0,2.0] = [entire]; fma [-1.0,infinity] [0.0,0.0] [-2.0,2.0] = [-2.0,2.0]; fma [-1.0,infinity] [-0.0,-0.0] [-2.0,2.0] = [-2.0,2.0]; fma [-1.0,infinity] [-5.0, -1.0] [-2.0,2.0] = [-infinity,7.0]; fma [-1.0,infinity] [-5.0, 3.0] [-2.0,2.0] = [entire]; fma [-1.0,infinity] [1.0, 3.0] [-2.0,2.0] = [-5.0,infinity]; fma [-1.0,infinity] [-infinity, -1.0] [-2.0,2.0] = [entire]; fma [-1.0,infinity] [-infinity, 3.0] [-2.0,2.0] = [entire]; fma [-1.0,infinity] [-5.0, infinity] [-2.0,2.0] = [entire]; fma [-1.0,infinity] [1.0, infinity] [-2.0,2.0] = [entire]; fma [-1.0,infinity] [entire] [-2.0,2.0] = [entire]; fma [-infinity,3.0] [0.0,0.0] [-2.0,2.0] = [-2.0,2.0]; fma [-infinity,3.0] [-0.0,-0.0] [-2.0,2.0] = [-2.0,2.0]; fma [-infinity,3.0] [-5.0, -1.0] [-2.0,2.0] = [-17.0,infinity]; fma [-infinity,3.0] [-5.0, 3.0] [-2.0,2.0] = [entire]; fma [-infinity,3.0] [1.0, 3.0] [-2.0,2.0] = [-infinity,11.0]; fma [-infinity,3.0] [-infinity, -1.0] [-2.0,2.0] = [entire]; fma [-infinity,3.0] [-infinity, 3.0] [-2.0,2.0] = [entire]; fma [-infinity,3.0] [-5.0, infinity] [-2.0,2.0] = [entire]; fma [-infinity,3.0] [1.0, infinity] [-2.0,2.0] = [entire]; fma [-infinity,3.0] [entire] [-2.0,2.0] = [entire]; fma [-infinity,-3.0] [0.0,0.0] [-2.0,2.0] = [-2.0,2.0]; fma [-infinity,-3.0] [-0.0,-0.0] [-2.0,2.0] = [-2.0,2.0]; fma [-infinity,-3.0] [-5.0, -1.0] [-2.0,2.0] = [1.0,infinity]; fma [-infinity,-3.0] [-5.0, 3.0] [-2.0,2.0] = [entire]; fma [-infinity,-3.0] [1.0, 3.0] [-2.0,2.0] = [-infinity,-1.0]; fma [-infinity,-3.0] [-infinity, -1.0] [-2.0,2.0] = [1.0,infinity]; fma [-infinity,-3.0] [-infinity, 3.0] [-2.0,2.0] = [entire]; fma [-infinity,-3.0] [-5.0, infinity] [-2.0,2.0] = [entire]; fma [-infinity,-3.0] [1.0, infinity] [-2.0,2.0] = [-infinity,-1.0]; fma [-infinity,-3.0] [entire] [-2.0,2.0] = [entire]; fma [0.0,0.0] [0.0,0.0] [-2.0,2.0] = [-2.0,2.0]; fma [0.0,0.0] [-0.0,-0.0] [-2.0,2.0] = [-2.0,2.0]; fma [0.0,0.0] [-5.0, -1.0] [-2.0,2.0] = [-2.0,2.0]; fma [0.0,0.0] [-5.0, 3.0] [-2.0,2.0] = [-2.0,2.0]; fma [0.0,0.0] [1.0, 3.0] [-2.0,2.0] = [-2.0,2.0]; fma [0.0,0.0] [-infinity, -1.0] [-2.0,2.0] = [-2.0,2.0]; fma [0.0,0.0] [-infinity, 3.0] [-2.0,2.0] = [-2.0,2.0]; fma [0.0,0.0] [-5.0, infinity] [-2.0,2.0] = [-2.0,2.0]; fma [0.0,0.0] [1.0, infinity] [-2.0,2.0] = [-2.0,2.0]; fma [0.0,0.0] [entire] [-2.0,2.0] = [-2.0,2.0]; fma [-0.0,-0.0] [0.0,0.0] [-2.0,2.0] = [-2.0,2.0]; fma [-0.0,-0.0] [-0.0,-0.0] [-2.0,2.0] = [-2.0,2.0]; fma [-0.0,-0.0] [-5.0, -1.0] [-2.0,2.0] = [-2.0,2.0]; fma [-0.0,-0.0] [-5.0, 3.0] [-2.0,2.0] = [-2.0,2.0]; fma [-0.0,-0.0] [1.0, 3.0] [-2.0,2.0] = [-2.0,2.0]; fma [-0.0,-0.0] [-infinity, -1.0] [-2.0,2.0] = [-2.0,2.0]; fma [-0.0,-0.0] [-infinity, 3.0] [-2.0,2.0] = [-2.0,2.0]; fma [-0.0,-0.0] [-5.0, infinity] [-2.0,2.0] = [-2.0,2.0]; fma [-0.0,-0.0] [1.0, infinity] [-2.0,2.0] = [-2.0,2.0]; fma [-0.0,-0.0] [entire] [-2.0,2.0] = [-2.0,2.0]; fma [1.0,5.0] [0.0,0.0] [-2.0,2.0] = [-2.0,2.0]; fma [1.0,5.0] [-0.0,-0.0] [-2.0,2.0] = [-2.0,2.0]; fma [1.0,5.0] [-5.0, -1.0] [-2.0,2.0] = [-27.0,1.0]; fma [1.0,5.0] [-5.0, 3.0] [-2.0,2.0] = [-27.0,17.0]; fma [1.0,5.0] [1.0, 3.0] [-2.0,2.0] = [-1.0,17.0]; fma [1.0,5.0] [-infinity, -1.0] [-2.0,2.0] = [-infinity,1.0]; fma [1.0,5.0] [-infinity, 3.0] [-2.0,2.0] = [-infinity,17.0]; fma [1.0,5.0] [-5.0, infinity] [-2.0,2.0] = [-27.0,infinity]; fma [1.0,5.0] [1.0, infinity] [-2.0,2.0] = [-1.0,infinity]; fma [1.0,5.0] [entire] [-2.0,2.0] = [entire]; fma [-1.0,5.0] [0.0,0.0] [-2.0,2.0] = [-2.0,2.0]; fma [-1.0,5.0] [-0.0,-0.0] [-2.0,2.0] = [-2.0,2.0]; fma [-1.0,5.0] [-5.0, -1.0] [-2.0,2.0] = [-27.0,7.0]; //min max fma [-1.0,5.0] [-5.0, 3.0] [-2.0,2.0] = [-27.0,17.0]; fma [-10.0,2.0] [-5.0, 3.0] [-2.0,2.0] = [-32.0,52.0]; fma [-1.0,5.0] [-1.0, 10.0] [-2.0,2.0] = [-12.0,52.0]; fma [-2.0,2.0] [-5.0, 3.0] [-2.0,2.0] = [-12.0,12.0]; //end min max fma [-1.0,5.0] [1.0, 3.0] [-2.0,2.0] = [-5.0,17.0]; fma [-1.0,5.0] [-infinity, -1.0] [-2.0,2.0] = [entire]; fma [-1.0,5.0] [-infinity, 3.0] [-2.0,2.0] = [entire]; fma [-1.0,5.0] [-5.0, infinity] [-2.0,2.0] = [entire]; fma [-1.0,5.0] [1.0, infinity] [-2.0,2.0] = [entire]; fma [-1.0,5.0] [entire] [-2.0,2.0] = [entire]; fma [-10.0,-5.0] [0.0,0.0] [-2.0,2.0] = [-2.0,2.0]; fma [-10.0,-5.0] [-0.0,-0.0] [-2.0,2.0] = [-2.0,2.0]; fma [-10.0,-5.0] [-5.0, -1.0] [-2.0,2.0] = [3.0,52.0]; fma [-10.0,-5.0] [-5.0, 3.0] [-2.0,2.0] = [-32.0,52.0]; fma [-10.0,-5.0] [1.0, 3.0] [-2.0,2.0] = [-32.0,-3.0]; fma [-10.0,-5.0] [-infinity, -1.0] [-2.0,2.0] = [3.0,infinity]; fma [-10.0,-5.0] [-infinity, 3.0] [-2.0,2.0] = [-32.0,infinity]; fma [-10.0,-5.0] [-5.0, infinity] [-2.0,2.0] = [-infinity,52.0]; fma [-10.0,-5.0] [1.0, infinity] [-2.0,2.0] = [-infinity,-3.0]; fma [-10.0,-5.0] [entire] [-2.0,2.0] = [entire]; fma [empty] [empty] [-2.0,infinity] = [empty]; fma [-1.0,1.0] [empty] [-2.0,infinity] = [empty]; fma [empty] [-1.0,1.0] [-2.0,infinity] = [empty]; fma [empty] [entire] [-2.0,infinity] = [empty]; fma [entire] [empty] [-2.0,infinity] = [empty]; fma [0.0,0.0] [empty] [-2.0,infinity] = [empty]; fma [-0.0,-0.0] [empty] [-2.0,infinity] = [empty]; fma [empty] [0.0,0.0] [-2.0,infinity] = [empty]; fma [empty] [-0.0,-0.0] [-2.0,infinity] = [empty]; fma [entire] [0.0,0.0] [-2.0,infinity] = [-2.0,infinity]; fma [entire] [-0.0,-0.0] [-2.0,infinity] = [-2.0,infinity]; fma [entire] [-5.0, -1.0] [-2.0,infinity] = [entire]; fma [entire] [-5.0, 3.0] [-2.0,infinity] = [entire]; fma [entire] [1.0, 3.0] [-2.0,infinity] = [entire]; fma [entire] [-infinity, -1.0] [-2.0,infinity] = [entire]; fma [entire] [-infinity, 3.0] [-2.0,infinity] = [entire]; fma [entire] [-5.0, infinity] [-2.0,infinity] = [entire]; fma [entire] [1.0, infinity] [-2.0,infinity] = [entire]; fma [entire] [entire] [-2.0,infinity] = [entire]; fma [1.0,infinity] [0.0,0.0] [-2.0,infinity] = [-2.0,infinity]; fma [1.0,infinity] [-0.0,-0.0] [-2.0,infinity] = [-2.0,infinity]; fma [1.0,infinity] [-5.0, -1.0] [-2.0,infinity] = [entire]; fma [1.0,infinity] [-5.0, 3.0] [-2.0,infinity] = [entire]; fma [1.0,infinity] [1.0, 3.0] [-2.0,infinity] = [-1.0,infinity]; fma [1.0,infinity] [-infinity, -1.0] [-2.0,infinity] = [entire]; fma [1.0,infinity] [-infinity, 3.0] [-2.0,infinity] = [entire]; fma [1.0,infinity] [-5.0, infinity] [-2.0,infinity] = [entire]; fma [1.0,infinity] [1.0, infinity] [-2.0,infinity] = [-1.0,infinity]; fma [1.0,infinity] [entire] [-2.0,infinity] = [entire]; fma [-1.0,infinity] [0.0,0.0] [-2.0,infinity] = [-2.0,infinity]; fma [-1.0,infinity] [-0.0,-0.0] [-2.0,infinity] = [-2.0,infinity]; fma [-1.0,infinity] [-5.0, -1.0] [-2.0,infinity] = [entire]; fma [-1.0,infinity] [-5.0, 3.0] [-2.0,infinity] = [entire]; fma [-1.0,infinity] [1.0, 3.0] [-2.0,infinity] = [-5.0,infinity]; fma [-1.0,infinity] [-infinity, -1.0] [-2.0,infinity] = [entire]; fma [-1.0,infinity] [-infinity, 3.0] [-2.0,infinity] = [entire]; fma [-1.0,infinity] [-5.0, infinity] [-2.0,infinity] = [entire]; fma [-1.0,infinity] [1.0, infinity] [-2.0,infinity] = [entire]; fma [-1.0,infinity] [entire] [-2.0,infinity] = [entire]; fma [-infinity,3.0] [0.0,0.0] [-2.0,infinity] = [-2.0,infinity]; fma [-infinity,3.0] [-0.0,-0.0] [-2.0,infinity] = [-2.0,infinity]; fma [-infinity,3.0] [-5.0, -1.0] [-2.0,infinity] = [-17.0,infinity]; fma [-infinity,3.0] [-5.0, 3.0] [-2.0,infinity] = [entire]; fma [-infinity,3.0] [1.0, 3.0] [-2.0,infinity] = [entire]; fma [-infinity,3.0] [-infinity, -1.0] [-2.0,infinity] = [entire]; fma [-infinity,3.0] [-infinity, 3.0] [-2.0,infinity] = [entire]; fma [-infinity,3.0] [-5.0, infinity] [-2.0,infinity] = [entire]; fma [-infinity,3.0] [1.0, infinity] [-2.0,infinity] = [entire]; fma [-infinity,3.0] [entire] [-2.0,infinity] = [entire]; fma [-infinity,-3.0] [0.0,0.0] [-2.0,infinity] = [-2.0,infinity]; fma [-infinity,-3.0] [-0.0,-0.0] [-2.0,infinity] = [-2.0,infinity]; fma [-infinity,-3.0] [-5.0, -1.0] [-2.0,infinity] = [1.0,infinity]; fma [-infinity,-3.0] [-5.0, 3.0] [-2.0,infinity] = [entire]; fma [-infinity,-3.0] [1.0, 3.0] [-2.0,infinity] = [entire]; fma [-infinity,-3.0] [-infinity, -1.0] [-2.0,infinity] = [1.0,infinity]; fma [-infinity,-3.0] [-infinity, 3.0] [-2.0,infinity] = [entire]; fma [-infinity,-3.0] [-5.0, infinity] [-2.0,infinity] = [entire]; fma [-infinity,-3.0] [1.0, infinity] [-2.0,infinity] = [entire]; fma [-infinity,-3.0] [entire] [-2.0,infinity] = [entire]; fma [0.0,0.0] [0.0,0.0] [-2.0,infinity] = [-2.0,infinity]; fma [0.0,0.0] [-0.0,-0.0] [-2.0,infinity] = [-2.0,infinity]; fma [0.0,0.0] [-5.0, -1.0] [-2.0,infinity] = [-2.0,infinity]; fma [0.0,0.0] [-5.0, 3.0] [-2.0,infinity] = [-2.0,infinity]; fma [0.0,0.0] [1.0, 3.0] [-2.0,infinity] = [-2.0,infinity]; fma [0.0,0.0] [-infinity, -1.0] [-2.0,infinity] = [-2.0,infinity]; fma [0.0,0.0] [-infinity, 3.0] [-2.0,infinity] = [-2.0,infinity]; fma [0.0,0.0] [-5.0, infinity] [-2.0,infinity] = [-2.0,infinity]; fma [0.0,0.0] [1.0, infinity] [-2.0,infinity] = [-2.0,infinity]; fma [0.0,0.0] [entire] [-2.0,infinity] = [-2.0,infinity]; fma [-0.0,-0.0] [0.0,0.0] [-2.0,infinity] = [-2.0,infinity]; fma [-0.0,-0.0] [-0.0,-0.0] [-2.0,infinity] = [-2.0,infinity]; fma [-0.0,-0.0] [-5.0, -1.0] [-2.0,infinity] = [-2.0,infinity]; fma [-0.0,-0.0] [-5.0, 3.0] [-2.0,infinity] = [-2.0,infinity]; fma [-0.0,-0.0] [1.0, 3.0] [-2.0,infinity] = [-2.0,infinity]; fma [-0.0,-0.0] [-infinity, -1.0] [-2.0,infinity] = [-2.0,infinity]; fma [-0.0,-0.0] [-infinity, 3.0] [-2.0,infinity] = [-2.0,infinity]; fma [-0.0,-0.0] [-5.0, infinity] [-2.0,infinity] = [-2.0,infinity]; fma [-0.0,-0.0] [1.0, infinity] [-2.0,infinity] = [-2.0,infinity]; fma [-0.0,-0.0] [entire] [-2.0,infinity] = [-2.0,infinity]; fma [1.0,5.0] [0.0,0.0] [-2.0,infinity] = [-2.0,infinity]; fma [1.0,5.0] [-0.0,-0.0] [-2.0,infinity] = [-2.0,infinity]; fma [1.0,5.0] [-5.0, -1.0] [-2.0,infinity] = [-27.0,infinity]; fma [1.0,5.0] [-5.0, 3.0] [-2.0,infinity] = [-27.0,infinity]; fma [1.0,5.0] [1.0, 3.0] [-2.0,infinity] = [-1.0,infinity]; fma [1.0,5.0] [-infinity, -1.0] [-2.0,infinity] = [entire]; fma [1.0,5.0] [-infinity, 3.0] [-2.0,infinity] = [entire]; fma [1.0,5.0] [-5.0, infinity] [-2.0,infinity] = [-27.0,infinity]; fma [1.0,5.0] [1.0, infinity] [-2.0,infinity] = [-1.0,infinity]; fma [1.0,5.0] [entire] [-2.0,infinity] = [entire]; fma [-1.0,5.0] [-0.0,-0.0] [-2.0,infinity] = [-2.0,infinity]; fma [-1.0,5.0] [0.0,0.0] [-2.0,infinity] = [-2.0,infinity]; fma [-1.0,5.0] [-5.0, -1.0] [-2.0,infinity] = [-27.0,infinity]; //min max fma [-1.0,5.0] [-5.0, 3.0] [-2.0,infinity] = [-27.0,infinity]; fma [-10.0,2.0] [-5.0, 3.0] [-2.0,infinity] = [-32.0,infinity]; fma [-1.0,5.0] [-1.0, 10.0] [-2.0,infinity] = [-12.0,infinity]; fma [-2.0,2.0] [-5.0, 3.0] [-2.0,infinity] = [-12.0,infinity]; //end min max fma [-1.0,5.0] [1.0, 3.0] [-2.0,infinity] = [-5.0,infinity]; fma [-1.0,5.0] [-infinity, -1.0] [-2.0,infinity] = [entire]; fma [-1.0,5.0] [-infinity, 3.0] [-2.0,infinity] = [entire]; fma [-1.0,5.0] [-5.0, infinity] [-2.0,infinity] = [entire]; fma [-1.0,5.0] [1.0, infinity] [-2.0,infinity] = [entire]; fma [-1.0,5.0] [entire] [-2.0,infinity] = [entire]; fma [-10.0,-5.0] [0.0,0.0] [-2.0,infinity] = [-2.0,infinity]; fma [-10.0,-5.0] [-0.0,-0.0] [-2.0,infinity] = [-2.0,infinity]; fma [-10.0,-5.0] [-5.0, -1.0] [-2.0,infinity] = [3.0,infinity]; fma [-10.0,-5.0] [-5.0, 3.0] [-2.0,infinity] = [-32.0,infinity]; fma [-10.0,-5.0] [1.0, 3.0] [-2.0,infinity] = [-32.0,infinity]; fma [-10.0,-5.0] [-infinity, -1.0] [-2.0,infinity] = [3.0,infinity]; fma [-10.0,-5.0] [-infinity, 3.0] [-2.0,infinity] = [-32.0,infinity]; fma [-10.0,-5.0] [-5.0, infinity] [-2.0,infinity] = [entire]; fma [-10.0,-5.0] [1.0, infinity] [-2.0,infinity] = [entire]; fma [-10.0,-5.0] [entire] [-2.0,infinity] = [entire]; fma [empty] [empty] [entire] = [empty]; fma [-1.0,1.0] [empty] [entire] = [empty]; fma [empty] [-1.0,1.0] [entire] = [empty]; fma [empty] [entire] [entire] = [empty]; fma [entire] [empty] [entire] = [empty]; fma [0.0,0.0] [empty] [entire] = [empty]; fma [-0.0,-0.0] [empty] [entire] = [empty]; fma [empty] [0.0,0.0] [entire] = [empty]; fma [empty] [-0.0,-0.0] [entire] = [empty]; fma [entire] [0.0,0.0] [entire] = [entire]; fma [entire] [-0.0,-0.0] [entire] = [entire]; fma [entire] [-5.0, -1.0] [entire] = [entire]; fma [entire] [-5.0, 3.0] [entire] = [entire]; fma [entire] [1.0, 3.0] [entire] = [entire]; fma [entire] [-infinity, -1.0] [entire] = [entire]; fma [entire] [-infinity, 3.0] [entire] = [entire]; fma [entire] [-5.0, infinity] [entire] = [entire]; fma [entire] [1.0, infinity] [entire] = [entire]; fma [entire] [entire] [entire] = [entire]; fma [1.0,infinity] [0.0,0.0] [entire] = [entire]; fma [1.0,infinity] [-0.0,-0.0] [entire] = [entire]; fma [1.0,infinity] [-5.0, -1.0] [entire] = [entire]; fma [1.0,infinity] [-5.0, 3.0] [entire] = [entire]; fma [1.0,infinity] [1.0, 3.0] [entire] = [entire]; fma [1.0,infinity] [-infinity, -1.0] [entire] = [entire]; fma [1.0,infinity] [-infinity, 3.0] [entire] = [entire]; fma [1.0,infinity] [-5.0, infinity] [entire] = [entire]; fma [1.0,infinity] [1.0, infinity] [entire] = [entire]; fma [1.0,infinity] [entire] [entire] = [entire]; fma [-1.0,infinity] [0.0,0.0] [entire] = [entire]; fma [-1.0,infinity] [-0.0,-0.0] [entire] = [entire]; fma [-1.0,infinity] [-5.0, -1.0] [entire] = [entire]; fma [-1.0,infinity] [-5.0, 3.0] [entire] = [entire]; fma [-1.0,infinity] [1.0, 3.0] [entire] = [entire]; fma [-1.0,infinity] [-infinity, -1.0] [entire] = [entire]; fma [-1.0,infinity] [-infinity, 3.0] [entire] = [entire]; fma [-1.0,infinity] [-5.0, infinity] [entire] = [entire]; fma [-1.0,infinity] [1.0, infinity] [entire] = [entire]; fma [-1.0,infinity] [entire] [entire] = [entire]; fma [-infinity,3.0] [0.0,0.0] [entire] = [entire]; fma [-infinity,3.0] [-0.0,-0.0] [entire] = [entire]; fma [-infinity,3.0] [-5.0, -1.0] [entire] = [entire]; fma [-infinity,3.0] [-5.0, 3.0] [entire] = [entire]; fma [-infinity,3.0] [1.0, 3.0] [entire] = [entire]; fma [-infinity,3.0] [-infinity, -1.0] [entire] = [entire]; fma [-infinity,3.0] [-infinity, 3.0] [entire] = [entire]; fma [-infinity,3.0] [-5.0, infinity] [entire] = [entire]; fma [-infinity,3.0] [1.0, infinity] [entire] = [entire]; fma [-infinity,3.0] [entire] [entire] = [entire]; fma [-infinity,-3.0] [0.0,0.0] [entire] = [entire]; fma [-infinity,-3.0] [-0.0,-0.0] [entire] = [entire]; fma [-infinity,-3.0] [-5.0, -1.0] [entire] = [entire]; fma [-infinity,-3.0] [-5.0, 3.0] [entire] = [entire]; fma [-infinity,-3.0] [1.0, 3.0] [entire] = [entire]; fma [-infinity,-3.0] [-infinity, -1.0] [entire] = [entire]; fma [-infinity,-3.0] [-infinity, 3.0] [entire] = [entire]; fma [-infinity,-3.0] [-5.0, infinity] [entire] = [entire]; fma [-infinity,-3.0] [1.0, infinity] [entire] = [entire]; fma [-infinity,-3.0] [entire] [entire] = [entire]; fma [0.0,0.0] [0.0,0.0] [entire] = [entire]; fma [0.0,0.0] [-0.0,-0.0] [entire] = [entire]; fma [0.0,0.0] [-5.0, -1.0] [entire] = [entire]; fma [0.0,0.0] [-5.0, 3.0] [entire] = [entire]; fma [0.0,0.0] [1.0, 3.0] [entire] = [entire]; fma [0.0,0.0] [-infinity, -1.0] [entire] = [entire]; fma [0.0,0.0] [-infinity, 3.0] [entire] = [entire]; fma [0.0,0.0] [-5.0, infinity] [entire] = [entire]; fma [0.0,0.0] [1.0, infinity] [entire] = [entire]; fma [0.0,0.0] [entire] [entire] = [entire]; fma [-0.0,-0.0] [0.0,0.0] [entire] = [entire]; fma [-0.0,-0.0] [-0.0,-0.0] [entire] = [entire]; fma [-0.0,-0.0] [-5.0, -1.0] [entire] = [entire]; fma [-0.0,-0.0] [-5.0, 3.0] [entire] = [entire]; fma [-0.0,-0.0] [1.0, 3.0] [entire] = [entire]; fma [-0.0,-0.0] [-infinity, -1.0] [entire] = [entire]; fma [-0.0,-0.0] [-infinity, 3.0] [entire] = [entire]; fma [-0.0,-0.0] [-5.0, infinity] [entire] = [entire]; fma [-0.0,-0.0] [1.0, infinity] [entire] = [entire]; fma [-0.0,-0.0] [entire] [entire] = [entire]; fma [1.0,5.0] [0.0,0.0] [entire] = [entire]; fma [1.0,5.0] [-0.0,-0.0] [entire] = [entire]; fma [1.0,5.0] [-5.0, -1.0] [entire] = [entire]; fma [1.0,5.0] [-5.0, 3.0] [entire] = [entire]; fma [1.0,5.0] [1.0, 3.0] [entire] = [entire]; fma [1.0,5.0] [-infinity, -1.0] [entire] = [entire]; fma [1.0,5.0] [-infinity, 3.0] [entire] = [entire]; fma [1.0,5.0] [-5.0, infinity] [entire] = [entire]; fma [1.0,5.0] [1.0, infinity] [entire] = [entire]; fma [1.0,5.0] [entire] [entire] = [entire]; fma [-1.0,5.0] [0.0,0.0] [entire] = [entire]; fma [-1.0,5.0] [-0.0,-0.0] [entire] = [entire]; fma [-1.0,5.0] [-5.0, -1.0] [entire] = [entire]; //min max fma [-1.0,5.0] [-5.0, 3.0] [entire] = [entire]; fma [-10.0,2.0] [-5.0, 3.0] [entire] = [entire]; fma [-1.0,5.0] [-1.0, 10.0] [entire] = [entire]; fma [-2.0,2.0] [-5.0, 3.0] [entire] = [entire]; //end min max fma [-1.0,5.0] [1.0, 3.0] [entire] = [entire]; fma [-1.0,5.0] [-infinity, -1.0] [entire] = [entire]; fma [-1.0,5.0] [-infinity, 3.0] [entire] = [entire]; fma [-1.0,5.0] [-5.0, infinity] [entire] = [entire]; fma [-1.0,5.0] [1.0, infinity] [entire] = [entire]; fma [-1.0,5.0] [entire] [entire] = [entire]; fma [-10.0,-5.0] [0.0,0.0] [entire] = [entire]; fma [-10.0,-5.0] [-0.0,-0.0] [entire] = [entire]; fma [-10.0,-5.0] [-5.0, -1.0] [entire] = [entire]; fma [-10.0,-5.0] [-5.0, 3.0] [entire] = [entire]; fma [-10.0,-5.0] [1.0, 3.0] [entire] = [entire]; fma [-10.0,-5.0] [-infinity, -1.0] [entire] = [entire]; fma [-10.0,-5.0] [-infinity, 3.0] [entire] = [entire]; fma [-10.0,-5.0] [-5.0, infinity] [entire] = [entire]; fma [-10.0,-5.0] [1.0, infinity] [entire] = [entire]; fma [-10.0,-5.0] [entire] [entire] = [entire]; fma [0.1,0.5] [-5.0, 3.0] [-0.1,0.1] = [-0X1.4CCCCCCCCCCCDP+1,0X1.999999999999AP+0]; fma [-0.5,0.2] [-5.0, 3.0] [-0.1,0.1] = [-0X1.999999999999AP+0,0X1.4CCCCCCCCCCCDP+1]; fma [-0.5,-0.1] [2.0, 3.0] [-0.1,0.1] = [-0X1.999999999999AP+0,-0X1.999999999999AP-4]; fma [-0.5,-0.1] [-infinity, 3.0] [-0.1,0.1] = [-0X1.999999999999AP+0,infinity]; } testcase minimal_fma_dec_test { fma [-0.5,-0.1]_com [-infinity, 3.0]_dac [-0.1,0.1]_com = [-0X1.999999999999AP+0,infinity]_dac; fma [1.0,2.0]_com [1.0, 0x1.FFFFFFFFFFFFFp1023]_com [0.0,1.0]_com = [1.0,infinity]_dac; fma [1.0,2.0]_com [1.0, 2.0]_com [2.0,5.0]_com = [3.0,9.0]_com; } testcase minimal_pown_test { pown [empty] 0 = [empty]; pown [entire] 0 = [1.0,1.0]; pown [0.0,0.0] 0 = [1.0,1.0]; pown [-0.0,-0.0] 0 = [1.0,1.0]; pown [13.1,13.1] 0 = [1.0,1.0]; pown [-7451.145,-7451.145] 0 = [1.0,1.0]; pown [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] 0 = [1.0,1.0]; pown [-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023] 0 = [1.0,1.0]; pown [0.0,infinity] 0 = [1.0,1.0]; pown [-0.0,infinity] 0 = [1.0,1.0]; pown [-infinity,0.0] 0 = [1.0,1.0]; pown [-infinity,-0.0] 0 = [1.0,1.0]; pown [-324.3,2.5] 0 = [1.0,1.0]; pown [empty] 2 = [empty]; pown [entire] 2 = [0.0,infinity]; pown [0.0,0.0] 2 = [0.0,0.0]; pown [-0.0,-0.0] 2 = [0.0,0.0]; pown [13.1,13.1] 2 = [0X1.573851EB851EBP+7,0X1.573851EB851ECP+7]; pown [-7451.145,-7451.145] 2 = [0X1.A794A4E7CFAADP+25,0X1.A794A4E7CFAAEP+25]; pown [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] 2 = [0x1.FFFFFFFFFFFFFp1023,infinity]; pown [-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023] 2 = [0x1.FFFFFFFFFFFFFp1023,infinity]; pown [0.0,infinity] 2 = [0.0,infinity]; pown [-0.0,infinity] 2 = [0.0,infinity]; pown [-infinity,0.0] 2 = [0.0,infinity]; pown [-infinity,-0.0] 2 = [0.0,infinity]; pown [-324.3,2.5] 2 = [0.0,0X1.9AD27D70A3D72P+16]; pown [0.01,2.33] 2 = [0X1.A36E2EB1C432CP-14,0X1.5B7318FC50482P+2]; pown [-1.9,-0.33] 2 = [0X1.BE0DED288CE7P-4,0X1.CE147AE147AE1P+1]; pown [empty] 8 = [empty]; pown [entire] 8 = [0.0,infinity]; pown [0.0,0.0] 8 = [0.0,0.0]; pown [-0.0,-0.0] 8 = [0.0,0.0]; pown [13.1,13.1] 8 = [0X1.9D8FD495853F5P+29,0X1.9D8FD495853F6P+29]; pown [-7451.145,-7451.145] 8 = [0X1.DFB1BB622E70DP+102,0X1.DFB1BB622E70EP+102]; pown [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] 8 = [0x1.FFFFFFFFFFFFFp1023,infinity]; pown [-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023] 8 = [0x1.FFFFFFFFFFFFFp1023,infinity]; pown [0.0,infinity] 8 = [0.0,infinity]; pown [-0.0,infinity] 8 = [0.0,infinity]; pown [-infinity,0.0] 8 = [0.0,infinity]; pown [-infinity,-0.0] 8 = [0.0,infinity]; pown [-324.3,2.5] 8 = [0.0,0X1.A87587109655P+66]; pown [0.01,2.33] 8 = [0X1.CD2B297D889BDP-54,0X1.B253D9F33CE4DP+9]; pown [-1.9,-0.33] 8 = [0X1.26F1FCDD502A3P-13,0X1.53ABD7BFC4FC6P+7]; pown [empty] 1 = [empty]; pown [entire] 1 = [entire]; pown [0.0,0.0] 1 = [0.0,0.0]; pown [-0.0,-0.0] 1 = [0.0,0.0]; pown [13.1,13.1] 1 = [13.1,13.1]; pown [-7451.145,-7451.145] 1 = [-7451.145,-7451.145]; pown [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] 1 = [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]; pown [-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023] 1 = [-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023]; pown [0.0,infinity] 1 = [0.0,infinity]; pown [-0.0,infinity] 1 = [0.0,infinity]; pown [-infinity,0.0] 1 = [-infinity,0.0]; pown [-infinity,-0.0] 1 = [-infinity,0.0]; pown [-324.3,2.5] 1 = [-324.3,2.5]; pown [0.01,2.33] 1 = [0.01,2.33]; pown [-1.9,-0.33] 1 = [-1.9,-0.33]; pown [empty] 3 = [empty]; pown [entire] 3 = [entire]; pown [0.0,0.0] 3 = [0.0,0.0]; pown [-0.0,-0.0] 3 = [0.0,0.0]; pown [13.1,13.1] 3 = [0X1.1902E978D4FDEP+11,0X1.1902E978D4FDFP+11]; pown [-7451.145,-7451.145] 3 = [-0X1.81460637B9A3DP+38,-0X1.81460637B9A3CP+38]; pown [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] 3 = [0x1.FFFFFFFFFFFFFp1023,infinity]; pown [-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023] 3 = [-infinity,-0x1.FFFFFFFFFFFFFp1023]; pown [0.0,infinity] 3 = [0.0,infinity]; pown [-0.0,infinity] 3 = [0.0,infinity]; pown [-infinity,0.0] 3 = [-infinity,0.0]; pown [-infinity,-0.0] 3 = [-infinity,0.0]; pown [-324.3,2.5] 3 = [-0X1.0436D2F418938P+25,0X1.F4P+3]; pown [0.01,2.33] 3 = [0X1.0C6F7A0B5ED8DP-20,0X1.94C75E6362A6P+3]; pown [-1.9,-0.33] 3 = [-0X1.B6F9DB22D0E55P+2,-0X1.266559F6EC5B1P-5]; pown [empty] 7 = [empty]; pown [entire] 7 = [entire]; pown [0.0,0.0] 7 = [0.0,0.0]; pown [-0.0,-0.0] 7 = [0.0,0.0]; pown [13.1,13.1] 7 = [0X1.F91D1B185493BP+25,0X1.F91D1B185493CP+25]; pown [-7451.145,-7451.145] 7 = [-0X1.07B1DA32F9B59P+90,-0X1.07B1DA32F9B58P+90]; pown [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] 7 = [0x1.FFFFFFFFFFFFFp1023,infinity]; pown [-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023] 7 = [-infinity,-0x1.FFFFFFFFFFFFFp1023]; pown [0.0,infinity] 7 = [0.0,infinity]; pown [-0.0,infinity] 7 = [0.0,infinity]; pown [-infinity,0.0] 7 = [-infinity,0.0]; pown [-infinity,-0.0] 7 = [-infinity,0.0]; pown [-324.3,2.5] 7 = [-0X1.4F109959E6D7FP+58,0X1.312DP+9]; pown [0.01,2.33] 7 = [0X1.6849B86A12B9BP-47,0X1.74D0373C76313P+8]; pown [-1.9,-0.33] 7 = [-0X1.658C775099757P+6,-0X1.BEE30301BF47AP-12]; pown [empty] -2 = [empty]; pown [entire] -2 = [0.0,infinity]; pown [0.0,0.0] -2 = [empty]; pown [-0.0,-0.0] -2 = [empty]; pown [13.1,13.1] -2 = [0X1.7DE3A077D1568P-8,0X1.7DE3A077D1569P-8]; pown [-7451.145,-7451.145] -2 = [0X1.3570290CD6E14P-26,0X1.3570290CD6E15P-26]; pown [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] -2 = [0X0P+0,0X0.0000000000001P-1022]; pown [-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023] -2 = [0X0P+0,0X0.0000000000001P-1022]; pown [0.0,infinity] -2 = [0.0,infinity]; pown [-0.0,infinity] -2 = [0.0,infinity]; pown [-infinity,0.0] -2 = [0.0,infinity]; pown [-infinity,-0.0] -2 = [0.0,infinity]; pown [-324.3,2.5] -2 = [0X1.3F0C482C977C9P-17,infinity]; pown [0.01,2.33] -2 = [0X1.793D85EF38E47P-3,0X1.388P+13]; pown [-1.9,-0.33] -2 = [0X1.1BA81104F6C8P-2,0X1.25D8FA1F801E1P+3]; pown [empty] -8 = [empty]; pown [entire] -8 = [0.0,infinity]; pown [0.0,0.0] -8 = [empty]; pown [-0.0,-0.0] -8 = [empty]; pown [13.1,13.1] -8 = [0X1.3CEF39247CA6DP-30,0X1.3CEF39247CA6EP-30]; pown [-7451.145,-7451.145] -8 = [0X1.113D9EF0A99ACP-103,0X1.113D9EF0A99ADP-103]; pown [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] -8 = [0X0P+0,0X0.0000000000001P-1022]; pown [-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023] -8 = [0X0P+0,0X0.0000000000001P-1022]; pown [0.0,infinity] -8 = [0.0,infinity]; pown [-0.0,infinity] -8 = [0.0,infinity]; pown [-infinity,0.0] -8 = [0.0,infinity]; pown [-infinity,-0.0] -8 = [0.0,infinity]; pown [-324.3,2.5] -8 = [0X1.34CC3764D1E0CP-67,infinity]; pown [0.01,2.33] -8 = [0X1.2DC80DB11AB7CP-10,0X1.1C37937E08P+53]; pown [-1.9,-0.33] -8 = [0X1.81E104E61630DP-8,0X1.BC64F21560E34P+12]; pown [empty] -1 = [empty]; pown [entire] -1 = [entire]; pown [0.0,0.0] -1 = [empty]; pown [-0.0,-0.0] -1 = [empty]; pown [13.1,13.1] -1 = [0X1.38ABF82EE6986P-4,0X1.38ABF82EE6987P-4]; pown [-7451.145,-7451.145] -1 = [-0X1.197422C9048BFP-13,-0X1.197422C9048BEP-13]; pown [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] -1 = [0X0.4P-1022,0X0.4000000000001P-1022]; pown [-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023] -1 = [-0X0.4000000000001P-1022,-0X0.4P-1022]; pown [0.0,infinity] -1 = [0.0,infinity]; pown [-0.0,infinity] -1 = [0.0,infinity]; pown [-infinity,0.0] -1 = [-infinity,0.0]; pown [-infinity,-0.0] -1 = [-infinity,0.0]; pown [-324.3,2.5] -1 = [entire]; pown [0.01,2.33] -1 = [0X1.B77C278DBBE13P-2,0X1.9P+6]; pown [-1.9,-0.33] -1 = [-0X1.83E0F83E0F83EP+1,-0X1.0D79435E50D79P-1]; pown [empty] -3 = [empty]; pown [entire] -3 = [entire]; pown [0.0,0.0] -3 = [empty]; pown [-0.0,-0.0] -3 = [empty]; pown [13.1,13.1] -3 = [0X1.D26DF4D8B1831P-12,0X1.D26DF4D8B1832P-12]; pown [-7451.145,-7451.145] -3 = [-0X1.54347DED91B19P-39,-0X1.54347DED91B18P-39]; pown [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] -3 = [0X0P+0,0X0.0000000000001P-1022]; pown [-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023] -3 = [-0X0.0000000000001P-1022,-0X0P+0]; pown [0.0,infinity] -3 = [0.0,infinity]; pown [-0.0,infinity] -3 = [0.0,infinity]; pown [-infinity,0.0] -3 = [-infinity,0.0]; pown [-infinity,-0.0] -3 = [-infinity,0.0]; pown [-324.3,2.5] -3 = [entire]; pown [0.01,2.33] -3 = [0X1.43CFBA61AACABP-4,0X1.E848P+19]; pown [-1.9,-0.33] -3 = [-0X1.BD393CE9E8E7CP+4,-0X1.2A95F6F7C066CP-3]; pown [empty] -7 = [empty]; pown [entire] -7 = [entire]; pown [0.0,0.0] -7 = [empty]; pown [-0.0,-0.0] -7 = [empty]; pown [13.1,13.1] -7 = [0X1.037D76C912DBCP-26,0X1.037D76C912DBDP-26]; pown [-7451.145,-7451.145] -7 = [-0X1.F10F41FB8858FP-91,-0X1.F10F41FB8858EP-91]; pown [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] -7 = [0X0P+0,0X0.0000000000001P-1022]; pown [-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023] -7 = [-0X0.0000000000001P-1022,-0X0P+0]; pown [0.0,infinity] -7 = [0.0,infinity]; pown [-0.0,infinity] -7 = [0.0,infinity]; pown [-infinity,0.0] -7 = [-infinity,0.0]; pown [-infinity,-0.0] -7 = [-infinity,0.0]; pown [-324.3,2.5] -7 = [entire]; pown [0.01,2.33] -7 = [0X1.5F934D64162A9P-9,0X1.6BCC41E9P+46]; pown [-1.9,-0.33] -7 = [-0X1.254CDD3711DDBP+11,-0X1.6E95C4A761E19P-7]; } testcase minimal_pown_dec_test { pown [-5.0,10.0]_com 0 = [1.0,1.0]_com; pown [-infinity,15.0]_dac 0 = [1.0,1.0]_dac; pown [-3.0,5.0]_def 2 = [0.0,25.0]_def; pown [-0x1.FFFFFFFFFFFFFp1023,2.0]_com 2 = [0.0,infinity]_dac; pown [-3.0,5.0]_dac 3 = [-27.0,125.0]_dac; pown [-0x1.FFFFFFFFFFFFFp1023,2.0]_com 3 = [-infinity, 8.0]_dac; pown [3.0,5.0]_com -2 = [0X1.47AE147AE147AP-5,0X1.C71C71C71C71DP-4]_com; pown [-5.0,-3.0]_def -2 = [0X1.47AE147AE147AP-5,0X1.C71C71C71C71DP-4]_def; pown [-5.0,3.0]_com -2 = [0X1.47AE147AE147AP-5,infinity]_trv; pown [3.0,5.0]_dac -3 = [0X1.0624DD2F1A9FBP-7 ,0X1.2F684BDA12F69P-5]_dac; pown [-3.0,5.0]_com -3 = [entire]_trv; } testcase minimal_pow_test { pow [empty] [empty] = [empty]; pow [empty] [entire] = [empty]; pow [empty] [-infinity,-1.0] = [empty]; pow [empty] [-infinity,0.0] = [empty]; pow [empty] [-infinity,-0.0] = [empty]; pow [empty] [0.0,infinity] = [empty]; pow [empty] [-0.0,infinity] = [empty]; pow [empty] [1.0,infinity] = [empty]; pow [empty] [-3.0,5.0] = [empty]; pow [empty] [0.0,0.0] = [empty]; pow [empty] [-0.0,-0.0] = [empty]; pow [empty] [-5.0,-5.0] = [empty]; pow [empty] [5.0,5.0] = [empty]; pow [0.1,0.5] [empty] = [empty]; pow [0.1,0.5] [0.0,0.0] = [1.0,1.0]; pow [0.1,0.5] [-0.0,-0.0] = [1.0,1.0]; pow [0.1,0.5] [0.0,1.0] = [0X1.999999999999AP-4,1.0]; pow [0.1,0.5] [-0.0,1.0] = [0X1.999999999999AP-4,1.0]; pow [0.1,0.5] [0.0,2.5] = [0X1.9E7C6E43390B7P-9,1.0]; pow [0.1,0.5] [-0.0,2.5] = [0X1.9E7C6E43390B7P-9,1.0]; pow [0.1,0.5] [0.0,infinity] = [0.0,1.0]; pow [0.1,0.5] [-0.0,infinity] = [0.0,1.0]; pow [0.1,0.5] [0.1,0.1] = [0X1.96B230BCDC434P-1,0X1.DDB680117AB13P-1]; pow [0.1,0.5] [0.1,1.0] = [0X1.999999999999AP-4,0X1.DDB680117AB13P-1]; pow [0.1,0.5] [0.1,2.5] = [0X1.9E7C6E43390B7P-9,0X1.DDB680117AB13P-1]; pow [0.1,0.5] [0.1,infinity] = [0.0,0X1.DDB680117AB13P-1]; pow [0.1,0.5] [1.0,1.0] = [0X1.999999999999AP-4,0X1P-1]; pow [0.1,0.5] [1.0,2.5] = [0X1.9E7C6E43390B7P-9,0X1P-1]; pow [0.1,0.5] [1.0,infinity] = [0.0,0X1P-1]; pow [0.1,0.5] [2.5,2.5] = [0X1.9E7C6E43390B7P-9,0X1.6A09E667F3BCDP-3]; pow [0.1,0.5] [2.5,infinity] = [0.0,0X1.6A09E667F3BCDP-3]; pow [0.1,0.5] [-0.1,0.1] = [0X1.96B230BCDC434P-1,0X1.4248EF8FC2604P+0]; pow [0.1,0.5] [-0.1,1.0] = [0X1.999999999999AP-4,0X1.4248EF8FC2604P+0]; pow [0.1,0.5] [-0.1,2.5] = [0X1.9E7C6E43390B7P-9,0X1.4248EF8FC2604P+0]; pow [0.1,0.5] [-0.1,infinity] = [0.0,0X1.4248EF8FC2604P+0]; pow [0.1,0.5] [-1.0,0.1] = [0X1.96B230BCDC434P-1,0X1.4P+3]; pow [0.1,0.5] [-1.0,1.0] = [0X1.999999999999AP-4,0X1.4P+3]; pow [0.1,0.5] [-1.0,2.5] = [0X1.9E7C6E43390B7P-9,0X1.4P+3]; pow [0.1,0.5] [-1.0,infinity] = [0.0,0X1.4P+3]; pow [0.1,0.5] [-2.5,0.1] = [0X1.96B230BCDC434P-1,0X1.3C3A4EDFA9758P+8]; pow [0.1,0.5] [-2.5,1.0] = [0X1.999999999999AP-4,0X1.3C3A4EDFA9758P+8]; pow [0.1,0.5] [-2.5,2.5] = [0X1.9E7C6E43390B7P-9,0X1.3C3A4EDFA9758P+8]; pow [0.1,0.5] [-2.5,infinity] = [0.0,0X1.3C3A4EDFA9758P+8]; pow [0.1,0.5] [-infinity,0.1] = [0X1.96B230BCDC434P-1,infinity]; pow [0.1,0.5] [-infinity,1.0] = [0X1.999999999999AP-4,infinity]; pow [0.1,0.5] [-infinity,2.5] = [0X1.9E7C6E43390B7P-9,infinity]; pow [0.1,0.5] [entire] = [0.0,infinity]; pow [0.1,0.5] [-1.0,0.0] = [1.0,0X1.4P+3]; pow [0.1,0.5] [-1.0,-0.0] = [1.0,0X1.4P+3]; pow [0.1,0.5] [-2.5,0.0] = [1.0,0X1.3C3A4EDFA9758P+8]; pow [0.1,0.5] [-2.5,-0.0] = [1.0,0X1.3C3A4EDFA9758P+8]; pow [0.1,0.5] [-infinity,0.0] = [1.0,infinity]; pow [0.1,0.5] [-infinity,-0.0] = [1.0,infinity]; pow [0.1,0.5] [-0.1,-0.1] = [0X1.125FBEE250664P+0,0X1.4248EF8FC2604P+0]; pow [0.1,0.5] [-1.0,-0.1] = [0X1.125FBEE250664P+0,0X1.4P+3]; pow [0.1,0.5] [-2.5,-0.1] = [0X1.125FBEE250664P+0,0X1.3C3A4EDFA9758P+8]; pow [0.1,0.5] [-infinity,-0.1] = [0X1.125FBEE250664P+0,infinity]; pow [0.1,0.5] [-1.0,-1.0] = [0X1P+1,0X1.4P+3]; pow [0.1,0.5] [-2.5,-1.0] = [0X1P+1,0X1.3C3A4EDFA9758P+8]; pow [0.1,0.5] [-infinity,-1.0] = [0X1P+1,infinity]; pow [0.1,0.5] [-2.5,-2.5] = [0X1.6A09E667F3BCCP+2,0X1.3C3A4EDFA9758P+8]; pow [0.1,0.5] [-infinity,-2.5] = [0X1.6A09E667F3BCCP+2,infinity]; pow [0.1,1.0] [empty] = [empty]; pow [0.1,1.0] [0.0,0.0] = [1.0,1.0]; pow [0.1,1.0] [-0.0,-0.0] = [1.0,1.0]; pow [0.1,1.0] [0.0,1.0] = [0X1.999999999999AP-4,1.0]; pow [0.1,1.0] [-0.0,1.0] = [0X1.999999999999AP-4,1.0]; pow [0.1,1.0] [0.0,2.5] = [0X1.9E7C6E43390B7P-9,1.0]; pow [0.1,1.0] [-0.0,2.5] = [0X1.9E7C6E43390B7P-9,1.0]; pow [0.1,1.0] [0.0,infinity] = [0.0,1.0]; pow [0.1,1.0] [-0.0,infinity] = [0.0,1.0]; pow [0.1,1.0] [0.1,0.1] = [0X1.96B230BCDC434P-1,1.0]; pow [0.1,1.0] [0.1,1.0] = [0X1.999999999999AP-4,1.0]; pow [0.1,1.0] [0.1,2.5] = [0X1.9E7C6E43390B7P-9,1.0]; pow [0.1,1.0] [0.1,infinity] = [0.0,1.0]; pow [0.1,1.0] [1.0,1.0] = [0X1.999999999999AP-4,1.0]; pow [0.1,1.0] [1.0,2.5] = [0X1.9E7C6E43390B7P-9,1.0]; pow [0.1,1.0] [1.0,infinity] = [0.0,1.0]; pow [0.1,1.0] [2.5,2.5] = [0X1.9E7C6E43390B7P-9,1.0]; pow [0.1,1.0] [2.5,infinity] = [0.0,1.0]; pow [0.1,1.0] [-0.1,0.1] = [0X1.96B230BCDC434P-1,0X1.4248EF8FC2604P+0]; pow [0.1,1.0] [-0.1,1.0] = [0X1.999999999999AP-4,0X1.4248EF8FC2604P+0]; pow [0.1,1.0] [-0.1,2.5] = [0X1.9E7C6E43390B7P-9,0X1.4248EF8FC2604P+0]; pow [0.1,1.0] [-0.1,infinity] = [0.0,0X1.4248EF8FC2604P+0]; pow [0.1,1.0] [-1.0,0.1] = [0X1.96B230BCDC434P-1,0X1.4P+3]; pow [0.1,1.0] [-1.0,1.0] = [0X1.999999999999AP-4,0X1.4P+3]; pow [0.1,1.0] [-1.0,2.5] = [0X1.9E7C6E43390B7P-9,0X1.4P+3]; pow [0.1,1.0] [-1.0,infinity] = [0.0,0X1.4P+3]; pow [0.1,1.0] [-2.5,0.1] = [0X1.96B230BCDC434P-1,0X1.3C3A4EDFA9758P+8]; pow [0.1,1.0] [-2.5,1.0] = [0X1.999999999999AP-4,0X1.3C3A4EDFA9758P+8]; pow [0.1,1.0] [-2.5,2.5] = [0X1.9E7C6E43390B7P-9,0X1.3C3A4EDFA9758P+8]; pow [0.1,1.0] [-2.5,infinity] = [0.0,0X1.3C3A4EDFA9758P+8]; pow [0.1,1.0] [-infinity,0.1] = [0X1.96B230BCDC434P-1,infinity]; pow [0.1,1.0] [-infinity,1.0] = [0X1.999999999999AP-4,infinity]; pow [0.1,1.0] [-infinity,2.5] = [0X1.9E7C6E43390B7P-9,infinity]; pow [0.1,1.0] [entire] = [0.0,infinity]; pow [0.1,1.0] [-0.1,0.0] = [1.0,0X1.4248EF8FC2604P+0]; pow [0.1,1.0] [-0.1,-0.0] = [1.0,0X1.4248EF8FC2604P+0]; pow [0.1,1.0] [-1.0,0.0] = [1.0,0X1.4P+3]; pow [0.1,1.0] [-1.0,-0.0] = [1.0,0X1.4P+3]; pow [0.1,1.0] [-2.5,0.0] = [1.0,0X1.3C3A4EDFA9758P+8]; pow [0.1,1.0] [-2.5,-0.0] = [1.0,0X1.3C3A4EDFA9758P+8]; pow [0.1,1.0] [-infinity,0.0] = [1.0,infinity]; pow [0.1,1.0] [-infinity,-0.0] = [1.0,infinity]; pow [0.1,1.0] [-0.1,-0.1] = [1.0,0X1.4248EF8FC2604P+0]; pow [0.1,1.0] [-1.0,-0.1] = [1.0,0X1.4P+3]; pow [0.1,1.0] [-2.5,-0.1] = [1.0,0X1.3C3A4EDFA9758P+8]; pow [0.1,1.0] [-infinity,-0.1] = [1.0,infinity]; pow [0.1,1.0] [-1.0,-1.0] = [1.0,0X1.4P+3]; pow [0.1,1.0] [-2.5,-1.0] = [1.0,0X1.3C3A4EDFA9758P+8]; pow [0.1,1.0] [-infinity,-1.0] = [1.0,infinity]; pow [0.1,1.0] [-2.5,-2.5] = [1.0,0X1.3C3A4EDFA9758P+8]; pow [0.1,1.0] [-infinity,-2.5] = [1.0,infinity]; pow [0.5,1.5] [empty] = [empty]; pow [0.5,1.5] [0.0,0.0] = [1.0,1.0]; pow [0.5,1.5] [-0.0,-0.0] = [1.0,1.0]; pow [0.5,1.5] [0.0,1.0] = [0.5,1.5]; pow [0.5,1.5] [-0.0,1.0] = [0.5,1.5]; pow [0.5,1.5] [0.0,2.5] = [0X1.6A09E667F3BCCP-3,0X1.60B9FD68A4555P+1]; pow [0.5,1.5] [-0.0,2.5] = [0X1.6A09E667F3BCCP-3,0X1.60B9FD68A4555P+1]; pow [0.5,1.5] [0.0,infinity] = [0.0,infinity]; pow [0.5,1.5] [-0.0,infinity] = [0.0,infinity]; pow [0.5,1.5] [0.1,0.1] = [0X1.DDB680117AB12P-1,0X1.0A97DCE72A0CBP+0]; pow [0.5,1.5] [0.1,1.0] = [0.5,1.5]; pow [0.5,1.5] [0.1,2.5] = [0X1.6A09E667F3BCCP-3,0X1.60B9FD68A4555P+1]; pow [0.5,1.5] [0.1,infinity] = [0.0,infinity]; pow [0.5,1.5] [1.0,1.0] = [0.5,1.5]; pow [0.5,1.5] [1.0,2.5] = [0X1.6A09E667F3BCCP-3,0X1.60B9FD68A4555P+1]; pow [0.5,1.5] [1.0,infinity] = [0.0,infinity]; pow [0.5,1.5] [2.5,2.5] = [0X1.6A09E667F3BCCP-3,0X1.60B9FD68A4555P+1]; pow [0.5,1.5] [2.5,infinity] = [0.0,infinity]; pow [0.5,1.5] [-0.1,0.1] = [0X1.DDB680117AB12P-1,0X1.125FBEE250665P+0]; pow [0.5,1.5] [-0.1,1.0] = [0X1P-1,0X1.8P+0]; pow [0.5,1.5] [-0.1,2.5] = [0X1.6A09E667F3BCCP-3,0X1.60B9FD68A4555P+1]; pow [0.5,1.5] [-0.1,infinity] = [0X0P+0,infinity]; pow [0.5,1.5] [-1.0,0.1] = [0X1.5555555555555P-1,0X1P+1]; pow [0.5,1.5] [-1.0,1.0] = [0X1P-1,0X1P+1]; pow [0.5,1.5] [-1.0,2.5] = [0X1.6A09E667F3BCCP-3,0X1.60B9FD68A4555P+1]; pow [0.5,1.5] [-1.0,infinity] = [0X0P+0,infinity]; pow [0.5,1.5] [-2.5,0.1] = [0X1.7398BF1D1EE6FP-2,0X1.6A09E667F3BCDP+2]; pow [0.5,1.5] [-2.5,1.0] = [0X1.7398BF1D1EE6FP-2,0X1.6A09E667F3BCDP+2]; pow [0.5,1.5] [-2.5,2.5] = [0X1.6A09E667F3BCCP-3,0X1.6A09E667F3BCDP+2]; pow [0.5,1.5] [-2.5,infinity] = [0X0P+0,infinity]; pow [0.5,1.5] [-infinity,0.1] = [0X0P+0,infinity]; pow [0.5,1.5] [-infinity,1.0] = [0X0P+0,infinity]; pow [0.5,1.5] [-infinity,2.5] = [0X0P+0,infinity]; pow [0.5,1.5] [entire] = [0X0P+0,infinity]; pow [0.5,1.5] [-1.0,0.0] = [0X1.5555555555555P-1,0X1P+1]; pow [0.5,1.5] [-1.0,-0.0] = [0X1.5555555555555P-1,0X1P+1]; pow [0.5,1.5] [-2.5,0.0] = [0X1.7398BF1D1EE6FP-2,0X1.6A09E667F3BCDP+2]; pow [0.5,1.5] [-2.5,-0.0] = [0X1.7398BF1D1EE6FP-2,0X1.6A09E667F3BCDP+2]; pow [0.5,1.5] [-infinity,0.0] = [0X0P+0,infinity]; pow [0.5,1.5] [-infinity,-0.0] = [0X0P+0,infinity]; pow [0.5,1.5] [-0.1,-0.1] = [0X1.EBA7C9E4D31E9P-1,0X1.125FBEE250665P+0]; pow [0.5,1.5] [-1.0,-0.1] = [0X1.5555555555555P-1,0X1P+1]; pow [0.5,1.5] [-2.5,-0.1] = [0X1.7398BF1D1EE6FP-2,0X1.6A09E667F3BCDP+2]; pow [0.5,1.5] [-infinity,-0.1] = [0X0P+0,infinity]; pow [0.5,1.5] [-1.0,-1.0] = [0X1.5555555555555P-1,0X1P+1]; pow [0.5,1.5] [-2.5,-1.0] = [0X1.7398BF1D1EE6FP-2,0X1.6A09E667F3BCDP+2]; pow [0.5,1.5] [-infinity,-1.0] = [0X0P+0,infinity]; pow [0.5,1.5] [-2.5,-2.5] = [0X1.7398BF1D1EE6FP-2,0X1.6A09E667F3BCDP+2]; pow [0.5,1.5] [-infinity,-2.5] = [0X0P+0,infinity]; pow [0.5,infinity] [empty] = [empty]; pow [0.5,infinity] [0.0,0.0] = [1.0,1.0]; pow [0.5,infinity] [-0.0,-0.0] = [1.0,1.0]; pow [0.5,infinity] [0.0,1.0] = [0.5,infinity]; pow [0.5,infinity] [-0.0,1.0] = [0.5,infinity]; pow [0.5,infinity] [0.0,2.5] = [0X1.6A09E667F3BCCP-3,infinity]; pow [0.5,infinity] [-0.0,2.5] = [0X1.6A09E667F3BCCP-3,infinity]; pow [0.5,infinity] [0.0,infinity] = [0.0,infinity]; pow [0.5,infinity] [-0.0,infinity] = [0.0,infinity]; pow [0.5,infinity] [0.1,0.1] = [0X1.DDB680117AB12P-1,infinity]; pow [0.5,infinity] [0.1,1.0] = [0.5,infinity]; pow [0.5,infinity] [0.1,2.5] = [0X1.6A09E667F3BCCP-3,infinity]; pow [0.5,infinity] [0.1,infinity] = [0.0,infinity]; pow [0.5,infinity] [1.0,1.0] = [0.5,infinity]; pow [0.5,infinity] [1.0,2.5] = [0X1.6A09E667F3BCCP-3,infinity]; pow [0.5,infinity] [1.0,infinity] = [0.0,infinity]; pow [0.5,infinity] [2.5,2.5] = [0X1.6A09E667F3BCCP-3,infinity]; pow [0.5,infinity] [2.5,infinity] = [0.0,infinity]; pow [0.5,infinity] [-0.1,0.1] = [0.0,infinity]; pow [0.5,infinity] [-0.1,1.0] = [0.0,infinity]; pow [0.5,infinity] [-0.1,2.5] = [0.0,infinity]; pow [0.5,infinity] [-0.1,infinity] = [0.0,infinity]; pow [0.5,infinity] [-1.0,0.1] = [0.0,infinity]; pow [0.5,infinity] [-1.0,1.0] = [0.0,infinity]; pow [0.5,infinity] [-1.0,2.5] = [0.0,infinity]; pow [0.5,infinity] [-1.0,infinity] = [0.0,infinity]; pow [0.5,infinity] [-2.5,0.1] = [0.0,infinity]; pow [0.5,infinity] [-2.5,1.0] = [0.0,infinity]; pow [0.5,infinity] [-2.5,2.5] = [0.0,infinity]; pow [0.5,infinity] [-2.5,infinity] = [0.0,infinity]; pow [0.5,infinity] [-infinity,0.1] = [0.0,infinity]; pow [0.5,infinity] [-infinity,1.0] = [0.0,infinity]; pow [0.5,infinity] [-infinity,2.5] = [0.0,infinity]; pow [0.5,infinity] [entire] = [0.0,infinity]; pow [0.5,infinity] [-1.0,0.0] = [0.0,0X1P+1]; pow [0.5,infinity] [-1.0,-0.0] = [0.0,0X1P+1]; pow [0.5,infinity] [-2.5,0.0] = [0.0,0X1.6A09E667F3BCDP+2]; pow [0.5,infinity] [-2.5,-0.0] = [0.0,0X1.6A09E667F3BCDP+2]; pow [0.5,infinity] [-infinity,0.0] = [0.0,infinity]; pow [0.5,infinity] [-infinity,-0.0] = [0.0,infinity]; pow [0.5,infinity] [-0.1,-0.1] = [0.0,0X1.125FBEE250665P+0]; pow [0.5,infinity] [-1.0,-0.1] = [0.0,0X1P+1]; pow [0.5,infinity] [-2.5,-0.1] = [0.0,0X1.6A09E667F3BCDP+2]; pow [0.5,infinity] [-infinity,-0.1] = [0.0,infinity]; pow [0.5,infinity] [-1.0,-1.0] = [0.0,0X1P+1]; pow [0.5,infinity] [-2.5,-1.0] = [0.0,0X1.6A09E667F3BCDP+2]; pow [0.5,infinity] [-infinity,-1.0] = [0.0,infinity]; pow [0.5,infinity] [-infinity,-2.5] = [0.0,infinity]; pow [0.5,infinity] [-2.5,-2.5] = [0.0,0X1.6A09E667F3BCDP+2]; pow [1.0,1.5] [empty] = [empty]; pow [1.0,1.5] [0.0,0.0] = [1.0,1.0]; pow [1.0,1.5] [-0.0,-0.0] = [1.0,1.0]; pow [1.0,1.5] [0.0,1.0] = [1.0,0X1.8P+0]; pow [1.0,1.5] [-0.0,1.0] = [1.0,0X1.8P+0]; pow [1.0,1.5] [0.0,2.5] = [1.0,0X1.60B9FD68A4555P+1]; pow [1.0,1.5] [-0.0,2.5] = [1.0,0X1.60B9FD68A4555P+1]; pow [1.0,1.5] [0.0,infinity] = [1.0,infinity]; pow [1.0,1.5] [-0.0,infinity] = [1.0,infinity]; pow [1.0,1.5] [0.1,0.1] = [1.0,0X1.0A97DCE72A0CBP+0]; pow [1.0,1.5] [0.1,1.0] = [1.0,0X1.8P+0]; pow [1.0,1.5] [0.1,2.5] = [1.0,0X1.60B9FD68A4555P+1]; pow [1.0,1.5] [0.1,infinity] = [1.0,infinity]; pow [1.0,1.5] [1.0,1.0] = [1.0,0X1.8P+0]; pow [1.0,1.5] [1.0,2.5] = [1.0,0X1.60B9FD68A4555P+1]; pow [1.0,1.5] [1.0,infinity] = [1.0,infinity]; pow [1.0,1.5] [2.5,2.5] = [1.0,0X1.60B9FD68A4555P+1]; pow [1.0,1.5] [2.5,infinity] = [1.0,infinity]; pow [1.0,1.5] [-0.1,0.1] = [0X1.EBA7C9E4D31E9P-1,0X1.0A97DCE72A0CBP+0]; pow [1.0,1.5] [-0.1,1.0] = [0X1.EBA7C9E4D31E9P-1,0X1.8P+0]; pow [1.0,1.5] [-0.1,2.5] = [0X1.EBA7C9E4D31E9P-1,0X1.60B9FD68A4555P+1]; pow [1.0,1.5] [-0.1,infinity] = [0X1.EBA7C9E4D31E9P-1,infinity]; pow [1.0,1.5] [-1.0,0.1] = [0X1.5555555555555P-1,0X1.0A97DCE72A0CBP+0]; pow [1.0,1.5] [-1.0,1.0] = [0X1.5555555555555P-1,0X1.8P+0]; pow [1.0,1.5] [-1.0,2.5] = [0X1.5555555555555P-1,0X1.60B9FD68A4555P+1]; pow [1.0,1.5] [-1.0,infinity] = [0X1.5555555555555P-1,infinity]; pow [1.0,1.5] [-2.5,0.1] = [0X1.7398BF1D1EE6FP-2,0X1.0A97DCE72A0CBP+0]; pow [1.0,1.5] [-2.5,1.0] = [0X1.7398BF1D1EE6FP-2,0X1.8P+0]; pow [1.0,1.5] [-2.5,2.5] = [0X1.7398BF1D1EE6FP-2,0X1.60B9FD68A4555P+1]; pow [1.0,1.5] [-2.5,infinity] = [0X1.7398BF1D1EE6FP-2,infinity]; pow [1.0,1.5] [-infinity,0.1] = [0X0P+0,0X1.0A97DCE72A0CBP+0]; pow [1.0,1.5] [-infinity,1.0] = [0X0P+0,0X1.8P+0]; pow [1.0,1.5] [-infinity,2.5] = [0X0P+0,0X1.60B9FD68A4555P+1]; pow [1.0,1.5] [entire] = [0X0P+0,infinity]; pow [1.0,1.5] [-1.0,0.0] = [0X1.5555555555555P-1,1.0]; pow [1.0,1.5] [-1.0,-0.0] = [0X1.5555555555555P-1,1.0]; pow [1.0,1.5] [-2.5,0.0] = [0X1.7398BF1D1EE6FP-2,1.0]; pow [1.0,1.5] [-2.5,-0.0] = [0X1.7398BF1D1EE6FP-2,1.0]; pow [1.0,1.5] [-infinity,0.0] = [0X0P+0,1.0]; pow [1.0,1.5] [-infinity,-0.0] = [0X0P+0,1.0]; pow [1.0,1.5] [-0.1,-0.1] = [0X1.EBA7C9E4D31E9P-1,1.0]; pow [1.0,1.5] [-1.0,-0.1] = [0X1.5555555555555P-1,1.0]; pow [1.0,1.5] [-2.5,-0.1] = [0X1.7398BF1D1EE6FP-2,1.0]; pow [1.0,1.5] [-infinity,-0.1] = [0X0P+0,1.0]; pow [1.0,1.5] [-1.0,-1.0] = [0X1.5555555555555P-1,1.0]; pow [1.0,1.5] [-2.5,-1.0] = [0X1.7398BF1D1EE6FP-2,1.0]; pow [1.0,1.5] [-infinity,-1.0] = [0X0P+0,1.0]; pow [1.0,1.5] [-2.5,-2.5] = [0X1.7398BF1D1EE6FP-2,1.0]; pow [1.0,1.5] [-infinity,-2.5] = [0X0P+0,1.0]; pow [1.0,infinity] [empty] = [empty]; pow [1.0,infinity] [0.0,0.0] = [1.0,1.0]; pow [1.0,infinity] [-0.0,-0.0] = [1.0,1.0]; pow [1.0,infinity] [0.0,1.0] = [1.0,infinity]; pow [1.0,infinity] [-0.0,1.0] = [1.0,infinity]; pow [1.0,infinity] [0.0,2.5] = [1.0,infinity]; pow [1.0,infinity] [-0.0,2.5] = [1.0,infinity]; pow [1.0,infinity] [0.0,infinity] = [1.0,infinity]; pow [1.0,infinity] [-0.0,infinity] = [1.0,infinity]; pow [1.0,infinity] [0.1,0.1] = [1.0,infinity]; pow [1.0,infinity] [0.1,1.0] = [1.0,infinity]; pow [1.0,infinity] [0.1,2.5] = [1.0,infinity]; pow [1.0,infinity] [0.1,infinity] = [1.0,infinity]; pow [1.0,infinity] [1.0,1.0] = [1.0,infinity]; pow [1.0,infinity] [1.0,2.5] = [1.0,infinity]; pow [1.0,infinity] [1.0,infinity] = [1.0,infinity]; pow [1.0,infinity] [2.5,2.5] = [1.0,infinity]; pow [1.0,infinity] [2.5,infinity] = [1.0,infinity]; pow [1.0,infinity] [-0.1,0.1] = [0X0P+0,infinity]; pow [1.0,infinity] [-0.1,1.0] = [0X0P+0,infinity]; pow [1.0,infinity] [-0.1,2.5] = [0X0P+0,infinity]; pow [1.0,infinity] [-0.1,infinity] = [0X0P+0,infinity]; pow [1.0,infinity] [-1.0,0.1] = [0X0P+0,infinity]; pow [1.0,infinity] [-1.0,1.0] = [0X0P+0,infinity]; pow [1.0,infinity] [-1.0,2.5] = [0X0P+0,infinity]; pow [1.0,infinity] [-1.0,infinity] = [0X0P+0,infinity]; pow [1.0,infinity] [-2.5,0.1] = [0X0P+0,infinity]; pow [1.0,infinity] [-2.5,1.0] = [0X0P+0,infinity]; pow [1.0,infinity] [-2.5,2.5] = [0X0P+0,infinity]; pow [1.0,infinity] [-2.5,infinity] = [0X0P+0,infinity]; pow [1.0,infinity] [-infinity,0.1] = [0X0P+0,infinity]; pow [1.0,infinity] [-infinity,1.0] = [0X0P+0,infinity]; pow [1.0,infinity] [-infinity,2.5] = [0X0P+0,infinity]; pow [1.0,infinity] [entire] = [0X0P+0,infinity]; pow [1.0,infinity] [-1.0,0.0] = [0X0P+0,1.0]; pow [1.0,infinity] [-1.0,-0.0] = [0X0P+0,1.0]; pow [1.0,infinity] [-2.5,0.0] = [0X0P+0,1.0]; pow [1.0,infinity] [-2.5,-0.0] = [0X0P+0,1.0]; pow [1.0,infinity] [-infinity,0.0] = [0X0P+0,1.0]; pow [1.0,infinity] [-infinity,-0.0] = [0X0P+0,1.0]; pow [1.0,infinity] [-0.1,-0.1] = [0X0P+0,1.0]; pow [1.0,infinity] [-1.0,-0.1] = [0X0P+0,1.0]; pow [1.0,infinity] [-2.5,-0.1] = [0X0P+0,1.0]; pow [1.0,infinity] [-infinity,-0.1] = [0X0P+0,1.0]; pow [1.0,infinity] [-1.0,-1.0] = [0X0P+0,1.0]; pow [1.0,infinity] [-2.5,-1.0] = [0X0P+0,1.0]; pow [1.0,infinity] [-infinity,-1.0] = [0X0P+0,1.0]; pow [1.0,infinity] [-2.5,-2.5] = [0X0P+0,1.0]; pow [1.0,infinity] [-infinity,-2.5] = [0X0P+0,1.0]; pow [1.1,1.5] [empty] = [empty]; pow [1.1,1.5] [0.0,0.0] = [1.0,1.0]; pow [1.1,1.5] [-0.0,-0.0] = [1.0,1.0]; pow [1.1,1.5] [0.0,1.0] = [1.0,0X1.8P+0]; pow [1.1,1.5] [-0.0,1.0] = [1.0,0X1.8P+0]; pow [1.1,1.5] [0.0,2.5] = [1.0,0X1.60B9FD68A4555P+1]; pow [1.1,1.5] [-0.0,2.5] = [1.0,0X1.60B9FD68A4555P+1]; pow [1.1,1.5] [0.0,infinity] = [1.0,infinity]; pow [1.1,1.5] [-0.0,infinity] = [1.0,infinity]; pow [1.1,1.5] [0.1,0.1] = [0X1.02739C65D58BFP+0,0X1.0A97DCE72A0CBP+0]; pow [1.1,1.5] [0.1,1.0] = [0X1.02739C65D58BFP+0,0X1.8P+0]; pow [1.1,1.5] [0.1,2.5] = [0X1.02739C65D58BFP+0,0X1.60B9FD68A4555P+1]; pow [1.1,1.5] [0.1,infinity] = [0X1.02739C65D58BFP+0,infinity]; pow [1.1,1.5] [1.0,1.0] = [0X1.199999999999AP+0,0X1.8P+0]; pow [1.1,1.5] [1.0,2.5] = [0X1.199999999999AP+0,0X1.60B9FD68A4555P+1]; pow [1.1,1.5] [1.0,infinity] = [0X1.199999999999AP+0,infinity]; pow [1.1,1.5] [2.5,2.5] = [0X1.44E1080833B25P+0,0X1.60B9FD68A4555P+1]; pow [1.1,1.5] [2.5,infinity] = [0X1.44E1080833B25P+0,infinity]; pow [1.1,1.5] [-0.1,0.1] = [0X1.EBA7C9E4D31E9P-1,0X1.0A97DCE72A0CBP+0]; pow [1.1,1.5] [-0.1,1.0] = [0X1.EBA7C9E4D31E9P-1,0X1.8P+0]; pow [1.1,1.5] [-0.1,2.5] = [0X1.EBA7C9E4D31E9P-1,0X1.60B9FD68A4555P+1]; pow [1.1,1.5] [-0.1,infinity] = [0X1.EBA7C9E4D31E9P-1,infinity]; pow [1.1,1.5] [-1.0,0.1] = [0X1.5555555555555P-1,0X1.0A97DCE72A0CBP+0]; pow [1.1,1.5] [-1.0,1.0] = [0X1.5555555555555P-1,0X1.8P+0]; pow [1.1,1.5] [-1.0,2.5] = [0X1.5555555555555P-1,0X1.60B9FD68A4555P+1]; pow [1.1,1.5] [-1.0,infinity] = [0X1.5555555555555P-1,infinity]; pow [1.1,1.5] [-2.5,0.1] = [0X1.7398BF1D1EE6FP-2,0X1.0A97DCE72A0CBP+0]; pow [1.1,1.5] [-2.5,1.0] = [0X1.7398BF1D1EE6FP-2,0X1.8P+0]; pow [1.1,1.5] [-2.5,2.5] = [0X1.7398BF1D1EE6FP-2,0X1.60B9FD68A4555P+1]; pow [1.1,1.5] [-2.5,infinity] = [0X1.7398BF1D1EE6FP-2,infinity]; pow [1.1,1.5] [-infinity,0.1] = [0X0P+0,0X1.0A97DCE72A0CBP+0]; pow [1.1,1.5] [-infinity,1.0] = [0X0P+0,0X1.8P+0]; pow [1.1,1.5] [-infinity,2.5] = [0X0P+0,0X1.60B9FD68A4555P+1]; pow [1.1,1.5] [entire] = [0X0P+0,infinity]; pow [1.1,1.5] [-1.0,0.0] = [0X1.5555555555555P-1,1.0]; pow [1.1,1.5] [-1.0,-0.0] = [0X1.5555555555555P-1,1.0]; pow [1.1,1.5] [-2.5,0.0] = [0X1.7398BF1D1EE6FP-2,1.0]; pow [1.1,1.5] [-2.5,-0.0] = [0X1.7398BF1D1EE6FP-2,1.0]; pow [1.1,1.5] [-infinity,0.0] = [0X0P+0,1.0]; pow [1.1,1.5] [-infinity,-0.0] = [0X0P+0,1.0]; pow [1.1,1.5] [-0.1,-0.1] = [0X1.EBA7C9E4D31E9P-1,0X1.FB24AF5281928P-1]; pow [1.1,1.5] [-1.0,-0.1] = [0X1.5555555555555P-1,0X1.FB24AF5281928P-1]; pow [1.1,1.5] [-2.5,-0.1] = [0X1.7398BF1D1EE6FP-2,0X1.FB24AF5281928P-1]; pow [1.1,1.5] [-infinity,-0.1] = [0X0P+0,0X1.FB24AF5281928P-1]; pow [1.1,1.5] [-1.0,-1.0] = [0X1.5555555555555P-1,0X1.D1745D1745D17P-1]; pow [1.1,1.5] [-2.5,-1.0] = [0X1.7398BF1D1EE6FP-2,0X1.D1745D1745D17P-1]; pow [1.1,1.5] [-infinity,-1.0] = [0X0P+0,0X1.D1745D1745D17P-1]; pow [1.1,1.5] [-2.5,-2.5] = [0X1.7398BF1D1EE6FP-2,0X1.9372D999784C8P-1]; pow [1.1,1.5] [-infinity,-2.5] = [0X0P+0,0X1.9372D999784C8P-1]; pow [1.1,infinity] [empty] = [empty]; pow [1.1,infinity] [0.0,0.0] = [1.0,1.0]; pow [1.1,infinity] [-0.0,-0.0] = [1.0,1.0]; pow [1.1,infinity] [0.0,1.0] = [1.0,infinity]; pow [1.1,infinity] [-0.0,1.0] = [1.0,infinity]; pow [1.1,infinity] [0.0,2.5] = [1.0,infinity]; pow [1.1,infinity] [-0.0,2.5] = [1.0,infinity]; pow [1.1,infinity] [0.0,infinity] = [1.0,infinity]; pow [1.1,infinity] [-0.0,infinity] = [1.0,infinity]; pow [1.1,infinity] [0.1,0.1] = [0X1.02739C65D58BFP+0,infinity]; pow [1.1,infinity] [0.1,1.0] = [0X1.02739C65D58BFP+0,infinity]; pow [1.1,infinity] [0.1,2.5] = [0X1.02739C65D58BFP+0,infinity]; pow [1.1,infinity] [0.1,infinity] = [0X1.02739C65D58BFP+0,infinity]; pow [1.1,infinity] [1.0,1.0] = [0X1.199999999999AP+0,infinity]; pow [1.1,infinity] [1.0,2.5] = [0X1.199999999999AP+0,infinity]; pow [1.1,infinity] [1.0,infinity] = [0X1.199999999999AP+0,infinity]; pow [1.1,infinity] [2.5,2.5] = [0X1.44E1080833B25P+0,infinity]; pow [1.1,infinity] [2.5,infinity] = [0X1.44E1080833B25P+0,infinity]; pow [1.1,infinity] [-0.1,0.1] = [0X0P+0,infinity]; pow [1.1,infinity] [-0.1,1.0] = [0X0P+0,infinity]; pow [1.1,infinity] [-0.1,2.5] = [0X0P+0,infinity]; pow [1.1,infinity] [-0.1,infinity] = [0X0P+0,infinity]; pow [1.1,infinity] [-1.0,0.1] = [0X0P+0,infinity]; pow [1.1,infinity] [-1.0,1.0] = [0X0P+0,infinity]; pow [1.1,infinity] [-1.0,2.5] = [0X0P+0,infinity]; pow [1.1,infinity] [-1.0,infinity] = [0X0P+0,infinity]; pow [1.1,infinity] [-2.5,0.1] = [0X0P+0,infinity]; pow [1.1,infinity] [-2.5,1.0] = [0X0P+0,infinity]; pow [1.1,infinity] [-2.5,2.5] = [0X0P+0,infinity]; pow [1.1,infinity] [-2.5,infinity] = [0X0P+0,infinity]; pow [1.1,infinity] [-infinity,0.1] = [0X0P+0,infinity]; pow [1.1,infinity] [-infinity,1.0] = [0X0P+0,infinity]; pow [1.1,infinity] [-infinity,2.5] = [0X0P+0,infinity]; pow [1.1,infinity] [entire] = [0X0P+0,infinity]; pow [1.1,infinity] [-1.0,0.0] = [0X0P+0,1.0]; pow [1.1,infinity] [-1.0,-0.0] = [0X0P+0,1.0]; pow [1.1,infinity] [-2.5,0.0] = [0X0P+0,1.0]; pow [1.1,infinity] [-2.5,-0.0] = [0X0P+0,1.0]; pow [1.1,infinity] [-infinity,0.0] = [0X0P+0,1.0]; pow [1.1,infinity] [-infinity,-0.0] = [0X0P+0,1.0]; pow [1.1,infinity] [-0.1,-0.1] = [0X0P+0,0X1.FB24AF5281928P-1]; pow [1.1,infinity] [-1.0,-0.1] = [0X0P+0,0X1.FB24AF5281928P-1]; pow [1.1,infinity] [-2.5,-0.1] = [0X0P+0,0X1.FB24AF5281928P-1]; pow [1.1,infinity] [-infinity,-0.1] = [0X0P+0,0X1.FB24AF5281928P-1]; pow [1.1,infinity] [-1.0,-1.0] = [0X0P+0,0X1.D1745D1745D17P-1]; pow [1.1,infinity] [-2.5,-1.0] = [0X0P+0,0X1.D1745D1745D17P-1]; pow [1.1,infinity] [-infinity,-1.0] = [0X0P+0,0X1.D1745D1745D17P-1]; pow [1.1,infinity] [-2.5,-2.5] = [0X0P+0,0X1.9372D999784C8P-1]; pow [1.1,infinity] [-infinity,-2.5] = [0X0P+0,0X1.9372D999784C8P-1]; pow [0.0,0.5] [empty] = [empty]; pow [0.0,0.5] [0.0,0.0] = [1.0,1.0]; pow [0.0,0.5] [-0.0,-0.0] = [1.0,1.0]; pow [0.0,0.5] [0.0,1.0] = [0.0,1.0]; pow [0.0,0.5] [-0.0,1.0] = [0.0,1.0]; pow [0.0,0.5] [0.0,2.5] = [0.0,1.0]; pow [0.0,0.5] [-0.0,2.5] = [0.0,1.0]; pow [0.0,0.5] [0.0,infinity] = [0.0,1.0]; pow [0.0,0.5] [-0.0,infinity] = [0.0,1.0]; pow [0.0,0.5] [0.1,0.1] = [0.0,0X1.DDB680117AB13P-1]; pow [0.0,0.5] [0.1,1.0] = [0.0,0X1.DDB680117AB13P-1]; pow [0.0,0.5] [0.1,2.5] = [0.0,0X1.DDB680117AB13P-1]; pow [0.0,0.5] [0.1,infinity] = [0.0,0X1.DDB680117AB13P-1]; pow [0.0,0.5] [1.0,1.0] = [0.0,0.5]; pow [0.0,0.5] [1.0,2.5] = [0.0,0.5]; pow [0.0,0.5] [1.0,infinity] = [0.0,0.5]; pow [0.0,0.5] [2.5,2.5] = [0.0,0X1.6A09E667F3BCDP-3]; pow [0.0,0.5] [2.5,infinity] = [0.0,0X1.6A09E667F3BCDP-3]; pow [0.0,0.5] [-0.1,0.1] = [0.0,infinity]; pow [0.0,0.5] [-0.1,1.0] = [0.0,infinity]; pow [0.0,0.5] [-0.1,2.5] = [0.0,infinity]; pow [0.0,0.5] [-0.1,infinity] = [0.0,infinity]; pow [0.0,0.5] [-1.0,0.1] = [0.0,infinity]; pow [0.0,0.5] [-1.0,1.0] = [0.0,infinity]; pow [0.0,0.5] [-1.0,2.5] = [0.0,infinity]; pow [0.0,0.5] [-1.0,infinity] = [0.0,infinity]; pow [0.0,0.5] [-2.5,0.1] = [0.0,infinity]; pow [0.0,0.5] [-2.5,1.0] = [0.0,infinity]; pow [0.0,0.5] [-2.5,2.5] = [0.0,infinity]; pow [0.0,0.5] [-2.5,infinity] = [0.0,infinity]; pow [0.0,0.5] [-infinity,0.1] = [0.0,infinity]; pow [0.0,0.5] [-infinity,1.0] = [0.0,infinity]; pow [0.0,0.5] [-infinity,2.5] = [0.0,infinity]; pow [0.0,0.5] [entire] = [0.0,infinity]; pow [0.0,0.5] [-1.0,0.0] = [1.0,infinity]; pow [0.0,0.5] [-1.0,-0.0] = [1.0,infinity]; pow [0.0,0.5] [-2.5,0.0] = [1.0,infinity]; pow [0.0,0.5] [-2.5,-0.0] = [1.0,infinity]; pow [0.0,0.5] [-infinity,0.0] = [1.0,infinity]; pow [0.0,0.5] [-infinity,-0.0] = [1.0,infinity]; pow [0.0,0.5] [-0.1,-0.1] = [0X1.125FBEE250664P+0,infinity]; pow [0.0,0.5] [-1.0,-0.1] = [0X1.125FBEE250664P+0,infinity]; pow [0.0,0.5] [-2.5,-0.1] = [0X1.125FBEE250664P+0,infinity]; pow [0.0,0.5] [-infinity,-0.1] = [0X1.125FBEE250664P+0,infinity]; pow [0.0,0.5] [-1.0,-1.0] = [0X1P+1,infinity]; pow [0.0,0.5] [-2.5,-1.0] = [0X1P+1,infinity]; pow [0.0,0.5] [-infinity,-1.0] = [0X1P+1,infinity]; pow [0.0,0.5] [-2.5,-2.5] = [0X1.6A09E667F3BCCP+2,infinity]; pow [0.0,0.5] [-infinity,-2.5] = [0X1.6A09E667F3BCCP+2,infinity]; pow [0.0,1.0] [empty] = [empty]; pow [0.0,1.0] [0.0,0.0] = [1.0,1.0]; pow [0.0,1.0] [-0.0,-0.0] = [1.0,1.0]; pow [0.0,1.0] [0.0,1.0] = [0.0,1.0]; pow [0.0,1.0] [-0.0,1.0] = [0.0,1.0]; pow [0.0,1.0] [0.0,2.5] = [0.0,1.0]; pow [0.0,1.0] [-0.0,2.5] = [0.0,1.0]; pow [0.0,1.0] [0.0,infinity] = [0.0,1.0]; pow [0.0,1.0] [-0.0,infinity] = [0.0,1.0]; pow [0.0,1.0] [0.1,0.1] = [0.0,1.0]; pow [0.0,1.0] [0.1,1.0] = [0.0,1.0]; pow [0.0,1.0] [0.1,2.5] = [0.0,1.0]; pow [0.0,1.0] [0.1,infinity] = [0.0,1.0]; pow [0.0,1.0] [1.0,1.0] = [0.0,1.0]; pow [0.0,1.0] [1.0,2.5] = [0.0,1.0]; pow [0.0,1.0] [1.0,infinity] = [0.0,1.0]; pow [0.0,1.0] [2.5,2.5] = [0.0,1.0]; pow [0.0,1.0] [2.5,infinity] = [0.0,1.0]; pow [0.0,1.0] [-0.1,0.1] = [0.0,infinity]; pow [0.0,1.0] [-0.1,1.0] = [0.0,infinity]; pow [0.0,1.0] [-0.1,2.5] = [0.0,infinity]; pow [0.0,1.0] [-0.1,infinity] = [0.0,infinity]; pow [0.0,1.0] [-1.0,0.1] = [0.0,infinity]; pow [0.0,1.0] [-1.0,1.0] = [0.0,infinity]; pow [0.0,1.0] [-1.0,2.5] = [0.0,infinity]; pow [0.0,1.0] [-1.0,infinity] = [0.0,infinity]; pow [0.0,1.0] [-2.5,0.1] = [0.0,infinity]; pow [0.0,1.0] [-2.5,1.0] = [0.0,infinity]; pow [0.0,1.0] [-2.5,2.5] = [0.0,infinity]; pow [0.0,1.0] [-2.5,infinity] = [0.0,infinity]; pow [0.0,1.0] [-infinity,0.1] = [0.0,infinity]; pow [0.0,1.0] [-infinity,1.0] = [0.0,infinity]; pow [0.0,1.0] [-infinity,2.5] = [0.0,infinity]; pow [0.0,1.0] [entire] = [0.0,infinity]; pow [0.0,1.0] [-0.1,0.0] = [1.0,infinity]; pow [0.0,1.0] [-0.1,-0.0] = [1.0,infinity]; pow [0.0,1.0] [-1.0,0.0] = [1.0,infinity]; pow [0.0,1.0] [-1.0,-0.0] = [1.0,infinity]; pow [0.0,1.0] [-2.5,0.0] = [1.0,infinity]; pow [0.0,1.0] [-2.5,-0.0] = [1.0,infinity]; pow [0.0,1.0] [-infinity,0.0] = [1.0,infinity]; pow [0.0,1.0] [-infinity,-0.0] = [1.0,infinity]; pow [0.0,1.0] [-0.1,-0.1] = [1.0,infinity]; pow [0.0,1.0] [-1.0,-0.1] = [1.0,infinity]; pow [0.0,1.0] [-2.5,-0.1] = [1.0,infinity]; pow [0.0,1.0] [-infinity,-0.1] = [1.0,infinity]; pow [0.0,1.0] [-1.0,-1.0] = [1.0,infinity]; pow [0.0,1.0] [-2.5,-1.0] = [1.0,infinity]; pow [0.0,1.0] [-infinity,-1.0] = [1.0,infinity]; pow [0.0,1.0] [-2.5,-2.5] = [1.0,infinity]; pow [0.0,1.0] [-infinity,-2.5] = [1.0,infinity]; pow [0.0,1.5] [empty] = [empty]; pow [0.0,1.5] [0.0,0.0] = [1.0,1.0]; pow [0.0,1.5] [-0.0,-0.0] = [1.0,1.0]; pow [0.0,1.5] [0.0,1.0] = [0.0,1.5]; pow [0.0,1.5] [-0.0,1.0] = [0.0,1.5]; pow [0.0,1.5] [0.0,2.5] = [0.0,0X1.60B9FD68A4555P+1]; pow [0.0,1.5] [-0.0,2.5] = [0.0,0X1.60B9FD68A4555P+1]; pow [0.0,1.5] [0.0,infinity] = [0.0,infinity]; pow [0.0,1.5] [-0.0,infinity] = [0.0,infinity]; pow [0.0,1.5] [0.1,0.1] = [0.0,0X1.0A97DCE72A0CBP+0]; pow [0.0,1.5] [0.1,1.0] = [0.0,1.5]; pow [0.0,1.5] [0.1,2.5] = [0.0,0X1.60B9FD68A4555P+1]; pow [0.0,1.5] [0.1,infinity] = [0.0,infinity]; pow [0.0,1.5] [1.0,1.0] = [0.0,1.5]; pow [0.0,1.5] [1.0,2.5] = [0.0,0X1.60B9FD68A4555P+1]; pow [0.0,1.5] [1.0,infinity] = [0.0,infinity]; pow [0.0,1.5] [2.5,2.5] = [0.0,0X1.60B9FD68A4555P+1]; pow [0.0,1.5] [2.5,infinity] = [0.0,infinity]; pow [0.0,1.5] [-0.1,0.1] = [0.0,infinity]; pow [0.0,1.5] [-0.1,1.0] = [0.0,infinity]; pow [0.0,1.5] [-0.1,2.5] = [0.0,infinity]; pow [0.0,1.5] [-0.1,infinity] = [0.0,infinity]; pow [0.0,1.5] [-1.0,0.1] = [0.0,infinity]; pow [0.0,1.5] [-1.0,1.0] = [0.0,infinity]; pow [0.0,1.5] [-1.0,2.5] = [0.0,infinity]; pow [0.0,1.5] [-1.0,infinity] = [0.0,infinity]; pow [0.0,1.5] [-2.5,0.1] = [0.0,infinity]; pow [0.0,1.5] [-2.5,1.0] = [0.0,infinity]; pow [0.0,1.5] [-2.5,2.5] = [0.0,infinity]; pow [0.0,1.5] [-2.5,infinity] = [0.0,infinity]; pow [0.0,1.5] [-infinity,0.1] = [0.0,infinity]; pow [0.0,1.5] [-infinity,1.0] = [0.0,infinity]; pow [0.0,1.5] [-infinity,2.5] = [0.0,infinity]; pow [0.0,1.5] [entire] = [0.0,infinity]; pow [0.0,1.5] [-1.0,0.0] = [0X1.5555555555555P-1,infinity]; pow [0.0,1.5] [-1.0,-0.0] = [0X1.5555555555555P-1,infinity]; pow [0.0,1.5] [-2.5,0.0] = [0X1.7398BF1D1EE6FP-2,infinity]; pow [0.0,1.5] [-2.5,-0.0] = [0X1.7398BF1D1EE6FP-2,infinity]; pow [0.0,1.5] [-infinity,0.0] = [0.0,infinity]; pow [0.0,1.5] [-infinity,-0.0] = [0.0,infinity]; pow [0.0,1.5] [-0.1,-0.1] = [0X1.EBA7C9E4D31E9P-1,infinity]; pow [0.0,1.5] [-1.0,-0.1] = [0X1.5555555555555P-1,infinity]; pow [0.0,1.5] [-2.5,-0.1] = [0X1.7398BF1D1EE6FP-2,infinity]; pow [0.0,1.5] [-infinity,-0.1] = [0.0,infinity]; pow [0.0,1.5] [-1.0,-1.0] = [0X1.5555555555555P-1,infinity]; pow [0.0,1.5] [-2.5,-1.0] = [0X1.7398BF1D1EE6FP-2,infinity]; pow [0.0,1.5] [-infinity,-1.0] = [0.0,infinity]; pow [0.0,1.5] [-2.5,-2.5] = [0X1.7398BF1D1EE6FP-2,infinity]; pow [0.0,1.5] [-infinity,-2.5] = [0.0,infinity]; pow [0.0,infinity] [empty] = [empty]; pow [0.0,infinity] [0.0,0.0] = [1.0,1.0]; pow [0.0,infinity] [-0.0,-0.0] = [1.0,1.0]; pow [0.0,infinity] [0.0,1.0] = [0.0,infinity]; pow [0.0,infinity] [-0.0,1.0] = [0.0,infinity]; pow [0.0,infinity] [0.0,2.5] = [0.0,infinity]; pow [0.0,infinity] [-0.0,2.5] = [0.0,infinity]; pow [0.0,infinity] [0.0,infinity] = [0.0,infinity]; pow [0.0,infinity] [-0.0,infinity] = [0.0,infinity]; pow [0.0,infinity] [0.1,0.1] = [0.0,infinity]; pow [0.0,infinity] [0.1,1.0] = [0.0,infinity]; pow [0.0,infinity] [0.1,2.5] = [0.0,infinity]; pow [0.0,infinity] [0.1,infinity] = [0.0,infinity]; pow [0.0,infinity] [1.0,1.0] = [0.0,infinity]; pow [0.0,infinity] [1.0,2.5] = [0.0,infinity]; pow [0.0,infinity] [1.0,infinity] = [0.0,infinity]; pow [0.0,infinity] [2.5,2.5] = [0.0,infinity]; pow [0.0,infinity] [2.5,infinity] = [0.0,infinity]; pow [0.0,infinity] [-0.1,0.1] = [0.0,infinity]; pow [0.0,infinity] [-0.1,1.0] = [0.0,infinity]; pow [0.0,infinity] [-0.1,2.5] = [0.0,infinity]; pow [0.0,infinity] [-0.1,infinity] = [0.0,infinity]; pow [0.0,infinity] [-1.0,0.1] = [0.0,infinity]; pow [0.0,infinity] [-1.0,1.0] = [0.0,infinity]; pow [0.0,infinity] [-1.0,2.5] = [0.0,infinity]; pow [0.0,infinity] [-1.0,infinity] = [0.0,infinity]; pow [0.0,infinity] [-2.5,0.1] = [0.0,infinity]; pow [0.0,infinity] [-2.5,1.0] = [0.0,infinity]; pow [0.0,infinity] [-2.5,2.5] = [0.0,infinity]; pow [0.0,infinity] [-2.5,infinity] = [0.0,infinity]; pow [0.0,infinity] [-infinity,0.1] = [0.0,infinity]; pow [0.0,infinity] [-infinity,1.0] = [0.0,infinity]; pow [0.0,infinity] [-infinity,2.5] = [0.0,infinity]; pow [0.0,infinity] [entire] = [0.0,infinity]; pow [0.0,infinity] [-1.0,0.0] = [0.0,infinity]; pow [0.0,infinity] [-1.0,-0.0] = [0.0,infinity]; pow [0.0,infinity] [-2.5,0.0] = [0.0,infinity]; pow [0.0,infinity] [-2.5,-0.0] = [0.0,infinity]; pow [0.0,infinity] [-infinity,0.0] = [0.0,infinity]; pow [0.0,infinity] [-infinity,-0.0] = [0.0,infinity]; pow [0.0,infinity] [-0.1,-0.1] = [0.0,infinity]; pow [0.0,infinity] [-1.0,-0.1] = [0.0,infinity]; pow [0.0,infinity] [-2.5,-0.1] = [0.0,infinity]; pow [0.0,infinity] [-infinity,-0.1] = [0.0,infinity]; pow [0.0,infinity] [-1.0,-1.0] = [0.0,infinity]; pow [0.0,infinity] [-2.5,-1.0] = [0.0,infinity]; pow [0.0,infinity] [-infinity,-1.0] = [0.0,infinity]; pow [0.0,infinity] [-infinity,-2.5] = [0.0,infinity]; pow [0.0,infinity] [-2.5,-2.5] = [0.0,infinity]; pow [-0.0,0.5] [empty] = [empty]; pow [-0.0,0.5] [0.0,0.0] = [1.0,1.0]; pow [-0.0,0.5] [-0.0,-0.0] = [1.0,1.0]; pow [-0.0,0.5] [0.0,1.0] = [0.0,1.0]; pow [-0.0,0.5] [-0.0,1.0] = [0.0,1.0]; pow [-0.0,0.5] [0.0,2.5] = [0.0,1.0]; pow [-0.0,0.5] [-0.0,2.5] = [0.0,1.0]; pow [-0.0,0.5] [0.0,infinity] = [0.0,1.0]; pow [-0.0,0.5] [-0.0,infinity] = [0.0,1.0]; pow [-0.0,0.5] [0.1,0.1] = [0.0,0X1.DDB680117AB13P-1]; pow [-0.0,0.5] [0.1,1.0] = [0.0,0X1.DDB680117AB13P-1]; pow [-0.0,0.5] [0.1,2.5] = [0.0,0X1.DDB680117AB13P-1]; pow [-0.0,0.5] [0.1,infinity] = [0.0,0X1.DDB680117AB13P-1]; pow [-0.0,0.5] [1.0,1.0] = [0.0,0.5]; pow [-0.0,0.5] [1.0,2.5] = [0.0,0.5]; pow [-0.0,0.5] [1.0,infinity] = [0.0,0.5]; pow [-0.0,0.5] [2.5,2.5] = [0.0,0X1.6A09E667F3BCDP-3]; pow [-0.0,0.5] [2.5,infinity] = [0.0,0X1.6A09E667F3BCDP-3]; pow [-0.0,0.5] [-0.1,0.1] = [0.0,infinity]; pow [-0.0,0.5] [-0.1,1.0] = [0.0,infinity]; pow [-0.0,0.5] [-0.1,2.5] = [0.0,infinity]; pow [-0.0,0.5] [-0.1,infinity] = [0.0,infinity]; pow [-0.0,0.5] [-1.0,0.1] = [0.0,infinity]; pow [-0.0,0.5] [-1.0,1.0] = [0.0,infinity]; pow [-0.0,0.5] [-1.0,2.5] = [0.0,infinity]; pow [-0.0,0.5] [-1.0,infinity] = [0.0,infinity]; pow [-0.0,0.5] [-2.5,0.1] = [0.0,infinity]; pow [-0.0,0.5] [-2.5,1.0] = [0.0,infinity]; pow [-0.0,0.5] [-2.5,2.5] = [0.0,infinity]; pow [-0.0,0.5] [-2.5,infinity] = [0.0,infinity]; pow [-0.0,0.5] [-infinity,0.1] = [0.0,infinity]; pow [-0.0,0.5] [-infinity,1.0] = [0.0,infinity]; pow [-0.0,0.5] [-infinity,2.5] = [0.0,infinity]; pow [-0.0,0.5] [entire] = [0.0,infinity]; pow [-0.0,0.5] [-1.0,0.0] = [1.0,infinity]; pow [-0.0,0.5] [-1.0,-0.0] = [1.0,infinity]; pow [-0.0,0.5] [-2.5,0.0] = [1.0,infinity]; pow [-0.0,0.5] [-2.5,-0.0] = [1.0,infinity]; pow [-0.0,0.5] [-infinity,0.0] = [1.0,infinity]; pow [-0.0,0.5] [-infinity,-0.0] = [1.0,infinity]; pow [-0.0,0.5] [-0.1,-0.1] = [0X1.125FBEE250664P+0,infinity]; pow [-0.0,0.5] [-1.0,-0.1] = [0X1.125FBEE250664P+0,infinity]; pow [-0.0,0.5] [-2.5,-0.1] = [0X1.125FBEE250664P+0,infinity]; pow [-0.0,0.5] [-infinity,-0.1] = [0X1.125FBEE250664P+0,infinity]; pow [-0.0,0.5] [-1.0,-1.0] = [0X1P+1,infinity]; pow [-0.0,0.5] [-2.5,-1.0] = [0X1P+1,infinity]; pow [-0.0,0.5] [-infinity,-1.0] = [0X1P+1,infinity]; pow [-0.0,0.5] [-2.5,-2.5] = [0X1.6A09E667F3BCCP+2,infinity]; pow [-0.0,0.5] [-infinity,-2.5] = [0X1.6A09E667F3BCCP+2,infinity]; pow [-0.0,1.0] [empty] = [empty]; pow [-0.0,1.0] [0.0,0.0] = [1.0,1.0]; pow [-0.0,1.0] [-0.0,-0.0] = [1.0,1.0]; pow [-0.0,1.0] [0.0,1.0] = [0.0,1.0]; pow [-0.0,1.0] [-0.0,1.0] = [0.0,1.0]; pow [-0.0,1.0] [0.0,2.5] = [0.0,1.0]; pow [-0.0,1.0] [-0.0,2.5] = [0.0,1.0]; pow [-0.0,1.0] [0.0,infinity] = [0.0,1.0]; pow [-0.0,1.0] [-0.0,infinity] = [0.0,1.0]; pow [-0.0,1.0] [0.1,0.1] = [0.0,1.0]; pow [-0.0,1.0] [0.1,1.0] = [0.0,1.0]; pow [-0.0,1.0] [0.1,2.5] = [0.0,1.0]; pow [-0.0,1.0] [0.1,infinity] = [0.0,1.0]; pow [-0.0,1.0] [1.0,1.0] = [0.0,1.0]; pow [-0.0,1.0] [1.0,2.5] = [0.0,1.0]; pow [-0.0,1.0] [1.0,infinity] = [0.0,1.0]; pow [-0.0,1.0] [2.5,2.5] = [0.0,1.0]; pow [-0.0,1.0] [2.5,infinity] = [0.0,1.0]; pow [-0.0,1.0] [-0.1,0.1] = [0.0,infinity]; pow [-0.0,1.0] [-0.1,1.0] = [0.0,infinity]; pow [-0.0,1.0] [-0.1,2.5] = [0.0,infinity]; pow [-0.0,1.0] [-0.1,infinity] = [0.0,infinity]; pow [-0.0,1.0] [-1.0,0.1] = [0.0,infinity]; pow [-0.0,1.0] [-1.0,1.0] = [0.0,infinity]; pow [-0.0,1.0] [-1.0,2.5] = [0.0,infinity]; pow [-0.0,1.0] [-1.0,infinity] = [0.0,infinity]; pow [-0.0,1.0] [-2.5,0.1] = [0.0,infinity]; pow [-0.0,1.0] [-2.5,1.0] = [0.0,infinity]; pow [-0.0,1.0] [-2.5,2.5] = [0.0,infinity]; pow [-0.0,1.0] [-2.5,infinity] = [0.0,infinity]; pow [-0.0,1.0] [-infinity,0.1] = [0.0,infinity]; pow [-0.0,1.0] [-infinity,1.0] = [0.0,infinity]; pow [-0.0,1.0] [-infinity,2.5] = [0.0,infinity]; pow [-0.0,1.0] [entire] = [0.0,infinity]; pow [-0.0,1.0] [-0.1,0.0] = [1.0,infinity]; pow [-0.0,1.0] [-0.1,-0.0] = [1.0,infinity]; pow [-0.0,1.0] [-1.0,0.0] = [1.0,infinity]; pow [-0.0,1.0] [-1.0,-0.0] = [1.0,infinity]; pow [-0.0,1.0] [-2.5,0.0] = [1.0,infinity]; pow [-0.0,1.0] [-2.5,-0.0] = [1.0,infinity]; pow [-0.0,1.0] [-infinity,0.0] = [1.0,infinity]; pow [-0.0,1.0] [-infinity,-0.0] = [1.0,infinity]; pow [-0.0,1.0] [-0.1,-0.1] = [1.0,infinity]; pow [-0.0,1.0] [-1.0,-0.1] = [1.0,infinity]; pow [-0.0,1.0] [-2.5,-0.1] = [1.0,infinity]; pow [-0.0,1.0] [-infinity,-0.1] = [1.0,infinity]; pow [-0.0,1.0] [-1.0,-1.0] = [1.0,infinity]; pow [-0.0,1.0] [-2.5,-1.0] = [1.0,infinity]; pow [-0.0,1.0] [-infinity,-1.0] = [1.0,infinity]; pow [-0.0,1.0] [-2.5,-2.5] = [1.0,infinity]; pow [-0.0,1.0] [-infinity,-2.5] = [1.0,infinity]; pow [-0.0,1.5] [empty] = [empty]; pow [-0.0,1.5] [0.0,0.0] = [1.0,1.0]; pow [-0.0,1.5] [-0.0,-0.0] = [1.0,1.0]; pow [-0.0,1.5] [0.0,1.0] = [0.0,1.5]; pow [-0.0,1.5] [-0.0,1.0] = [0.0,1.5]; pow [-0.0,1.5] [0.0,2.5] = [0.0,0X1.60B9FD68A4555P+1]; pow [-0.0,1.5] [-0.0,2.5] = [0.0,0X1.60B9FD68A4555P+1]; pow [-0.0,1.5] [0.0,infinity] = [0.0,infinity]; pow [-0.0,1.5] [-0.0,infinity] = [0.0,infinity]; pow [-0.0,1.5] [0.1,0.1] = [0.0,0X1.0A97DCE72A0CBP+0]; pow [-0.0,1.5] [0.1,1.0] = [0.0,1.5]; pow [-0.0,1.5] [0.1,2.5] = [0.0,0X1.60B9FD68A4555P+1]; pow [-0.0,1.5] [0.1,infinity] = [0.0,infinity]; pow [-0.0,1.5] [1.0,1.0] = [0.0,1.5]; pow [-0.0,1.5] [1.0,2.5] = [0.0,0X1.60B9FD68A4555P+1]; pow [-0.0,1.5] [1.0,infinity] = [0.0,infinity]; pow [-0.0,1.5] [2.5,2.5] = [0.0,0X1.60B9FD68A4555P+1]; pow [-0.0,1.5] [2.5,infinity] = [0.0,infinity]; pow [-0.0,1.5] [-0.1,0.1] = [0.0,infinity]; pow [-0.0,1.5] [-0.1,1.0] = [0.0,infinity]; pow [-0.0,1.5] [-0.1,2.5] = [0.0,infinity]; pow [-0.0,1.5] [-0.1,infinity] = [0.0,infinity]; pow [-0.0,1.5] [-1.0,0.1] = [0.0,infinity]; pow [-0.0,1.5] [-1.0,1.0] = [0.0,infinity]; pow [-0.0,1.5] [-1.0,2.5] = [0.0,infinity]; pow [-0.0,1.5] [-1.0,infinity] = [0.0,infinity]; pow [-0.0,1.5] [-2.5,0.1] = [0.0,infinity]; pow [-0.0,1.5] [-2.5,1.0] = [0.0,infinity]; pow [-0.0,1.5] [-2.5,2.5] = [0.0,infinity]; pow [-0.0,1.5] [-2.5,infinity] = [0.0,infinity]; pow [-0.0,1.5] [-infinity,0.1] = [0.0,infinity]; pow [-0.0,1.5] [-infinity,1.0] = [0.0,infinity]; pow [-0.0,1.5] [-infinity,2.5] = [0.0,infinity]; pow [-0.0,1.5] [entire] = [0.0,infinity]; pow [-0.0,1.5] [-1.0,0.0] = [0X1.5555555555555P-1,infinity]; pow [-0.0,1.5] [-1.0,-0.0] = [0X1.5555555555555P-1,infinity]; pow [-0.0,1.5] [-2.5,0.0] = [0X1.7398BF1D1EE6FP-2,infinity]; pow [-0.0,1.5] [-2.5,-0.0] = [0X1.7398BF1D1EE6FP-2,infinity]; pow [-0.0,1.5] [-infinity,0.0] = [0.0,infinity]; pow [-0.0,1.5] [-infinity,-0.0] = [0.0,infinity]; pow [-0.0,1.5] [-0.1,-0.1] = [0X1.EBA7C9E4D31E9P-1,infinity]; pow [-0.0,1.5] [-1.0,-0.1] = [0X1.5555555555555P-1,infinity]; pow [-0.0,1.5] [-2.5,-0.1] = [0X1.7398BF1D1EE6FP-2,infinity]; pow [-0.0,1.5] [-infinity,-0.1] = [0.0,infinity]; pow [-0.0,1.5] [-1.0,-1.0] = [0X1.5555555555555P-1,infinity]; pow [-0.0,1.5] [-2.5,-1.0] = [0X1.7398BF1D1EE6FP-2,infinity]; pow [-0.0,1.5] [-infinity,-1.0] = [0.0,infinity]; pow [-0.0,1.5] [-2.5,-2.5] = [0X1.7398BF1D1EE6FP-2,infinity]; pow [-0.0,1.5] [-infinity,-2.5] = [0.0,infinity]; pow [-0.0,infinity] [empty] = [empty]; pow [-0.0,infinity] [0.0,0.0] = [1.0,1.0]; pow [-0.0,infinity] [-0.0,-0.0] = [1.0,1.0]; pow [-0.0,infinity] [0.0,1.0] = [0.0,infinity]; pow [-0.0,infinity] [-0.0,1.0] = [0.0,infinity]; pow [-0.0,infinity] [0.0,2.5] = [0.0,infinity]; pow [-0.0,infinity] [-0.0,2.5] = [0.0,infinity]; pow [-0.0,infinity] [0.0,infinity] = [0.0,infinity]; pow [-0.0,infinity] [-0.0,infinity] = [0.0,infinity]; pow [-0.0,infinity] [0.1,0.1] = [0.0,infinity]; pow [-0.0,infinity] [0.1,1.0] = [0.0,infinity]; pow [-0.0,infinity] [0.1,2.5] = [0.0,infinity]; pow [-0.0,infinity] [0.1,infinity] = [0.0,infinity]; pow [-0.0,infinity] [1.0,1.0] = [0.0,infinity]; pow [-0.0,infinity] [1.0,2.5] = [0.0,infinity]; pow [-0.0,infinity] [1.0,infinity] = [0.0,infinity]; pow [-0.0,infinity] [2.5,2.5] = [0.0,infinity]; pow [-0.0,infinity] [2.5,infinity] = [0.0,infinity]; pow [-0.0,infinity] [-0.1,0.1] = [0.0,infinity]; pow [-0.0,infinity] [-0.1,1.0] = [0.0,infinity]; pow [-0.0,infinity] [-0.1,2.5] = [0.0,infinity]; pow [-0.0,infinity] [-0.1,infinity] = [0.0,infinity]; pow [-0.0,infinity] [-1.0,0.1] = [0.0,infinity]; pow [-0.0,infinity] [-1.0,1.0] = [0.0,infinity]; pow [-0.0,infinity] [-1.0,2.5] = [0.0,infinity]; pow [-0.0,infinity] [-1.0,infinity] = [0.0,infinity]; pow [-0.0,infinity] [-2.5,0.1] = [0.0,infinity]; pow [-0.0,infinity] [-2.5,1.0] = [0.0,infinity]; pow [-0.0,infinity] [-2.5,2.5] = [0.0,infinity]; pow [-0.0,infinity] [-2.5,infinity] = [0.0,infinity]; pow [-0.0,infinity] [-infinity,0.1] = [0.0,infinity]; pow [-0.0,infinity] [-infinity,1.0] = [0.0,infinity]; pow [-0.0,infinity] [-infinity,2.5] = [0.0,infinity]; pow [-0.0,infinity] [entire] = [0.0,infinity]; pow [-0.0,infinity] [-1.0,0.0] = [0.0,infinity]; pow [-0.0,infinity] [-1.0,-0.0] = [0.0,infinity]; pow [-0.0,infinity] [-2.5,0.0] = [0.0,infinity]; pow [-0.0,infinity] [-2.5,-0.0] = [0.0,infinity]; pow [-0.0,infinity] [-infinity,0.0] = [0.0,infinity]; pow [-0.0,infinity] [-infinity,-0.0] = [0.0,infinity]; pow [-0.0,infinity] [-0.1,-0.1] = [0.0,infinity]; pow [-0.0,infinity] [-1.0,-0.1] = [0.0,infinity]; pow [-0.0,infinity] [-2.5,-0.1] = [0.0,infinity]; pow [-0.0,infinity] [-infinity,-0.1] = [0.0,infinity]; pow [-0.0,infinity] [-1.0,-1.0] = [0.0,infinity]; pow [-0.0,infinity] [-2.5,-1.0] = [0.0,infinity]; pow [-0.0,infinity] [-infinity,-1.0] = [0.0,infinity]; pow [-0.0,infinity] [-infinity,-2.5] = [0.0,infinity]; pow [-0.0,infinity] [-2.5,-2.5] = [0.0,infinity]; pow [-0.1,0.5] [empty] = [empty]; pow [-0.1,0.5] [0.0,0.0] = [1.0,1.0]; pow [-0.1,0.5] [-0.0,-0.0] = [1.0,1.0]; pow [-0.1,0.5] [0.0,1.0] = [0.0,1.0]; pow [-0.1,0.5] [-0.0,1.0] = [0.0,1.0]; pow [-0.1,0.5] [0.0,2.5] = [0.0,1.0]; pow [-0.1,0.5] [-0.0,2.5] = [0.0,1.0]; pow [-0.1,0.5] [0.0,infinity] = [0.0,1.0]; pow [-0.1,0.5] [-0.0,infinity] = [0.0,1.0]; pow [-0.1,0.5] [0.1,0.1] = [0.0,0X1.DDB680117AB13P-1]; pow [-0.1,0.5] [0.1,1.0] = [0.0,0X1.DDB680117AB13P-1]; pow [-0.1,0.5] [0.1,2.5] = [0.0,0X1.DDB680117AB13P-1]; pow [-0.1,0.5] [0.1,infinity] = [0.0,0X1.DDB680117AB13P-1]; pow [-0.1,0.5] [1.0,1.0] = [0.0,0.5]; pow [-0.1,0.5] [1.0,2.5] = [0.0,0.5]; pow [-0.1,0.5] [1.0,infinity] = [0.0,0.5]; pow [-0.1,0.5] [2.5,2.5] = [0.0,0X1.6A09E667F3BCDP-3]; pow [-0.1,0.5] [2.5,infinity] = [0.0,0X1.6A09E667F3BCDP-3]; pow [-0.1,0.5] [-0.1,0.1] = [0.0,infinity]; pow [-0.1,0.5] [-0.1,1.0] = [0.0,infinity]; pow [-0.1,0.5] [-0.1,2.5] = [0.0,infinity]; pow [-0.1,0.5] [-0.1,infinity] = [0.0,infinity]; pow [-0.1,0.5] [-1.0,0.1] = [0.0,infinity]; pow [-0.1,0.5] [-1.0,1.0] = [0.0,infinity]; pow [-0.1,0.5] [-1.0,2.5] = [0.0,infinity]; pow [-0.1,0.5] [-1.0,infinity] = [0.0,infinity]; pow [-0.1,0.5] [-2.5,0.1] = [0.0,infinity]; pow [-0.1,0.5] [-2.5,1.0] = [0.0,infinity]; pow [-0.1,0.5] [-2.5,2.5] = [0.0,infinity]; pow [-0.1,0.5] [-2.5,infinity] = [0.0,infinity]; pow [-0.1,0.5] [-infinity,0.1] = [0.0,infinity]; pow [-0.1,0.5] [-infinity,1.0] = [0.0,infinity]; pow [-0.1,0.5] [-infinity,2.5] = [0.0,infinity]; pow [-0.1,0.5] [entire] = [0.0,infinity]; pow [-0.1,0.5] [-1.0,0.0] = [1.0,infinity]; pow [-0.1,0.5] [-1.0,-0.0] = [1.0,infinity]; pow [-0.1,0.5] [-2.5,0.0] = [1.0,infinity]; pow [-0.1,0.5] [-2.5,-0.0] = [1.0,infinity]; pow [-0.1,0.5] [-infinity,0.0] = [1.0,infinity]; pow [-0.1,0.5] [-infinity,-0.0] = [1.0,infinity]; pow [-0.1,0.5] [-0.1,-0.1] = [0X1.125FBEE250664P+0,infinity]; pow [-0.1,0.5] [-1.0,-0.1] = [0X1.125FBEE250664P+0,infinity]; pow [-0.1,0.5] [-2.5,-0.1] = [0X1.125FBEE250664P+0,infinity]; pow [-0.1,0.5] [-infinity,-0.1] = [0X1.125FBEE250664P+0,infinity]; pow [-0.1,0.5] [-1.0,-1.0] = [0X1P+1,infinity]; pow [-0.1,0.5] [-2.5,-1.0] = [0X1P+1,infinity]; pow [-0.1,0.5] [-infinity,-1.0] = [0X1P+1,infinity]; pow [-0.1,0.5] [-2.5,-2.5] = [0X1.6A09E667F3BCCP+2,infinity]; pow [-0.1,0.5] [-infinity,-2.5] = [0X1.6A09E667F3BCCP+2,infinity]; pow [-0.1,1.0] [empty] = [empty]; pow [-0.1,1.0] [0.0,0.0] = [1.0,1.0]; pow [-0.1,1.0] [-0.0,-0.0] = [1.0,1.0]; pow [-0.1,1.0] [0.0,1.0] = [0.0,1.0]; pow [-0.1,1.0] [-0.0,1.0] = [0.0,1.0]; pow [-0.1,1.0] [0.0,2.5] = [0.0,1.0]; pow [-0.1,1.0] [-0.0,2.5] = [0.0,1.0]; pow [-0.1,1.0] [0.0,infinity] = [0.0,1.0]; pow [-0.1,1.0] [-0.0,infinity] = [0.0,1.0]; pow [-0.1,1.0] [0.1,0.1] = [0.0,1.0]; pow [-0.1,1.0] [0.1,1.0] = [0.0,1.0]; pow [-0.1,1.0] [0.1,2.5] = [0.0,1.0]; pow [-0.1,1.0] [0.1,infinity] = [0.0,1.0]; pow [-0.1,1.0] [1.0,1.0] = [0.0,1.0]; pow [-0.1,1.0] [1.0,2.5] = [0.0,1.0]; pow [-0.1,1.0] [1.0,infinity] = [0.0,1.0]; pow [-0.1,1.0] [2.5,2.5] = [0.0,1.0]; pow [-0.1,1.0] [2.5,infinity] = [0.0,1.0]; pow [-0.1,1.0] [-0.1,0.1] = [0.0,infinity]; pow [-0.1,1.0] [-0.1,1.0] = [0.0,infinity]; pow [-0.1,1.0] [-0.1,2.5] = [0.0,infinity]; pow [-0.1,1.0] [-0.1,infinity] = [0.0,infinity]; pow [-0.1,1.0] [-1.0,0.1] = [0.0,infinity]; pow [-0.1,1.0] [-1.0,1.0] = [0.0,infinity]; pow [-0.1,1.0] [-1.0,2.5] = [0.0,infinity]; pow [-0.1,1.0] [-1.0,infinity] = [0.0,infinity]; pow [-0.1,1.0] [-2.5,0.1] = [0.0,infinity]; pow [-0.1,1.0] [-2.5,1.0] = [0.0,infinity]; pow [-0.1,1.0] [-2.5,2.5] = [0.0,infinity]; pow [-0.1,1.0] [-2.5,infinity] = [0.0,infinity]; pow [-0.1,1.0] [-infinity,0.1] = [0.0,infinity]; pow [-0.1,1.0] [-infinity,1.0] = [0.0,infinity]; pow [-0.1,1.0] [-infinity,2.5] = [0.0,infinity]; pow [-0.1,1.0] [entire] = [0.0,infinity]; pow [-0.1,1.0] [-0.1,0.0] = [1.0,infinity]; pow [-0.1,1.0] [-0.1,-0.0] = [1.0,infinity]; pow [-0.1,1.0] [-1.0,0.0] = [1.0,infinity]; pow [-0.1,1.0] [-1.0,-0.0] = [1.0,infinity]; pow [-0.1,1.0] [-2.5,0.0] = [1.0,infinity]; pow [-0.1,1.0] [-2.5,-0.0] = [1.0,infinity]; pow [-0.1,1.0] [-infinity,0.0] = [1.0,infinity]; pow [-0.1,1.0] [-infinity,-0.0] = [1.0,infinity]; pow [-0.1,1.0] [-0.1,-0.1] = [1.0,infinity]; pow [-0.1,1.0] [-1.0,-0.1] = [1.0,infinity]; pow [-0.1,1.0] [-2.5,-0.1] = [1.0,infinity]; pow [-0.1,1.0] [-infinity,-0.1] = [1.0,infinity]; pow [-0.1,1.0] [-1.0,-1.0] = [1.0,infinity]; pow [-0.1,1.0] [-2.5,-1.0] = [1.0,infinity]; pow [-0.1,1.0] [-infinity,-1.0] = [1.0,infinity]; pow [-0.1,1.0] [-2.5,-2.5] = [1.0,infinity]; pow [-0.1,1.0] [-infinity,-2.5] = [1.0,infinity]; pow [-0.1,1.5] [empty] = [empty]; pow [-0.1,1.5] [0.0,0.0] = [1.0,1.0]; pow [-0.1,1.5] [-0.0,-0.0] = [1.0,1.0]; pow [-0.1,1.5] [0.0,1.0] = [0.0,1.5]; pow [-0.1,1.5] [-0.0,1.0] = [0.0,1.5]; pow [-0.1,1.5] [0.0,2.5] = [0.0,0X1.60B9FD68A4555P+1]; pow [-0.1,1.5] [-0.0,2.5] = [0.0,0X1.60B9FD68A4555P+1]; pow [-0.1,1.5] [0.0,infinity] = [0.0,infinity]; pow [-0.1,1.5] [-0.0,infinity] = [0.0,infinity]; pow [-0.1,1.5] [0.1,0.1] = [0.0,0X1.0A97DCE72A0CBP+0]; pow [-0.1,1.5] [0.1,1.0] = [0.0,1.5]; pow [-0.1,1.5] [0.1,2.5] = [0.0,0X1.60B9FD68A4555P+1]; pow [-0.1,1.5] [0.1,infinity] = [0.0,infinity]; pow [-0.1,1.5] [1.0,1.0] = [0.0,1.5]; pow [-0.1,1.5] [1.0,2.5] = [0.0,0X1.60B9FD68A4555P+1]; pow [-0.1,1.5] [1.0,infinity] = [0.0,infinity]; pow [-0.1,1.5] [2.5,2.5] = [0.0,0X1.60B9FD68A4555P+1]; pow [-0.1,1.5] [2.5,infinity] = [0.0,infinity]; pow [-0.1,1.5] [-0.1,0.1] = [0.0,infinity]; pow [-0.1,1.5] [-0.1,1.0] = [0.0,infinity]; pow [-0.1,1.5] [-0.1,2.5] = [0.0,infinity]; pow [-0.1,1.5] [-0.1,infinity] = [0.0,infinity]; pow [-0.1,1.5] [-1.0,0.1] = [0.0,infinity]; pow [-0.1,1.5] [-1.0,1.0] = [0.0,infinity]; pow [-0.1,1.5] [-1.0,2.5] = [0.0,infinity]; pow [-0.1,1.5] [-1.0,infinity] = [0.0,infinity]; pow [-0.1,1.5] [-2.5,0.1] = [0.0,infinity]; pow [-0.1,1.5] [-2.5,1.0] = [0.0,infinity]; pow [-0.1,1.5] [-2.5,2.5] = [0.0,infinity]; pow [-0.1,1.5] [-2.5,infinity] = [0.0,infinity]; pow [-0.1,1.5] [-infinity,0.1] = [0.0,infinity]; pow [-0.1,1.5] [-infinity,1.0] = [0.0,infinity]; pow [-0.1,1.5] [-infinity,2.5] = [0.0,infinity]; pow [-0.1,1.5] [entire] = [0.0,infinity]; pow [-0.1,1.5] [-1.0,0.0] = [0X1.5555555555555P-1,infinity]; pow [-0.1,1.5] [-1.0,-0.0] = [0X1.5555555555555P-1,infinity]; pow [-0.1,1.5] [-2.5,0.0] = [0X1.7398BF1D1EE6FP-2,infinity]; pow [-0.1,1.5] [-2.5,-0.0] = [0X1.7398BF1D1EE6FP-2,infinity]; pow [-0.1,1.5] [-infinity,0.0] = [0.0,infinity]; pow [-0.1,1.5] [-infinity,-0.0] = [0.0,infinity]; pow [-0.1,1.5] [-0.1,-0.1] = [0X1.EBA7C9E4D31E9P-1,infinity]; pow [-0.1,1.5] [-1.0,-0.1] = [0X1.5555555555555P-1,infinity]; pow [-0.1,1.5] [-2.5,-0.1] = [0X1.7398BF1D1EE6FP-2,infinity]; pow [-0.1,1.5] [-infinity,-0.1] = [0.0,infinity]; pow [-0.1,1.5] [-1.0,-1.0] = [0X1.5555555555555P-1,infinity]; pow [-0.1,1.5] [-2.5,-1.0] = [0X1.7398BF1D1EE6FP-2,infinity]; pow [-0.1,1.5] [-infinity,-1.0] = [0.0,infinity]; pow [-0.1,1.5] [-2.5,-2.5] = [0X1.7398BF1D1EE6FP-2,infinity]; pow [-0.1,1.5] [-infinity,-2.5] = [0.0,infinity]; pow [-0.1,infinity] [empty] = [empty]; pow [-0.1,infinity] [0.0,0.0] = [1.0,1.0]; pow [-0.1,infinity] [-0.0,-0.0] = [1.0,1.0]; pow [-0.1,infinity] [0.0,1.0] = [0.0,infinity]; pow [-0.1,infinity] [-0.0,1.0] = [0.0,infinity]; pow [-0.1,infinity] [0.0,2.5] = [0.0,infinity]; pow [-0.1,infinity] [-0.0,2.5] = [0.0,infinity]; pow [-0.1,infinity] [0.0,infinity] = [0.0,infinity]; pow [-0.1,infinity] [-0.0,infinity] = [0.0,infinity]; pow [-0.1,infinity] [0.1,0.1] = [0.0,infinity]; pow [-0.1,infinity] [0.1,1.0] = [0.0,infinity]; pow [-0.1,infinity] [0.1,2.5] = [0.0,infinity]; pow [-0.1,infinity] [0.1,infinity] = [0.0,infinity]; pow [-0.1,infinity] [1.0,1.0] = [0.0,infinity]; pow [-0.1,infinity] [1.0,2.5] = [0.0,infinity]; pow [-0.1,infinity] [1.0,infinity] = [0.0,infinity]; pow [-0.1,infinity] [2.5,2.5] = [0.0,infinity]; pow [-0.1,infinity] [2.5,infinity] = [0.0,infinity]; pow [-0.1,infinity] [-0.1,0.1] = [0.0,infinity]; pow [-0.1,infinity] [-0.1,1.0] = [0.0,infinity]; pow [-0.1,infinity] [-0.1,2.5] = [0.0,infinity]; pow [-0.1,infinity] [-0.1,infinity] = [0.0,infinity]; pow [-0.1,infinity] [-1.0,0.1] = [0.0,infinity]; pow [-0.1,infinity] [-1.0,1.0] = [0.0,infinity]; pow [-0.1,infinity] [-1.0,2.5] = [0.0,infinity]; pow [-0.1,infinity] [-1.0,infinity] = [0.0,infinity]; pow [-0.1,infinity] [-2.5,0.1] = [0.0,infinity]; pow [-0.1,infinity] [-2.5,1.0] = [0.0,infinity]; pow [-0.1,infinity] [-2.5,2.5] = [0.0,infinity]; pow [-0.1,infinity] [-2.5,infinity] = [0.0,infinity]; pow [-0.1,infinity] [-infinity,0.1] = [0.0,infinity]; pow [-0.1,infinity] [-infinity,1.0] = [0.0,infinity]; pow [-0.1,infinity] [-infinity,2.5] = [0.0,infinity]; pow [-0.1,infinity] [entire] = [0.0,infinity]; pow [-0.1,infinity] [-1.0,0.0] = [0.0,infinity]; pow [-0.1,infinity] [-1.0,-0.0] = [0.0,infinity]; pow [-0.1,infinity] [-2.5,0.0] = [0.0,infinity]; pow [-0.1,infinity] [-2.5,-0.0] = [0.0,infinity]; pow [-0.1,infinity] [-infinity,0.0] = [0.0,infinity]; pow [-0.1,infinity] [-infinity,-0.0] = [0.0,infinity]; pow [-0.1,infinity] [-0.1,-0.1] = [0.0,infinity]; pow [-0.1,infinity] [-1.0,-0.1] = [0.0,infinity]; pow [-0.1,infinity] [-2.5,-0.1] = [0.0,infinity]; pow [-0.1,infinity] [-infinity,-0.1] = [0.0,infinity]; pow [-0.1,infinity] [-1.0,-1.0] = [0.0,infinity]; pow [-0.1,infinity] [-2.5,-1.0] = [0.0,infinity]; pow [-0.1,infinity] [-infinity,-1.0] = [0.0,infinity]; pow [-0.1,infinity] [-infinity,-2.5] = [0.0,infinity]; pow [-0.1,infinity] [-2.5,-2.5] = [0.0,infinity]; pow [0.0,0.0] [empty] = [empty]; pow [0.0,0.0] [0.0,0.0] = [empty]; pow [0.0,0.0] [-0.0,-0.0] = [empty]; pow [0.0,0.0] [0.0,1.0] = [0.0,0.0]; pow [0.0,0.0] [-0.0,1.0] = [0.0,0.0]; pow [0.0,0.0] [0.0,2.5] = [0.0,0.0]; pow [0.0,0.0] [-0.0,2.5] = [0.0,0.0]; pow [0.0,0.0] [0.0,infinity] = [0.0,0.0]; pow [0.0,0.0] [-0.0,infinity] = [0.0,0.0]; pow [0.0,0.0] [0.1,0.1] = [0.0,0.0]; pow [0.0,0.0] [0.1,1.0] = [0.0,0.0]; pow [0.0,0.0] [0.1,2.5] = [0.0,0.0]; pow [0.0,0.0] [0.1,infinity] = [0.0,0.0]; pow [0.0,0.0] [1.0,1.0] = [0.0,0.0]; pow [0.0,0.0] [1.0,2.5] = [0.0,0.0]; pow [0.0,0.0] [1.0,infinity] = [0.0,0.0]; pow [0.0,0.0] [2.5,2.5] = [0.0,0.0]; pow [0.0,0.0] [2.5,infinity] = [0.0,0.0]; pow [0.0,0.0] [-0.1,0.1] = [0.0,0.0]; pow [0.0,0.0] [-0.1,1.0] = [0.0,0.0]; pow [0.0,0.0] [-0.1,2.5] = [0.0,0.0]; pow [0.0,0.0] [-0.1,infinity] = [0.0,0.0]; pow [0.0,0.0] [-1.0,0.1] = [0.0,0.0]; pow [0.0,0.0] [-1.0,1.0] = [0.0,0.0]; pow [0.0,0.0] [-1.0,2.5] = [0.0,0.0]; pow [0.0,0.0] [-1.0,infinity] = [0.0,0.0]; pow [0.0,0.0] [-2.5,0.1] = [0.0,0.0]; pow [0.0,0.0] [-2.5,1.0] = [0.0,0.0]; pow [0.0,0.0] [-2.5,2.5] = [0.0,0.0]; pow [0.0,0.0] [-2.5,infinity] = [0.0,0.0]; pow [0.0,0.0] [-infinity,0.1] = [0.0,0.0]; pow [0.0,0.0] [-infinity,1.0] = [0.0,0.0]; pow [0.0,0.0] [-infinity,2.5] = [0.0,0.0]; pow [0.0,0.0] [entire] = [0.0,0.0]; pow [0.0,0.0] [-1.0,0.0] = [empty]; pow [0.0,0.0] [-1.0,-0.0] = [empty]; pow [0.0,0.0] [-2.5,0.0] = [empty]; pow [0.0,0.0] [-2.5,-0.0] = [empty]; pow [0.0,0.0] [-infinity,0.0] = [empty]; pow [0.0,0.0] [-infinity,-0.0] = [empty]; pow [0.0,0.0] [-0.1,-0.1] = [empty]; pow [0.0,0.0] [-1.0,-0.1] = [empty]; pow [0.0,0.0] [-2.5,-0.1] = [empty]; pow [0.0,0.0] [-infinity,-0.1] = [empty]; pow [0.0,0.0] [-1.0,-1.0] = [empty]; pow [0.0,0.0] [-2.5,-1.0] = [empty]; pow [0.0,0.0] [-infinity,-1.0] = [empty]; pow [0.0,0.0] [-infinity,-2.5] = [empty]; pow [0.0,0.0] [-2.5,-2.5] = [empty]; pow [-0.0,-0.0] [empty] = [empty]; pow [-0.0,-0.0] [0.0,0.0] = [empty]; pow [-0.0,-0.0] [-0.0,-0.0] = [empty]; pow [-0.0,-0.0] [0.0,1.0] = [0.0,0.0]; pow [-0.0,-0.0] [-0.0,1.0] = [0.0,0.0]; pow [-0.0,-0.0] [0.0,2.5] = [0.0,0.0]; pow [-0.0,-0.0] [-0.0,2.5] = [0.0,0.0]; pow [-0.0,-0.0] [0.0,infinity] = [0.0,0.0]; pow [-0.0,-0.0] [-0.0,infinity] = [0.0,0.0]; pow [-0.0,-0.0] [0.1,0.1] = [0.0,0.0]; pow [-0.0,-0.0] [0.1,1.0] = [0.0,0.0]; pow [-0.0,-0.0] [0.1,2.5] = [0.0,0.0]; pow [-0.0,-0.0] [0.1,infinity] = [0.0,0.0]; pow [-0.0,-0.0] [1.0,1.0] = [0.0,0.0]; pow [-0.0,-0.0] [1.0,2.5] = [0.0,0.0]; pow [-0.0,-0.0] [1.0,infinity] = [0.0,0.0]; pow [-0.0,-0.0] [2.5,2.5] = [0.0,0.0]; pow [-0.0,-0.0] [2.5,infinity] = [0.0,0.0]; pow [-0.0,-0.0] [-0.1,0.1] = [0.0,0.0]; pow [-0.0,-0.0] [-0.1,1.0] = [0.0,0.0]; pow [-0.0,-0.0] [-0.1,2.5] = [0.0,0.0]; pow [-0.0,-0.0] [-0.1,infinity] = [0.0,0.0]; pow [-0.0,-0.0] [-1.0,0.1] = [0.0,0.0]; pow [-0.0,-0.0] [-1.0,1.0] = [0.0,0.0]; pow [-0.0,-0.0] [-1.0,2.5] = [0.0,0.0]; pow [-0.0,-0.0] [-1.0,infinity] = [0.0,0.0]; pow [-0.0,-0.0] [-2.5,0.1] = [0.0,0.0]; pow [-0.0,-0.0] [-2.5,1.0] = [0.0,0.0]; pow [-0.0,-0.0] [-2.5,2.5] = [0.0,0.0]; pow [-0.0,-0.0] [-2.5,infinity] = [0.0,0.0]; pow [-0.0,-0.0] [-infinity,0.1] = [0.0,0.0]; pow [-0.0,-0.0] [-infinity,1.0] = [0.0,0.0]; pow [-0.0,-0.0] [-infinity,2.5] = [0.0,0.0]; pow [-0.0,-0.0] [entire] = [0.0,0.0]; pow [-0.0,-0.0] [-1.0,0.0] = [empty]; pow [-0.0,-0.0] [-1.0,-0.0] = [empty]; pow [-0.0,-0.0] [-2.5,0.0] = [empty]; pow [-0.0,-0.0] [-2.5,-0.0] = [empty]; pow [-0.0,-0.0] [-infinity,0.0] = [empty]; pow [-0.0,-0.0] [-infinity,-0.0] = [empty]; pow [-0.0,-0.0] [-0.1,-0.1] = [empty]; pow [-0.0,-0.0] [-1.0,-0.1] = [empty]; pow [-0.0,-0.0] [-2.5,-0.1] = [empty]; pow [-0.0,-0.0] [-infinity,-0.1] = [empty]; pow [-0.0,-0.0] [-1.0,-1.0] = [empty]; pow [-0.0,-0.0] [-2.5,-1.0] = [empty]; pow [-0.0,-0.0] [-infinity,-1.0] = [empty]; pow [-0.0,-0.0] [-infinity,-2.5] = [empty]; pow [-0.0,-0.0] [-2.5,-2.5] = [empty]; pow [-0.0,0.0] [empty] = [empty]; pow [-0.0,0.0] [0.0,0.0] = [empty]; pow [-0.0,0.0] [-0.0,-0.0] = [empty]; pow [-0.0,0.0] [0.0,1.0] = [0.0,0.0]; pow [-0.0,0.0] [-0.0,1.0] = [0.0,0.0]; pow [-0.0,0.0] [0.0,2.5] = [0.0,0.0]; pow [-0.0,0.0] [-0.0,2.5] = [0.0,0.0]; pow [-0.0,0.0] [0.0,infinity] = [0.0,0.0]; pow [-0.0,0.0] [-0.0,infinity] = [0.0,0.0]; pow [-0.0,0.0] [0.1,0.1] = [0.0,0.0]; pow [-0.0,0.0] [0.1,1.0] = [0.0,0.0]; pow [-0.0,0.0] [0.1,2.5] = [0.0,0.0]; pow [-0.0,0.0] [0.1,infinity] = [0.0,0.0]; pow [-0.0,0.0] [1.0,1.0] = [0.0,0.0]; pow [-0.0,0.0] [1.0,2.5] = [0.0,0.0]; pow [-0.0,0.0] [1.0,infinity] = [0.0,0.0]; pow [-0.0,0.0] [2.5,2.5] = [0.0,0.0]; pow [-0.0,0.0] [2.5,infinity] = [0.0,0.0]; pow [-0.0,0.0] [-0.1,0.1] = [0.0,0.0]; pow [-0.0,0.0] [-0.1,1.0] = [0.0,0.0]; pow [-0.0,0.0] [-0.1,2.5] = [0.0,0.0]; pow [-0.0,0.0] [-0.1,infinity] = [0.0,0.0]; pow [-0.0,0.0] [-1.0,0.1] = [0.0,0.0]; pow [-0.0,0.0] [-1.0,1.0] = [0.0,0.0]; pow [-0.0,0.0] [-1.0,2.5] = [0.0,0.0]; pow [-0.0,0.0] [-1.0,infinity] = [0.0,0.0]; pow [-0.0,0.0] [-2.5,0.1] = [0.0,0.0]; pow [-0.0,0.0] [-2.5,1.0] = [0.0,0.0]; pow [-0.0,0.0] [-2.5,2.5] = [0.0,0.0]; pow [-0.0,0.0] [-2.5,infinity] = [0.0,0.0]; pow [-0.0,0.0] [-infinity,0.1] = [0.0,0.0]; pow [-0.0,0.0] [-infinity,1.0] = [0.0,0.0]; pow [-0.0,0.0] [-infinity,2.5] = [0.0,0.0]; pow [-0.0,0.0] [entire] = [0.0,0.0]; pow [-0.0,0.0] [-1.0,0.0] = [empty]; pow [-0.0,0.0] [-1.0,-0.0] = [empty]; pow [-0.0,0.0] [-2.5,0.0] = [empty]; pow [-0.0,0.0] [-2.5,-0.0] = [empty]; pow [-0.0,0.0] [-infinity,0.0] = [empty]; pow [-0.0,0.0] [-infinity,-0.0] = [empty]; pow [-0.0,0.0] [-0.1,-0.1] = [empty]; pow [-0.0,0.0] [-1.0,-0.1] = [empty]; pow [-0.0,0.0] [-2.5,-0.1] = [empty]; pow [-0.0,0.0] [-infinity,-0.1] = [empty]; pow [-0.0,0.0] [-1.0,-1.0] = [empty]; pow [-0.0,0.0] [-2.5,-1.0] = [empty]; pow [-0.0,0.0] [-infinity,-1.0] = [empty]; pow [-0.0,0.0] [-infinity,-2.5] = [empty]; pow [-0.0,0.0] [-2.5,-2.5] = [empty]; pow [0.0,-0.0] [empty] = [empty]; pow [0.0,-0.0] [0.0,0.0] = [empty]; pow [0.0,-0.0] [-0.0,-0.0] = [empty]; pow [0.0,-0.0] [0.0,1.0] = [0.0,0.0]; pow [0.0,-0.0] [-0.0,1.0] = [0.0,0.0]; pow [0.0,-0.0] [0.0,2.5] = [0.0,0.0]; pow [0.0,-0.0] [-0.0,2.5] = [0.0,0.0]; pow [0.0,-0.0] [0.0,infinity] = [0.0,0.0]; pow [0.0,-0.0] [-0.0,infinity] = [0.0,0.0]; pow [0.0,-0.0] [0.1,0.1] = [0.0,0.0]; pow [0.0,-0.0] [0.1,1.0] = [0.0,0.0]; pow [0.0,-0.0] [0.1,2.5] = [0.0,0.0]; pow [0.0,-0.0] [0.1,infinity] = [0.0,0.0]; pow [0.0,-0.0] [1.0,1.0] = [0.0,0.0]; pow [0.0,-0.0] [1.0,2.5] = [0.0,0.0]; pow [0.0,-0.0] [1.0,infinity] = [0.0,0.0]; pow [0.0,-0.0] [2.5,2.5] = [0.0,0.0]; pow [0.0,-0.0] [2.5,infinity] = [0.0,0.0]; pow [0.0,-0.0] [-0.1,0.1] = [0.0,0.0]; pow [0.0,-0.0] [-0.1,1.0] = [0.0,0.0]; pow [0.0,-0.0] [-0.1,2.5] = [0.0,0.0]; pow [0.0,-0.0] [-0.1,infinity] = [0.0,0.0]; pow [0.0,-0.0] [-1.0,0.1] = [0.0,0.0]; pow [0.0,-0.0] [-1.0,1.0] = [0.0,0.0]; pow [0.0,-0.0] [-1.0,2.5] = [0.0,0.0]; pow [0.0,-0.0] [-1.0,infinity] = [0.0,0.0]; pow [0.0,-0.0] [-2.5,0.1] = [0.0,0.0]; pow [0.0,-0.0] [-2.5,1.0] = [0.0,0.0]; pow [0.0,-0.0] [-2.5,2.5] = [0.0,0.0]; pow [0.0,-0.0] [-2.5,infinity] = [0.0,0.0]; pow [0.0,-0.0] [-infinity,0.1] = [0.0,0.0]; pow [0.0,-0.0] [-infinity,1.0] = [0.0,0.0]; pow [0.0,-0.0] [-infinity,2.5] = [0.0,0.0]; pow [0.0,-0.0] [entire] = [0.0,0.0]; pow [0.0,-0.0] [-1.0,0.0] = [empty]; pow [0.0,-0.0] [-1.0,-0.0] = [empty]; pow [0.0,-0.0] [-2.5,0.0] = [empty]; pow [0.0,-0.0] [-2.5,-0.0] = [empty]; pow [0.0,-0.0] [-infinity,0.0] = [empty]; pow [0.0,-0.0] [-infinity,-0.0] = [empty]; pow [0.0,-0.0] [-0.1,-0.1] = [empty]; pow [0.0,-0.0] [-1.0,-0.1] = [empty]; pow [0.0,-0.0] [-2.5,-0.1] = [empty]; pow [0.0,-0.0] [-infinity,-0.1] = [empty]; pow [0.0,-0.0] [-1.0,-1.0] = [empty]; pow [0.0,-0.0] [-2.5,-1.0] = [empty]; pow [0.0,-0.0] [-infinity,-1.0] = [empty]; pow [0.0,-0.0] [-infinity,-2.5] = [empty]; pow [0.0,-0.0] [-2.5,-2.5] = [empty]; pow [-1.0,0.0] [empty] = [empty]; pow [-1.0,0.0] [0.0,0.0] = [empty]; pow [-1.0,0.0] [-0.0,-0.0] = [empty]; pow [-1.0,0.0] [0.0,1.0] = [0.0,0.0]; pow [-1.0,0.0] [-0.0,1.0] = [0.0,0.0]; pow [-1.0,0.0] [0.0,2.5] = [0.0,0.0]; pow [-1.0,0.0] [-0.0,2.5] = [0.0,0.0]; pow [-1.0,0.0] [0.0,infinity] = [0.0,0.0]; pow [-1.0,0.0] [-0.0,infinity] = [0.0,0.0]; pow [-1.0,0.0] [0.1,0.1] = [0.0,0.0]; pow [-1.0,0.0] [0.1,1.0] = [0.0,0.0]; pow [-1.0,0.0] [0.1,2.5] = [0.0,0.0]; pow [-1.0,0.0] [0.1,infinity] = [0.0,0.0]; pow [-1.0,0.0] [1.0,1.0] = [0.0,0.0]; pow [-1.0,0.0] [1.0,2.5] = [0.0,0.0]; pow [-1.0,0.0] [1.0,infinity] = [0.0,0.0]; pow [-1.0,0.0] [2.5,2.5] = [0.0,0.0]; pow [-1.0,0.0] [2.5,infinity] = [0.0,0.0]; pow [-1.0,0.0] [-0.1,0.1] = [0.0,0.0]; pow [-1.0,0.0] [-0.1,1.0] = [0.0,0.0]; pow [-1.0,0.0] [-0.1,2.5] = [0.0,0.0]; pow [-1.0,0.0] [-0.1,infinity] = [0.0,0.0]; pow [-1.0,0.0] [-1.0,0.1] = [0.0,0.0]; pow [-1.0,0.0] [-1.0,1.0] = [0.0,0.0]; pow [-1.0,0.0] [-1.0,2.5] = [0.0,0.0]; pow [-1.0,0.0] [-1.0,infinity] = [0.0,0.0]; pow [-1.0,0.0] [-2.5,0.1] = [0.0,0.0]; pow [-1.0,0.0] [-2.5,1.0] = [0.0,0.0]; pow [-1.0,0.0] [-2.5,2.5] = [0.0,0.0]; pow [-1.0,0.0] [-2.5,infinity] = [0.0,0.0]; pow [-1.0,0.0] [-infinity,0.1] = [0.0,0.0]; pow [-1.0,0.0] [-infinity,1.0] = [0.0,0.0]; pow [-1.0,0.0] [-infinity,2.5] = [0.0,0.0]; pow [-1.0,0.0] [entire] = [0.0,0.0]; pow [-1.0,0.0] [-1.0,0.0] = [empty]; pow [-1.0,0.0] [-1.0,-0.0] = [empty]; pow [-1.0,0.0] [-2.5,0.0] = [empty]; pow [-1.0,0.0] [-2.5,-0.0] = [empty]; pow [-1.0,0.0] [-infinity,0.0] = [empty]; pow [-1.0,0.0] [-infinity,-0.0] = [empty]; pow [-1.0,0.0] [-0.1,-0.1] = [empty]; pow [-1.0,0.0] [-1.0,-0.1] = [empty]; pow [-1.0,0.0] [-2.5,-0.1] = [empty]; pow [-1.0,0.0] [-infinity,-0.1] = [empty]; pow [-1.0,0.0] [-1.0,-1.0] = [empty]; pow [-1.0,0.0] [-2.5,-1.0] = [empty]; pow [-1.0,0.0] [-infinity,-1.0] = [empty]; pow [-1.0,0.0] [-infinity,-2.5] = [empty]; pow [-1.0,0.0] [-2.5,-2.5] = [empty]; pow [-1.0,-0.0] [empty] = [empty]; pow [-1.0,-0.0] [0.0,0.0] = [empty]; pow [-1.0,-0.0] [-0.0,-0.0] = [empty]; pow [-1.0,-0.0] [0.0,1.0] = [0.0,0.0]; pow [-1.0,-0.0] [-0.0,1.0] = [0.0,0.0]; pow [-1.0,-0.0] [0.0,2.5] = [0.0,0.0]; pow [-1.0,-0.0] [-0.0,2.5] = [0.0,0.0]; pow [-1.0,-0.0] [0.0,infinity] = [0.0,0.0]; pow [-1.0,-0.0] [-0.0,infinity] = [0.0,0.0]; pow [-1.0,-0.0] [0.1,0.1] = [0.0,0.0]; pow [-1.0,-0.0] [0.1,1.0] = [0.0,0.0]; pow [-1.0,-0.0] [0.1,2.5] = [0.0,0.0]; pow [-1.0,-0.0] [0.1,infinity] = [0.0,0.0]; pow [-1.0,-0.0] [1.0,1.0] = [0.0,0.0]; pow [-1.0,-0.0] [1.0,2.5] = [0.0,0.0]; pow [-1.0,-0.0] [1.0,infinity] = [0.0,0.0]; pow [-1.0,-0.0] [2.5,2.5] = [0.0,0.0]; pow [-1.0,-0.0] [2.5,infinity] = [0.0,0.0]; pow [-1.0,-0.0] [-0.1,0.1] = [0.0,0.0]; pow [-1.0,-0.0] [-0.1,1.0] = [0.0,0.0]; pow [-1.0,-0.0] [-0.1,2.5] = [0.0,0.0]; pow [-1.0,-0.0] [-0.1,infinity] = [0.0,0.0]; pow [-1.0,-0.0] [-1.0,0.1] = [0.0,0.0]; pow [-1.0,-0.0] [-1.0,1.0] = [0.0,0.0]; pow [-1.0,-0.0] [-1.0,2.5] = [0.0,0.0]; pow [-1.0,-0.0] [-1.0,infinity] = [0.0,0.0]; pow [-1.0,-0.0] [-2.5,0.1] = [0.0,0.0]; pow [-1.0,-0.0] [-2.5,1.0] = [0.0,0.0]; pow [-1.0,-0.0] [-2.5,2.5] = [0.0,0.0]; pow [-1.0,-0.0] [-2.5,infinity] = [0.0,0.0]; pow [-1.0,-0.0] [-infinity,0.1] = [0.0,0.0]; pow [-1.0,-0.0] [-infinity,1.0] = [0.0,0.0]; pow [-1.0,-0.0] [-infinity,2.5] = [0.0,0.0]; pow [-1.0,-0.0] [entire] = [0.0,0.0]; pow [-1.0,-0.0] [-1.0,0.0] = [empty]; pow [-1.0,-0.0] [-1.0,-0.0] = [empty]; pow [-1.0,-0.0] [-2.5,0.0] = [empty]; pow [-1.0,-0.0] [-2.5,-0.0] = [empty]; pow [-1.0,-0.0] [-infinity,0.0] = [empty]; pow [-1.0,-0.0] [-infinity,-0.0] = [empty]; pow [-1.0,-0.0] [-0.1,-0.1] = [empty]; pow [-1.0,-0.0] [-1.0,-0.1] = [empty]; pow [-1.0,-0.0] [-2.5,-0.1] = [empty]; pow [-1.0,-0.0] [-infinity,-0.1] = [empty]; pow [-1.0,-0.0] [-1.0,-1.0] = [empty]; pow [-1.0,-0.0] [-2.5,-1.0] = [empty]; pow [-1.0,-0.0] [-infinity,-1.0] = [empty]; pow [-1.0,-0.0] [-infinity,-2.5] = [empty]; pow [-1.0,-0.0] [-2.5,-2.5] = [empty]; pow [-1.0,-0.1] [empty] = [empty]; pow [-1.0,-0.1] [0.0,0.0] = [empty]; pow [-1.0,-0.1] [-0.0,-0.0] = [empty]; pow [-1.0,-0.1] [0.0,1.0] = [empty]; pow [-1.0,-0.1] [-0.0,1.0] = [empty]; pow [-1.0,-0.1] [0.0,2.5] = [empty]; pow [-1.0,-0.1] [-0.0,2.5] = [empty]; pow [-1.0,-0.1] [0.0,infinity] = [empty]; pow [-1.0,-0.1] [-0.0,infinity] = [empty]; pow [-1.0,-0.1] [0.1,0.1] = [empty]; pow [-1.0,-0.1] [0.1,1.0] = [empty]; pow [-1.0,-0.1] [0.1,2.5] = [empty]; pow [-1.0,-0.1] [0.1,infinity] = [empty]; pow [-1.0,-0.1] [1.0,1.0] = [empty]; pow [-1.0,-0.1] [1.0,2.5] = [empty]; pow [-1.0,-0.1] [1.0,infinity] = [empty]; pow [-1.0,-0.1] [2.5,2.5] = [empty]; pow [-1.0,-0.1] [2.5,infinity] = [empty]; pow [-1.0,-0.1] [-0.1,0.1] = [empty]; pow [-1.0,-0.1] [-0.1,1.0] = [empty]; pow [-1.0,-0.1] [-0.1,2.5] = [empty]; pow [-1.0,-0.1] [-0.1,infinity] = [empty]; pow [-1.0,-0.1] [-1.0,0.1] = [empty]; pow [-1.0,-0.1] [-1.0,1.0] = [empty]; pow [-1.0,-0.1] [-1.0,2.5] = [empty]; pow [-1.0,-0.1] [-1.0,infinity] = [empty]; pow [-1.0,-0.1] [-2.5,0.1] = [empty]; pow [-1.0,-0.1] [-2.5,1.0] = [empty]; pow [-1.0,-0.1] [-2.5,2.5] = [empty]; pow [-1.0,-0.1] [-2.5,infinity] = [empty]; pow [-1.0,-0.1] [-infinity,0.1] = [empty]; pow [-1.0,-0.1] [-infinity,1.0] = [empty]; pow [-1.0,-0.1] [-infinity,2.5] = [empty]; pow [-1.0,-0.1] [entire] = [empty]; pow [-1.0,-0.1] [-1.0,0.0] = [empty]; pow [-1.0,-0.1] [-1.0,-0.0] = [empty]; pow [-1.0,-0.1] [-2.5,0.0] = [empty]; pow [-1.0,-0.1] [-2.5,-0.0] = [empty]; pow [-1.0,-0.1] [-infinity,0.0] = [empty]; pow [-1.0,-0.1] [-infinity,-0.0] = [empty]; pow [-1.0,-0.1] [-0.1,-0.1] = [empty]; pow [-1.0,-0.1] [-1.0,-0.1] = [empty]; pow [-1.0,-0.1] [-2.5,-0.1] = [empty]; pow [-1.0,-0.1] [-infinity,-0.1] = [empty]; pow [-1.0,-0.1] [-1.0,-1.0] = [empty]; pow [-1.0,-0.1] [-2.5,-1.0] = [empty]; pow [-1.0,-0.1] [-infinity,-1.0] = [empty]; pow [-1.0,-0.1] [-infinity,-2.5] = [empty]; pow [-1.0,-0.1] [-2.5,-2.5] = [empty]; } testcase minimal_pow_dec_test { pow [0.1,0.5]_com [0.0,1.0]_com = [0X1.999999999999AP-4,1.0]_com; pow [0.1,0.5]_com [0.1,0.1]_def = [0X1.96B230BCDC434P-1,0X1.DDB680117AB13P-1]_def; pow [0.1,0.5]_trv [-2.5,2.5]_dac = [0X1.9E7C6E43390B7P-9,0X1.3C3A4EDFA9758P+8]_trv; pow [0.1,0.5]_com [-2.5,infinity]_dac = [0.0,0X1.3C3A4EDFA9758P+8]_dac; pow [0.1,0.5]_trv [-infinity,0.1]_dac = [0X1.96B230BCDC434P-1,infinity]_trv; pow [0.1,1.0]_com [0.0,2.5]_com = [0X1.9E7C6E43390B7P-9,1.0]_com; pow [0.1,1.0]_def [1.0,1.0]_dac = [0X1.999999999999AP-4,1.0]_def; pow [0.1,1.0]_trv [-2.5,1.0]_def = [0X1.999999999999AP-4,0X1.3C3A4EDFA9758P+8]_trv; pow [0.5,1.5]_dac [0.1,0.1]_com = [0X1.DDB680117AB12P-1,0X1.0A97DCE72A0CBP+0]_dac; pow [0.5,1.5]_def [-2.5,0.1]_trv = [0X1.7398BF1D1EE6FP-2,0X1.6A09E667F3BCDP+2]_trv; pow [0.5,1.5]_com [-2.5,-2.5]_com = [0X1.7398BF1D1EE6FP-2,0X1.6A09E667F3BCDP+2]_com; pow [0.5,infinity]_dac [0.1,0.1]_com = [0X1.DDB680117AB12P-1,infinity]_dac; pow [0.5,infinity]_def [-2.5,-0.0]_com = [0.0,0X1.6A09E667F3BCDP+2]_def; pow [1.0,1.5]_com [-0.1,0.1]_def = [0X1.EBA7C9E4D31E9P-1,0X1.0A97DCE72A0CBP+0]_def; pow [1.0,1.5]_trv [-0.1,-0.1]_com = [0X1.EBA7C9E4D31E9P-1,1.0]_trv; pow [1.0,infinity]_dac [1.0,1.0]_dac = [1.0,infinity]_dac; pow [1.0,infinity]_def [-1.0,-0.0]_dac = [0X0P+0,1.0]_def; pow [1.1,1.5]_def [1.0,2.5]_com = [0X1.199999999999AP+0,0X1.60B9FD68A4555P+1]_def; pow [1.1,1.5]_com [-0.1,-0.1]_com = [0X1.EBA7C9E4D31E9P-1,0X1.FB24AF5281928P-1]_com; pow [1.1,infinity]_dac [0.1,infinity]_dac = [0X1.02739C65D58BFP+0,infinity]_dac; pow [1.1,infinity]_def [-2.5,infinity]_dac = [0X0P+0,infinity]_def; pow [1.1,infinity]_trv [-infinity,-1.0]_def = [0X0P+0,0X1.D1745D1745D17P-1]_trv; pow [0.0,0.5]_com [0.1,0.1]_com = [0.0,0X1.DDB680117AB13P-1]_com; pow [0.0,0.5]_com [2.5,infinity]_dac = [0.0,0X1.6A09E667F3BCDP-3]_dac; pow [0.0,0.5]_com [-infinity,-2.5]_dac = [0X1.6A09E667F3BCCP+2,infinity]_trv; pow [0.0,1.0]_com [0.0,0.0]_com = [1.0,1.0]_trv; pow [0.0,1.0]_def [0.0,2.5]_dac = [0.0,1.0]_trv; pow [0.0,1.0]_dac [1.0,2.5]_com = [0.0,1.0]_dac; pow [0.0,1.0]_com [-2.5,0.1]_dac = [0.0,infinity]_trv; pow [0.0,1.0]_def [entire]_def = [0.0,infinity]_trv; pow [0.0,1.0]_dac [-0.1,0.0]_com = [1.0,infinity]_trv; pow [0.0,1.0]_com [-infinity,0.0]_dac = [1.0,infinity]_trv; pow [0.0,1.0]_def [-infinity,-2.5]_dac = [1.0,infinity]_trv; pow [0.0,1.5]_com [0.0,2.5]_com = [0.0,0X1.60B9FD68A4555P+1]_trv; pow [0.0,1.5]_def [2.5,2.5]_dac = [0.0,0X1.60B9FD68A4555P+1]_def; pow [0.0,1.5]_dac [-1.0,0.0]_com = [0X1.5555555555555P-1,infinity]_trv; pow [0.0,1.5]_com [-2.5,-2.5]_def = [0X1.7398BF1D1EE6FP-2,infinity]_trv; pow [0.0,infinity]_dac [0.1,0.1]_com = [0.0,infinity]_dac; pow [0.0,infinity]_def [-1.0,1.0]_dac = [0.0,infinity]_trv; pow [0.0,infinity]_trv [-infinity,-1.0]_def = [0.0,infinity]_trv; pow [0.0,infinity]_dac [-2.5,-2.5]_dac = [0.0,infinity]_trv; pow [-0.0,0.5]_com [0.0,infinity]_dac = [0.0,1.0]_trv; pow [-0.0,0.5]_def [0.1,infinity]_def = [0.0,0X1.DDB680117AB13P-1]_def; pow [-0.0,0.5]_dac [2.5,2.5]_com = [0.0,0X1.6A09E667F3BCDP-3]_dac; pow [-0.0,0.5]_trv [-2.5,-0.0]_dac = [1.0,infinity]_trv; pow [-0.0,0.5]_com [-infinity,-0.1]_def = [0X1.125FBEE250664P+0,infinity]_trv; pow [-0.0,0.5]_def [-infinity,-2.5]_dac = [0X1.6A09E667F3BCCP+2,infinity]_trv; pow [-0.0,1.0]_com [2.5,2.5]_dac = [0.0,1.0]_dac; pow [-0.0,1.0]_dac [-1.0,infinity]_def = [0.0,infinity]_trv; pow [-0.0,1.0]_com [entire]_def = [0.0,infinity]_trv; pow [-0.0,1.0]_def [-2.5,-2.5]_com = [1.0,infinity]_trv; pow [-0.0,1.0]_dac [-infinity,-2.5]_def = [1.0,infinity]_trv; pow [-0.0,1.5]_com [0.1,2.5]_dac = [0.0,0X1.60B9FD68A4555P+1]_dac; pow [-0.0,1.5]_def [-1.0,0.0]_trv = [0X1.5555555555555P-1,infinity]_trv; pow [-0.0,1.5]_dac [-2.5,-0.1]_def = [0X1.7398BF1D1EE6FP-2,infinity]_trv; pow [-0.0,1.5]_com [-2.5,-2.5]_com = [0X1.7398BF1D1EE6FP-2,infinity]_trv; pow [-0.0,1.5]_def [-infinity,-2.5]_dac = [0.0,infinity]_trv; pow [-0.0,infinity]_dac [-0.1,infinity]_dac = [0.0,infinity]_trv; pow [-0.0,infinity]_def [-2.5,-0.0]_com = [0.0,infinity]_trv; pow [-0.0,infinity]_trv [-infinity,0.0]_def = [0.0,infinity]_trv; pow [-0.0,infinity]_dac [-infinity,-0.0]_trv = [0.0,infinity]_trv; pow [-0.0,infinity]_def [-infinity,-1.0]_def = [0.0,infinity]_trv; pow [-0.1,0.5]_def [0.1,infinity]_dac = [0.0,0X1.DDB680117AB13P-1]_trv; pow [-0.1,0.5]_com [-0.1,-0.1]_com = [0X1.125FBEE250664P+0,infinity]_trv; pow [-0.1,0.5]_dac [-infinity,-2.5]_def = [0X1.6A09E667F3BCCP+2,infinity]_trv; pow [-0.1,1.0]_com [0.0,0.0]_com = [1.0,1.0]_trv; pow [-0.1,1.0]_dac [-infinity,2.5]_dac = [0.0,infinity]_trv; pow [-0.1,1.0]_def [-infinity,-1.0]_def = [1.0,infinity]_trv; pow [-0.1,1.0]_com [-2.5,-2.5]_com = [1.0,infinity]_trv; pow [-0.1,1.0]_trv [-infinity,-2.5]_trv = [1.0,infinity]_trv; pow [-0.1,1.5]_trv [0.0,2.5]_com = [0.0,0X1.60B9FD68A4555P+1]_trv; pow [-0.1,1.5]_com [2.5,2.5]_dac = [0.0,0X1.60B9FD68A4555P+1]_trv; pow [-0.1,1.5]_dac [-1.0,0.0]_trv = [0X1.5555555555555P-1,infinity]_trv; pow [-0.1,1.5]_com [-0.1,-0.1]_com = [0X1.EBA7C9E4D31E9P-1,infinity]_trv; pow [-0.1,1.5]_def [-2.5,-2.5]_def = [0X1.7398BF1D1EE6FP-2,infinity]_trv; pow [-0.1,infinity]_dac [-0.1,2.5]_com = [0.0,infinity]_trv; pow [-0.1,infinity]_def [-2.5,0.0]_def = [0.0,infinity]_trv; pow [-0.1,infinity]_dac [-2.5,-2.5]_trv = [0.0,infinity]_trv; pow [0.0,0.0]_com [1.0,infinity]_dac = [0.0,0.0]_dac; pow [0.0,0.0]_com [-2.5,0.1]_com = [0.0,0.0]_trv; pow [0.0,0.0]_dac [-1.0,0.0]_def = [empty]_trv; pow [-1.0,-0.1]_com [-0.1,1.0]_def = [empty]_trv; pow [-1.0,-0.1]_dac [-0.1,2.5]_com = [empty]_trv; pow [-1.0,-0.1]_def [-0.1,infinity]_trv = [empty]_trv; } testcase minimal_exp_test { exp [empty] = [empty]; exp [-infinity,0.0] = [0.0,1.0]; exp [-infinity,-0.0] = [0.0,1.0]; exp [0.0,infinity] = [1.0,infinity]; exp [-0.0,infinity] = [1.0,infinity]; exp [entire] = [0.0,infinity]; exp [-infinity,0X1.62E42FEFA39FP+9] = [0.0,infinity]; exp [0X1.62E42FEFA39FP+9,0X1.62E42FEFA39FP+9] = [ 0X1.FFFFFFFFFFFFFP+1023,infinity]; exp [0.0,0X1.62E42FEFA39EP+9] = [1.0,0X1.FFFFFFFFFC32BP+1023]; exp [-0.0,0X1.62E42FEFA39EP+9] = [1.0,0X1.FFFFFFFFFC32BP+1023]; exp [-0X1.6232BDD7ABCD3P+9,0X1.62E42FEFA39EP+9] = [0X0.FFFFFFFFFFE7BP-1022,0X1.FFFFFFFFFC32BP+1023]; exp [-0X1.6232BDD7ABCD3P+8,0X1.62E42FEFA39EP+9] = [0X1.FFFFFFFFFFE7BP-512,0X1.FFFFFFFFFC32BP+1023]; exp [-0X1.6232BDD7ABCD3P+8,0.0] = [0X1.FFFFFFFFFFE7BP-512,1.0]; exp [-0X1.6232BDD7ABCD3P+8,-0.0] = [0X1.FFFFFFFFFFE7BP-512,1.0]; exp [-0X1.6232BDD7ABCD3P+8,1.0] = [0X1.FFFFFFFFFFE7BP-512,0X1.5BF0A8B14576AP+1]; exp [1.0,5.0] = [0X1.5BF0A8B145769P+1,0X1.28D389970339P+7]; exp [-0X1.A934F0979A372P+1,0X1.CEAECFEA8085AP+0] = [0X1.2797F0A337A5FP-5,0X1.86091CC9095C5P+2]; exp [0X1.87F42B972949CP-1,0X1.8B55484710029P+6] = [0X1.1337E9E45812AP+1, 0X1.805A5C88021B6P+142]; exp [0X1.78025C8B3FD39P+3,0X1.9FD8EEF3FA79BP+4] = [0X1.EF461A783114CP+16,0X1.691D36C6B008CP+37]; } testcase minimal_exp_dec_test { exp [0X1.62E42FEFA39FP+9,0X1.62E42FEFA39FP+9]_com = [ 0X1.FFFFFFFFFFFFFP+1023,infinity]_dac; exp [0.0,0X1.62E42FEFA39EP+9]_def = [1.0,0X1.FFFFFFFFFC32BP+1023]_def; } testcase minimal_exp2_test { exp2 [empty] = [empty]; exp2 [-infinity,0.0] = [0.0,1.0]; exp2 [-infinity,-0.0] = [0.0,1.0]; exp2 [0.0,infinity] = [1.0,infinity]; exp2 [-0.0,infinity] = [1.0,infinity]; exp2 [entire] = [0.0,infinity]; exp2 [-infinity,1024.0] = [0.0,infinity]; exp2 [1024.0,1024.0] = [0X1.FFFFFFFFFFFFFP+1023,infinity]; exp2 [0.0,1023.0] = [1.0,0X1P+1023]; exp2 [-0.0,1023.0] = [1.0,0X1P+1023]; exp2 [-1022.0,1023.0] = [0X1P-1022,0X1P+1023]; exp2 [-1022.0,0.0] = [0X1P-1022,1.0]; exp2 [-1022.0,-0.0] = [0X1P-1022,1.0]; exp2 [-1022.0,1.0] = [0X1P-1022,2.0]; exp2 [1.0,5.0] = [2.0,32.0]; exp2 [-0X1.A934F0979A372P+1,0X1.CEAECFEA8085AP+0] = [0X1.9999999999998P-4,0X1.C000000000001P+1]; exp2 [0X1.87F42B972949CP-1,0X1.8B55484710029P+6] = [0X1.B333333333332P+0,0X1.C81FD88228B4FP+98]; exp2 [0X1.78025C8B3FD39P+3,0X1.9FD8EEF3FA79BP+4] = [0X1.AEA0000721857P+11,0X1.FCA0555555559P+25]; } testcase minimal_exp2_dec_test { exp2 [1024.0,1024.0]_com = [0X1.FFFFFFFFFFFFFP+1023,infinity]_dac; exp2 [0X1.87F42B972949CP-1,0X1.8B55484710029P+6]_def = [0X1.B333333333332P+0,0X1.C81FD88228B4FP+98]_def; } testcase minimal_exp10_test { exp10 [empty] = [empty]; exp10 [-infinity,0.0] = [0.0,1.0]; exp10 [-infinity,-0.0] = [0.0,1.0]; exp10 [0.0,infinity] = [1.0,infinity]; exp10 [-0.0,infinity] = [1.0,infinity]; exp10 [entire] = [0.0,infinity]; exp10 [-infinity,0X1.34413509F79FFP+8] = [0.0,infinity]; exp10 [0X1.34413509F79FFP+8,0X1.34413509F79FFP+8] = [0X1.FFFFFFFFFFFFFP+1023,infinity]; exp10 [0.0,0X1.34413509F79FEP+8] = [1.0,0X1.FFFFFFFFFFBA1P+1023]; exp10 [-0.0,0X1.34413509F79FEP+8] = [1.0,0X1.FFFFFFFFFFBA1P+1023]; exp10 [-0X1.33A7146F72A42P+8,0X1.34413509F79FEP+8] = [0X0.FFFFFFFFFFFE3P-1022,0X1.FFFFFFFFFFBA1P+1023]; exp10 [-0X1.22P+7,0X1.34413509F79FEP+8] = [0X1.3FAAC3E3FA1F3P-482,0X1.FFFFFFFFFFBA1P+1023]; exp10 [-0X1.22P+7,0.0] = [0X1.3FAAC3E3FA1F3P-482,1.0]; exp10 [-0X1.22P+7,-0.0] = [0X1.3FAAC3E3FA1F3P-482,1.0]; exp10 [-0X1.22P+7,1.0] = [0X1.3FAAC3E3FA1F3P-482,10.0]; exp10 [1.0,5.0] = [10.0,100000.0]; exp10 [-0X1.A934F0979A372P+1,0X1.CEAECFEA8085AP+0] = [0X1.F3A8254311F9AP-12,0X1.00B18AD5B7D56P+6]; exp10 [0X1.87F42B972949CP-1,0X1.8B55484710029P+6] = [0X1.75014B7296807P+2,0X1.3EEC1D47DFB2BP+328]; exp10 [0X1.78025C8B3FD39P+3,0X1.9FD8EEF3FA79BP+4] = [0X1.0608D2279A811P+39,0X1.43AF5D4271CB8P+86]; } testcase minimal_exp10_dec_test { exp10 [0X1.34413509F79FFP+8,0X1.34413509F79FFP+8]_com = [ 0X1.FFFFFFFFFFFFFP+1023,infinity]_dac; exp10 [0X1.87F42B972949CP-1,0X1.8B55484710029P+6]_def = [0X1.75014B7296807P+2,0X1.3EEC1D47DFB2BP+328]_def; } testcase minimal_log_test { log [empty] = [empty]; log [-infinity,0.0] = [empty]; log [-infinity,-0.0] = [empty]; log [0.0,1.0] = [-infinity,0.0]; log [-0.0,1.0] = [-infinity,0.0]; log [1.0,infinity] = [0.0,infinity]; log [0.0,infinity] = [entire]; log [-0.0,infinity] = [entire]; log [entire] = [entire]; log [0.0,0x1.FFFFFFFFFFFFFp1023] = [-infinity,0X1.62E42FEFA39FP+9]; log [-0.0,0x1.FFFFFFFFFFFFFp1023] = [-infinity,0X1.62E42FEFA39FP+9]; log [1.0,0x1.FFFFFFFFFFFFFp1023] = [0.0,0X1.62E42FEFA39FP+9]; log [0x0.0000000000001p-1022,0x1.FFFFFFFFFFFFFp1023] = [-0x1.74385446D71C4p9, +0x1.62E42FEFA39Fp9]; log [0x0.0000000000001p-1022,1.0] = [-0x1.74385446D71C4p9,0.0]; log [0X1.5BF0A8B145769P+1,0X1.5BF0A8B145769P+1] = [0X1.FFFFFFFFFFFFFP-1,0X1P+0]; log [0X1.5BF0A8B14576AP+1,0X1.5BF0A8B14576AP+1] = [0X1P+0,0X1.0000000000001P+0]; log [0x0.0000000000001p-1022,0X1.5BF0A8B14576AP+1] = [-0x1.74385446D71C4p9,0X1.0000000000001P+0]; log [0X1.5BF0A8B145769P+1,32.0] = [0X1.FFFFFFFFFFFFFP-1,0X1.BB9D3BEB8C86CP+1]; log [0X1.999999999999AP-4,0X1.CP+1] = [-0X1.26BB1BBB55516P+1,0X1.40B512EB53D6P+0]; log [0X1.B333333333333P+0,0X1.C81FD88228B2FP+98] = [0X1.0FAE81914A99P-1,0X1.120627F6AE7F1P+6]; log [0X1.AEA0000721861P+11,0X1.FCA055555554CP+25] = [0X1.04A1363DB1E63P+3,0X1.203E52C0256B5P+4]; } testcase minimal_log_dec_test { log [0x0.0000000000001p-1022,0x1.FFFFFFFFFFFFFp1023]_com = [-0x1.74385446D71C4p9,0X1.62E42FEFA39FP+9]_com; log [0.0,1.0]_com = [-infinity,0.0]_trv; log [0X1.5BF0A8B14576AP+1,0X1.5BF0A8B14576AP+1]_def = [0X1P+0,0X1.0000000000001P+0]_def; } testcase minimal_log2_test { log2 [empty] = [empty]; log2 [-infinity,0.0] = [empty]; log2 [-infinity,-0.0] = [empty]; log2 [0.0,1.0] = [-infinity,0.0]; log2 [-0.0,1.0] = [-infinity,0.0]; log2 [1.0,infinity] = [0.0,infinity]; log2 [0.0,infinity] = [entire]; log2 [-0.0,infinity] = [entire]; log2 [entire] = [entire]; log2 [0.0,0x1.FFFFFFFFFFFFFp1023] = [-infinity,1024.0]; log2 [-0.0,0x1.FFFFFFFFFFFFFp1023] = [-infinity,1024.0]; log2 [1.0,0x1.FFFFFFFFFFFFFp1023] = [0.0,1024.0]; log2 [0x0.0000000000001p-1022,0x1.FFFFFFFFFFFFFp1023] = [-1074.0,1024.0]; log2 [0x0.0000000000001p-1022,1.0] = [-1074.0,0.0]; log2 [0x0.0000000000001p-1022,2.0] = [-1074.0,1.0]; log2 [2.0,32.0] = [1.0,5.0]; log2 [0X1.999999999999AP-4,0X1.CP+1] = [-0X1.A934F0979A372P+1,0X1.CEAECFEA8085AP+0]; log2 [0X1.B333333333333P+0,0X1.C81FD88228B2FP+98] = [0X1.87F42B972949CP-1,0X1.8B55484710029P+6]; log2 [0X1.AEA0000721861P+11,0X1.FCA055555554CP+25] = [0X1.78025C8B3FD39P+3,0X1.9FD8EEF3FA79BP+4]; } testcase minimal_log2_dec_test { log2 [0x0.0000000000001p-1022,0x1.FFFFFFFFFFFFFp1023]_com = [-1074.0,1024.0]_com; log2 [0x0.0000000000001p-1022,infinity]_dac = [-1074.0,infinity]_dac; log2 [2.0,32.0]_def = [1.0,5.0]_def; log2 [0.0,0x1.FFFFFFFFFFFFFp1023]_com = [-infinity,1024.0]_trv; } testcase minimal_log10_test { log10 [empty] = [empty]; log10 [-infinity,0.0] = [empty]; log10 [-infinity,-0.0] = [empty]; log10 [0.0,1.0] = [-infinity,0.0]; log10 [-0.0,1.0] = [-infinity,0.0]; log10 [1.0,infinity] = [0.0,infinity]; log10 [0.0,infinity] = [entire]; log10 [-0.0,infinity] = [entire]; log10 [entire] = [entire]; log10 [0.0,0x1.FFFFFFFFFFFFFp1023] = [-infinity,0X1.34413509F79FFP+8]; log10 [-0.0,0x1.FFFFFFFFFFFFFp1023] = [-infinity,0X1.34413509F79FFP+8]; log10 [1.0,0x1.FFFFFFFFFFFFFp1023] = [0.0,0X1.34413509F79FFP+8]; log10 [0x0.0000000000001p-1022,0x1.FFFFFFFFFFFFFp1023] = [-0x1.434E6420F4374p+8, +0x1.34413509F79FFp+8]; log10 [0x0.0000000000001p-1022,1.0] = [-0x1.434E6420F4374p+8 ,0.0]; log10 [0x0.0000000000001p-1022,10.0] = [-0x1.434E6420F4374p+8 ,1.0]; log10 [10.0,100000.0] = [1.0,5.0]; log10 [0X1.999999999999AP-4,0X1.CP+1] = [-0X1P+0,0X1.1690163290F4P-1]; log10 [0X1.999999999999AP-4,0X1.999999999999AP-4] = [-0X1P+0,-0X1.FFFFFFFFFFFFFP-1]; log10 [0X1.B333333333333P+0,0X1.C81FD88228B2FP+98] = [0X1.D7F59AA5BECB9P-3,0X1.DC074D84E5AABP+4]; log10 [0X1.AEA0000721861P+11,0X1.FCA055555554CP+25] = [0X1.C4C29DD829191P+1,0X1.F4BAEBBA4FA4P+2]; } testcase minimal_log10_dec_test { log10 [0x0.0000000000001p-1022,0x1.FFFFFFFFFFFFFp1023]_com = [-0x1.434E6420F4374p+8,0X1.34413509F79FFP+8]_com; log10 [0.0,0x1.FFFFFFFFFFFFFp1023]_dac = [-infinity,0X1.34413509F79FFP+8]_trv; } testcase minimal_sin_test { sin [empty] = [empty]; sin [0.0,infinity] = [-1.0,1.0]; sin [-0.0,infinity] = [-1.0,1.0]; sin [-infinity,0.0] = [-1.0,1.0]; sin [-infinity,-0.0] = [-1.0,1.0]; sin [entire] = [-1.0,1.0]; sin [0.0,0.0] = [0.0,0.0]; sin [-0.0,-0.0] = [0.0,0.0]; sin [0X1.921FB54442D18P+0,0X1.921FB54442D18P+0] = [0X1.FFFFFFFFFFFFFP-1,0X1P+0]; sin [0X1.921FB54442D19P+0,0X1.921FB54442D19P+0] = [0X1.FFFFFFFFFFFFFP-1,0X1P+0]; sin [0X1.921FB54442D18P+0,0X1.921FB54442D19P+0] = [0X1.FFFFFFFFFFFFFP-1,0X1P+0]; sin [0.0,0X1.921FB54442D18P+0] = [0.0,0X1P+0]; sin [-0.0,0X1.921FB54442D18P+0] = [0.0,0X1P+0]; sin [0.0,0X1.921FB54442D19P+0] = [0.0,0X1P+0]; sin [-0.0,0X1.921FB54442D19P+0] = [0.0,0X1P+0]; sin [0X1.921FB54442D18P+1,0X1.921FB54442D18P+1] = [0X1.1A62633145C06P-53,0X1.1A62633145C07P-53]; sin [0X1.921FB54442D19P+1,0X1.921FB54442D19P+1] = [-0X1.72CECE675D1FDP-52,-0X1.72CECE675D1FCP-52]; sin [0X1.921FB54442D18P+1,0X1.921FB54442D19P+1] = [-0X1.72CECE675D1FDP-52,0X1.1A62633145C07P-53]; sin [0.0,0X1.921FB54442D18P+1] = [0.0,1.0]; sin [-0.0,0X1.921FB54442D18P+1] = [0.0,1.0]; sin [0.0,0X1.921FB54442D19P+1] = [-0X1.72CECE675D1FDP-52,1.0]; sin [-0.0,0X1.921FB54442D19P+1] = [-0X1.72CECE675D1FDP-52,1.0]; sin [0X1.921FB54442D18P+0,0X1.921FB54442D18P+1] = [0X1.1A62633145C06P-53,0X1P+0]; sin [0X1.921FB54442D18P+0,0X1.921FB54442D19P+1] = [-0X1.72CECE675D1FDP-52,0X1P+0]; sin [0X1.921FB54442D19P+0,0X1.921FB54442D18P+1] = [0X1.1A62633145C06P-53,0X1P+0]; sin [0X1.921FB54442D19P+0,0X1.921FB54442D19P+1] = [-0X1.72CECE675D1FDP-52,0X1P+0]; sin [-0X1.921FB54442D18P+0,-0X1.921FB54442D18P+0] = [-0X1P+0,-0X1.FFFFFFFFFFFFFP-1]; sin [-0X1.921FB54442D19P+0,-0X1.921FB54442D19P+0] = [-0X1P+0,-0X1.FFFFFFFFFFFFFP-1]; sin [-0X1.921FB54442D19P+0,-0X1.921FB54442D18P+0] = [-0X1P+0,-0X1.FFFFFFFFFFFFFP-1]; sin [-0X1.921FB54442D18P+0,0.0] = [-0X1P+0,0.0]; sin [-0X1.921FB54442D18P+0,-0.0] = [-0X1P+0,0.0]; sin [-0X1.921FB54442D19P+0,0.0] = [-0X1P+0,0.0]; sin [-0X1.921FB54442D19P+0,-0.0] = [-0X1P+0,0.0]; sin [-0X1.921FB54442D18P+1,-0X1.921FB54442D18P+1] = [-0X1.1A62633145C07P-53,-0X1.1A62633145C06P-53]; sin [-0X1.921FB54442D19P+1,-0X1.921FB54442D19P+1] = [0X1.72CECE675D1FCP-52,0X1.72CECE675D1FDP-52]; sin [-0X1.921FB54442D19P+1,-0X1.921FB54442D18P+1] = [-0X1.1A62633145C07P-53,0X1.72CECE675D1FDP-52]; sin [-0X1.921FB54442D18P+1,0.0] = [-1.0,0.0]; sin [-0X1.921FB54442D18P+1,-0.0] = [-1.0,0.0]; sin [-0X1.921FB54442D19P+1,0.0] = [-1.0,0X1.72CECE675D1FDP-52]; sin [-0X1.921FB54442D19P+1,-0.0] = [-1.0,0X1.72CECE675D1FDP-52]; sin [-0X1.921FB54442D18P+1,-0X1.921FB54442D18P+0] = [-0X1P+0,-0X1.1A62633145C06P-53]; sin [-0X1.921FB54442D19P+1,-0X1.921FB54442D18P+0] = [-0X1P+0,0X1.72CECE675D1FDP-52]; sin [-0X1.921FB54442D18P+1,-0X1.921FB54442D19P+0] = [-0X1P+0,-0X1.1A62633145C06P-53]; sin [-0X1.921FB54442D19P+1,-0X1.921FB54442D19P+0] = [-0X1P+0,0X1.72CECE675D1FDP-52]; sin [-0X1.921FB54442D18P+0,0X1.921FB54442D18P+0] = [-0X1P+0,0X1P+0]; sin [-0X1.921FB54442D18P+0,0X1.921FB54442D19P+0] = [-0X1P+0,0X1P+0]; sin [-0X1.921FB54442D19P+0,0X1.921FB54442D18P+0] = [-0X1P+0,0X1P+0]; sin [-0X1.921FB54442D19P+0,0X1.921FB54442D19P+0] = [-0X1P+0,0X1P+0]; sin [-0.7,0.1] = [-0X1.49D6E694619B9P-1,0X1.98EAECB8BCB2DP-4]; sin [1.0,2.0] = [0X1.AED548F090CEEP-1,1.0]; sin [-3.2,-2.9] = [-0X1.E9FB8D64830E3P-3,0X1.DE33739E82D33P-5]; sin [2.0,3.0] = [0X1.210386DB6D55BP-3,0X1.D18F6EAD1B446P-1]; } testcase minimal_sin_dec_test { sin [-0X1.921FB54442D18P+1,-0X1.921FB54442D18P+0]_def = [-0X1P+0,-0X1.1A62633145C06P-53]_def; sin [-infinity,-0.0]_trv = [-1.0,1.0]_trv; sin [entire]_def = [-1.0,1.0]_def; } testcase minimal_cos_test { cos [empty] = [empty]; cos [0.0,infinity] = [-1.0,1.0]; cos [-0.0,infinity] = [-1.0,1.0]; cos [-infinity,0.0] = [-1.0,1.0]; cos [-infinity,-0.0] = [-1.0,1.0]; cos [entire] = [-1.0,1.0]; cos [0.0,0.0] = [1.0,1.0]; cos [-0.0,-0.0] = [1.0,1.0]; cos [0X1.921FB54442D18P+0,0X1.921FB54442D18P+0] = [0X1.1A62633145C06P-54,0X1.1A62633145C07P-54]; cos [0X1.921FB54442D19P+0,0X1.921FB54442D19P+0] = [-0X1.72CECE675D1FDP-53,-0X1.72CECE675D1FCP-53]; cos [0X1.921FB54442D18P+0,0X1.921FB54442D19P+0] = [-0X1.72CECE675D1FDP-53,0X1.1A62633145C07P-54]; cos [0.0,0X1.921FB54442D18P+0] = [0X1.1A62633145C06P-54,1.0]; cos [-0.0,0X1.921FB54442D18P+0] = [0X1.1A62633145C06P-54,1.0]; cos [0.0,0X1.921FB54442D19P+0] = [-0X1.72CECE675D1FDP-53,1.0]; cos [-0.0,0X1.921FB54442D19P+0] = [-0X1.72CECE675D1FDP-53,1.0]; cos [0X1.921FB54442D18P+1,0X1.921FB54442D18P+1] = [-0X1P+0,-0X1.FFFFFFFFFFFFFP-1]; cos [0X1.921FB54442D19P+1,0X1.921FB54442D19P+1] = [-0X1P+0,-0X1.FFFFFFFFFFFFFP-1]; cos [0X1.921FB54442D18P+1,0X1.921FB54442D19P+1] = [-0X1P+0,-0X1.FFFFFFFFFFFFFP-1]; cos [0.0,0X1.921FB54442D18P+1] = [-1.0,1.0]; cos [-0.0,0X1.921FB54442D18P+1] = [-1.0,1.0]; cos [0.0,0X1.921FB54442D19P+1] = [-1.0,1.0]; cos [-0.0,0X1.921FB54442D19P+1] = [-1.0,1.0]; cos [0X1.921FB54442D18P+0,0X1.921FB54442D18P+1] = [-1.0,0X1.1A62633145C07P-54]; cos [0X1.921FB54442D18P+0,0X1.921FB54442D19P+1] = [-1.0,0X1.1A62633145C07P-54]; cos [0X1.921FB54442D19P+0,0X1.921FB54442D18P+1] = [-1.0,-0X1.72CECE675D1FCP-53]; cos [0X1.921FB54442D19P+0,0X1.921FB54442D19P+1] = [-1.0,-0X1.72CECE675D1FCP-53]; cos [-0X1.921FB54442D18P+0,-0X1.921FB54442D18P+0] = [0X1.1A62633145C06P-54,0X1.1A62633145C07P-54]; cos [-0X1.921FB54442D19P+0,-0X1.921FB54442D19P+0] = [-0X1.72CECE675D1FDP-53,-0X1.72CECE675D1FCP-53]; cos [-0X1.921FB54442D19P+0,-0X1.921FB54442D18P+0] = [-0X1.72CECE675D1FDP-53,0X1.1A62633145C07P-54]; cos [-0X1.921FB54442D18P+0,0.0] = [0X1.1A62633145C06P-54,1.0]; cos [-0X1.921FB54442D18P+0,-0.0] = [0X1.1A62633145C06P-54,1.0]; cos [-0X1.921FB54442D19P+0,0.0] = [-0X1.72CECE675D1FDP-53,1.0]; cos [-0X1.921FB54442D19P+0,-0.0] = [-0X1.72CECE675D1FDP-53,1.0]; cos [-0X1.921FB54442D18P+1,-0X1.921FB54442D18P+1] = [-0X1P+0,-0X1.FFFFFFFFFFFFFP-1]; cos [-0X1.921FB54442D19P+1,-0X1.921FB54442D19P+1] = [-0X1P+0,-0X1.FFFFFFFFFFFFFP-1]; cos [-0X1.921FB54442D19P+1,-0X1.921FB54442D18P+1] = [-0X1P+0,-0X1.FFFFFFFFFFFFFP-1]; cos [-0X1.921FB54442D18P+1,0.0] = [-1.0,1.0]; cos [-0X1.921FB54442D18P+1,-0.0] = [-1.0,1.0]; cos [-0X1.921FB54442D19P+1,0.0] = [-1.0,1.0]; cos [-0X1.921FB54442D19P+1,-0.0] = [-1.0,1.0]; cos [-0X1.921FB54442D18P+1,-0X1.921FB54442D18P+0] = [-1.0,0X1.1A62633145C07P-54]; cos [-0X1.921FB54442D19P+1,-0X1.921FB54442D18P+0] = [-1.0,0X1.1A62633145C07P-54]; cos [-0X1.921FB54442D18P+1,-0X1.921FB54442D19P+0] = [-1.0,-0X1.72CECE675D1FCP-53]; cos [-0X1.921FB54442D19P+1,-0X1.921FB54442D19P+0] = [-1.0,-0X1.72CECE675D1FCP-53]; cos [-0X1.921FB54442D18P+0,0X1.921FB54442D18P+0] = [0X1.1A62633145C06P-54,1.0]; cos [-0X1.921FB54442D18P+0,0X1.921FB54442D19P+0] = [-0X1.72CECE675D1FDP-53,1.0]; cos [-0X1.921FB54442D19P+0,0X1.921FB54442D18P+0] = [-0X1.72CECE675D1FDP-53,1.0]; cos [-0X1.921FB54442D19P+0,0X1.921FB54442D19P+0] = [-0X1.72CECE675D1FDP-53,1.0]; cos [-0.7,0.1] = [0X1.87996529F9D92P-1,1.0]; cos [1.0,2.0] = [-0X1.AA22657537205P-2,0X1.14A280FB5068CP-1]; cos [-3.2,-2.9] = [-1.0,-0X1.F1216DBA340C8P-1]; cos [2.0,3.0] = [-0X1.FAE04BE85E5D3P-1,-0X1.AA22657537204P-2]; } testcase minimal_cos_dec_test { cos [-0X1.921FB54442D18P+0,-0X1.921FB54442D18P+0]_trv = [0X1.1A62633145C06P-54,0X1.1A62633145C07P-54]_trv; cos [-infinity,-0.0]_def = [-1.0,1.0]_def; cos [entire]_def = [-1.0,1.0]_def; } testcase minimal_tan_test { tan [empty] = [empty]; tan [0.0,infinity] = [entire]; tan [-0.0,infinity] = [entire]; tan [-infinity,0.0] = [entire]; tan [-infinity,-0.0] = [entire]; tan [entire] = [entire]; tan [0.0,0.0] = [0.0,0.0]; tan [-0.0,-0.0] = [0.0,0.0]; tan [0X1.921FB54442D18P+0,0X1.921FB54442D18P+0] = [0X1.D02967C31CDB4P+53,0X1.D02967C31CDB5P+53]; tan [0X1.921FB54442D19P+0,0X1.921FB54442D19P+0] = [-0X1.617A15494767BP+52,-0X1.617A15494767AP+52]; tan [0X1.921FB54442D18P+0,0X1.921FB54442D19P+0] = [entire]; tan [0X1.921FB54442D18P+1,0X1.921FB54442D18P+1] = [-0X1.1A62633145C07P-53,-0X1.1A62633145C06P-53]; tan [0X1.921FB54442D19P+1,0X1.921FB54442D19P+1] = [0X1.72CECE675D1FCP-52,0X1.72CECE675D1FDP-52]; tan [0.0,0X1.921FB54442D18P+0] = [0.0,0X1.D02967C31CDB5P+53]; tan [-0.0,0X1.921FB54442D18P+0] = [0.0,0X1.D02967C31CDB5P+53]; tan [0.0,0X1.921FB54442D19P+0] = [entire]; tan [-0.0,0X1.921FB54442D19P+0] = [entire]; tan [0.0,0X1.921FB54442D18P+1] = [entire]; tan [-0.0,0X1.921FB54442D18P+1] = [entire]; tan [0.0,0X1.921FB54442D19P+1] = [entire]; tan [-0.0,0X1.921FB54442D19P+1] = [entire]; tan [0X1P-51,0X1.921FB54442D18P+1] = [entire]; tan [0X1P-51,0X1.921FB54442D19P+1] = [entire]; tan [0X1P-52,0X1.921FB54442D18P+1] = [entire]; tan [0X1P-52,0X1.921FB54442D19P+1] = [entire]; tan [-0X1.921FB54442D18P+0,0X1.921FB54442D18P+0] = [-0X1.D02967C31CDB5P+53,0X1.D02967C31CDB5P+53]; tan [-0X1.921FB54442D18P+0,0X1.921FB54442D19P+0] = [entire]; tan [-0X1.921FB54442D19P+0,0X1.921FB54442D18P+0] = [entire]; tan [-0X1.921FB54442D19P+0,0X1.921FB54442D19P+0] = [entire]; tan [-0X1.555475A31A4BEP-2,0X1.999999999999AP-4] = [-0X1.628F4FD931FEFP-2,0X1.9AF8877430B81P-4]; tan [0X1.4E18E147AE148P+12,0X1.4E2028F5C28F6P+12] = [-0X1.D6D67B035B6B4P+2,-0X1.7E42B0760E3F3P+0]; tan [0X1.4E18E147AE148P+12,0X1.546028F5C28F6P+12] = [entire]; tan [0X1.FAE147AE147AEP-1,0X1.028F5C28F5C29P+0] = [0X1.860FADCC59064P+0,0X1.979AD0628469DP+0]; } testcase minimal_tan_dec_test { tan [empty]_trv = [empty]_trv; tan [0.0,infinity]_dac = [entire]_trv; tan [-0.0,infinity]_def = [entire]_trv; tan [-infinity,0.0]_trv = [entire]_trv; tan [-infinity,-0.0]_dac = [entire]_trv; tan [entire]_def = [entire]_trv; tan [0.0,0.0]_com = [0.0,0.0]_com; tan [-0.0,-0.0]_def = [0.0,0.0]_def; tan [0X1.921FB54442D18P+0,0X1.921FB54442D18P+0]_com = [0X1.D02967C31CDB4P+53,0X1.D02967C31CDB5P+53]_com; tan [0X1.921FB54442D19P+0,0X1.921FB54442D19P+0]_def = [-0X1.617A15494767BP+52,-0X1.617A15494767AP+52]_def; tan [0X1.921FB54442D18P+0,0X1.921FB54442D19P+0]_dac = [entire]_trv; tan [0X1.921FB54442D18P+1,0X1.921FB54442D18P+1]_trv = [-0X1.1A62633145C07P-53,-0X1.1A62633145C06P-53]_trv; tan [0X1.921FB54442D19P+1,0X1.921FB54442D19P+1]_com = [0X1.72CECE675D1FCP-52,0X1.72CECE675D1FDP-52]_com; tan [0.0,0X1.921FB54442D18P+0]_dac = [0.0,0X1.D02967C31CDB5P+53]_dac; tan [-0.0,0X1.921FB54442D18P+0]_com = [0.0,0X1.D02967C31CDB5P+53]_com; tan [0.0,0X1.921FB54442D19P+0]_trv = [entire]_trv; tan [-0.0,0X1.921FB54442D19P+0]_def = [entire]_trv; tan [0.0,0X1.921FB54442D18P+1]_dac = [entire]_trv; tan [-0.0,0X1.921FB54442D18P+1]_com = [entire]_trv; tan [0.0,0X1.921FB54442D19P+1]_trv = [entire]_trv; tan [-0.0,0X1.921FB54442D19P+1]_def = [entire]_trv; tan [0X1P-51,0X1.921FB54442D18P+1]_dac = [entire]_trv; tan [0X1P-51,0X1.921FB54442D19P+1]_com = [entire]_trv; tan [0X1P-52,0X1.921FB54442D18P+1]_trv = [entire]_trv; tan [0X1P-52,0X1.921FB54442D19P+1]_def = [entire]_trv; tan [-0X1.921FB54442D18P+0,0X1.921FB54442D18P+0]_com = [-0X1.D02967C31CDB5P+53,0X1.D02967C31CDB5P+53]_com; tan [-0X1.921FB54442D18P+0,0X1.921FB54442D19P+0]_trv = [entire]_trv; tan [-0X1.921FB54442D19P+0,0X1.921FB54442D18P+0]_def = [entire]_trv; tan [-0X1.921FB54442D19P+0,0X1.921FB54442D19P+0]_dac = [entire]_trv; tan [-0X1.555475A31A4BEP-2,0X1.999999999999AP-4]_com = [-0X1.628F4FD931FEFP-2,0X1.9AF8877430B81P-4]_com; tan [0X1.4E18E147AE148P+12,0X1.4E2028F5C28F6P+12]_dac = [-0X1.D6D67B035B6B4P+2,-0X1.7E42B0760E3F3P+0]_dac; tan [0X1.4E18E147AE148P+12,0X1.546028F5C28F6P+12]_def = [entire]_trv; tan [0X1.FAE147AE147AEP-1,0X1.028F5C28F5C29P+0]_trv = [0X1.860FADCC59064P+0,0X1.979AD0628469DP+0]_trv; } testcase minimal_asin_test { asin [empty] = [empty]; asin [0.0,infinity] = [0.0,0X1.921FB54442D19P+0]; asin [-0.0,infinity] = [0.0,0X1.921FB54442D19P+0]; asin [-infinity,0.0] = [-0X1.921FB54442D19P+0,0.0]; asin [-infinity,-0.0] = [-0X1.921FB54442D19P+0,0.0]; asin [entire] = [-0X1.921FB54442D19P+0,0X1.921FB54442D19P+0]; asin [-1.0,1.0] = [-0X1.921FB54442D19P+0,0X1.921FB54442D19P+0]; asin [-infinity,-1.0] = [-0X1.921FB54442D19P+0,-0X1.921FB54442D18P+0]; asin [1.0,infinity] = [0X1.921FB54442D18P+0,0X1.921FB54442D19P+0]; asin [-1.0,-1.0] = [-0X1.921FB54442D19P+0,-0X1.921FB54442D18P+0]; asin [1.0,1.0] = [0X1.921FB54442D18P+0,0X1.921FB54442D19P+0]; asin [0.0,0.0] = [0.0,0.0]; asin [-0.0,-0.0] = [0.0,0.0]; asin [-infinity,-0X1.0000000000001P+0] = [empty]; asin [0X1.0000000000001P+0,infinity] = [empty]; asin [-0X1.999999999999AP-4,0X1.999999999999AP-4] = [-0X1.9A49276037885P-4,0X1.9A49276037885P-4]; asin [-0X1.51EB851EB851FP-2,0X1.FFFFFFFFFFFFFP-1] = [-0X1.585FF6E341C3FP-2,0X1.921FB50442D19P+0]; asin [-0X1.FFFFFFFFFFFFFP-1,0X1.FFFFFFFFFFFFFP-1] = [-0X1.921FB50442D19P+0,0X1.921FB50442D19P+0]; } testcase minimal_asin_dec_test { asin [0.0,infinity]_dac = [0.0,0X1.921FB54442D19P+0]_trv; asin [-infinity,0.0]_def = [-0X1.921FB54442D19P+0,0.0]_trv; asin [-1.0,1.0]_com = [-0X1.921FB54442D19P+0,0X1.921FB54442D19P+0]_com; asin [entire]_def = [-0X1.921FB54442D19P+0,0X1.921FB54442D19P+0]_trv; asin [-0X1.51EB851EB851FP-2,0X1.FFFFFFFFFFFFFP-1]_def = [-0X1.585FF6E341C3FP-2,0X1.921FB50442D19P+0]_def; } testcase minimal_acos_test { acos [empty] = [empty]; acos [0.0,infinity] = [0.0,0X1.921FB54442D19P+0]; acos [-0.0,infinity] = [0.0,0X1.921FB54442D19P+0]; acos [-infinity,0.0] = [0X1.921FB54442D18P+0,0X1.921FB54442D19P+1]; acos [-infinity,-0.0] = [0X1.921FB54442D18P+0,0X1.921FB54442D19P+1]; acos [entire] = [0.0,0X1.921FB54442D19P+1]; acos [-1.0,1.0] = [0.0,0X1.921FB54442D19P+1]; acos [-infinity,-1.0] = [0X1.921FB54442D18P+1,0X1.921FB54442D19P+1]; acos [1.0,infinity] = [0.0,0.0]; acos [-1.0,-1.0] = [0X1.921FB54442D18P+1,0X1.921FB54442D19P+1]; acos [1.0,1.0] = [0.0,0.0]; acos [0.0,0.0] = [0X1.921FB54442D18P+0,0X1.921FB54442D19P+0]; acos [-0.0,-0.0] = [0X1.921FB54442D18P+0,0X1.921FB54442D19P+0]; acos [-infinity,-0X1.0000000000001P+0] = [empty]; acos [0X1.0000000000001P+0,infinity] = [empty]; acos [-0X1.999999999999AP-4,0X1.999999999999AP-4] = [0X1.787B22CE3F59P+0,0X1.ABC447BA464A1P+0]; acos [-0X1.51EB851EB851FP-2,0X1.FFFFFFFFFFFFFP-1] = [0X1P-26,0X1.E837B2FD13428P+0]; acos [-0X1.FFFFFFFFFFFFFP-1,0X1.FFFFFFFFFFFFFP-1] = [0X1P-26,0X1.921FB52442D19P+1]; } testcase minimal_acos_dec_test { acos [0.0,infinity]_dac = [0.0,0X1.921FB54442D19P+0]_trv; acos [-infinity,0.0]_def = [0X1.921FB54442D18P+0,0X1.921FB54442D19P+1]_trv; acos [-1.0,1.0]_com = [0.0,0X1.921FB54442D19P+1]_com; acos [entire]_def = [0.0,0X1.921FB54442D19P+1]_trv; acos [-0X1.51EB851EB851FP-2,0X1.FFFFFFFFFFFFFP-1]_def = [0X1P-26,0X1.E837B2FD13428P+0]_def; } testcase minimal_atan_test { atan [empty] = [empty]; atan [0.0,infinity] = [0.0,0X1.921FB54442D19P+0]; atan [-0.0,infinity] = [0.0,0X1.921FB54442D19P+0]; atan [-infinity,0.0] = [-0X1.921FB54442D19P+0,0.0]; atan [-infinity,-0.0] = [-0X1.921FB54442D19P+0,0.0]; atan [entire] = [-0X1.921FB54442D19P+0,0X1.921FB54442D19P+0]; atan [0.0,0.0] = [0.0,0.0]; atan [-0.0,-0.0] = [0.0,0.0]; atan [1.0,0X1.4C2463567C5ACP+25] = [0X1.921FB54442D18P-1,0X1.921FB4E19ABD7P+0]; atan [-0X1.FD219490EAAC1P+38,-0X1.1AF1C9D74F06DP+9] = [-0X1.921FB54440CEBP+0,-0X1.91ABE5C1E4C6DP+0]; } testcase minimal_atan_dec_test { atan [0.0,infinity]_dac = [0.0,0X1.921FB54442D19P+0]_dac; atan [-infinity,0.0]_def = [-0X1.921FB54442D19P+0,0.0]_def; atan [entire]_def = [-0X1.921FB54442D19P+0,0X1.921FB54442D19P+0]_def; atan [1.0,0X1.4C2463567C5ACP+25]_trv = [0X1.921FB54442D18P-1,0X1.921FB4E19ABD7P+0]_trv; atan [-0X1.FD219490EAAC1P+38,-0X1.1AF1C9D74F06DP+9]_com = [-0X1.921FB54440CEBP+0,-0X1.91ABE5C1E4C6DP+0]_com; } testcase minimal_atan2_test { atan2 [empty] [empty] = [empty]; atan2 [empty] [entire] = [empty]; atan2 [empty] [0.0, 0.0] = [empty]; atan2 [empty] [-0.0, 0.0] = [empty]; atan2 [empty] [0.0, -0.0] = [empty]; atan2 [empty] [-0.0, -0.0] = [empty]; atan2 [empty] [-2.0, -0.1] = [empty]; atan2 [empty] [-2.0, 0.0] = [empty]; atan2 [empty] [-2.0, -0.0] = [empty]; atan2 [empty] [-2.0, 1.0] = [empty]; atan2 [empty] [0.0, 1.0] = [empty]; atan2 [empty] [-0.0, 1.0] = [empty]; atan2 [empty] [0.1, 1.0] = [empty]; atan2 [entire] [empty] = [empty]; atan2 [entire] [entire] = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]; atan2 [entire] [0.0, 0.0] = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]; atan2 [entire] [0.0, -0.0] = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]; atan2 [entire] [-0.0, 0.0] = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]; atan2 [entire] [-0.0, -0.0] = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]; atan2 [entire] [-2.0, -0.1] = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]; atan2 [entire] [-2.0, 0.0] = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]; atan2 [entire] [-2.0, -0.0] = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]; atan2 [entire] [-2.0, 1.0] = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]; atan2 [entire] [0.0, 1.0] = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]; atan2 [entire] [-0.0, 1.0] = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]; atan2 [entire] [0.1, 1.0] = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]; atan2 [0.0, 0.0] [empty] = [empty]; atan2 [0.0, 0.0] [entire] = [0.0,0X1.921FB54442D19P+1]; atan2 [0.0, 0.0] [0.0, 0.0] = [empty]; atan2 [0.0, 0.0] [-0.0, 0.0] = [empty]; atan2 [0.0, 0.0] [0.0, -0.0] = [empty]; atan2 [0.0, 0.0] [-0.0, -0.0] = [empty]; atan2 [0.0, 0.0] [-2.0, -0.1] = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]; atan2 [0.0, 0.0] [-2.0, 0.0] = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]; atan2 [0.0, 0.0] [-2.0, -0.0] = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]; atan2 [0.0, 0.0] [-2.0, 1.0] = [0.0,0X1.921FB54442D19P+1]; atan2 [0.0, 0.0] [0.0, 1.0] = [0.0,0.0]; atan2 [0.0, 0.0] [-0.0, 1.0] = [0.0,0.0]; atan2 [0.0, 0.0] [0.1, 1.0] = [0.0,0.0]; atan2 [-0.0, 0.0] [empty] = [empty]; atan2 [-0.0, 0.0] [entire] = [0.0,0X1.921FB54442D19P+1]; atan2 [-0.0, 0.0] [0.0, 0.0] = [empty]; atan2 [-0.0, 0.0] [-0.0, 0.0] = [empty]; atan2 [-0.0, 0.0] [0.0, -0.0] = [empty]; atan2 [-0.0, 0.0] [-0.0, -0.0] = [empty]; atan2 [-0.0, 0.0] [-2.0, -0.1] = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]; atan2 [-0.0, 0.0] [-2.0, 0.0] = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]; atan2 [-0.0, 0.0] [-2.0, -0.0] = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]; atan2 [-0.0, 0.0] [-2.0, 1.0] = [0.0,0X1.921FB54442D19P+1]; atan2 [-0.0, 0.0] [0.0, 1.0] = [0.0,0.0]; atan2 [-0.0, 0.0] [-0.0, 1.0] = [0.0,0.0]; atan2 [-0.0, 0.0] [0.1, 1.0] = [0.0,0.0]; atan2 [0.0, -0.0] [empty] = [empty]; atan2 [0.0, -0.0] [entire] = [0.0,0X1.921FB54442D19P+1]; atan2 [0.0, -0.0] [0.0, 0.0] = [empty]; atan2 [0.0, -0.0] [-0.0, 0.0] = [empty]; atan2 [0.0, -0.0] [0.0, -0.0] = [empty]; atan2 [0.0, -0.0] [-0.0, -0.0] = [empty]; atan2 [0.0, -0.0] [-2.0, -0.1] = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]; atan2 [0.0, -0.0] [-2.0, 0.0] = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]; atan2 [0.0, -0.0] [-2.0, -0.0] = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]; atan2 [0.0, -0.0] [-2.0, 1.0] = [0.0,0X1.921FB54442D19P+1]; atan2 [0.0, -0.0] [0.0, 1.0] = [0.0,0.0]; atan2 [0.0, -0.0] [-0.0, 1.0] = [0.0,0.0]; atan2 [0.0, -0.0] [0.1, 1.0] = [0.0,0.0]; atan2 [-0.0, -0.0] [empty] = [empty]; atan2 [-0.0, -0.0] [entire] = [0.0,0X1.921FB54442D19P+1]; atan2 [-0.0, -0.0] [0.0, 0.0] = [empty]; atan2 [-0.0, -0.0] [-0.0, 0.0] = [empty]; atan2 [-0.0, -0.0] [0.0, -0.0] = [empty]; atan2 [-0.0, -0.0] [-0.0, -0.0] = [empty]; atan2 [-0.0, -0.0] [-2.0, -0.1] = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]; atan2 [-0.0, -0.0] [-2.0, 0.0] = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]; atan2 [-0.0, -0.0] [-2.0, -0.0] = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]; atan2 [-0.0, -0.0] [-2.0, 1.0] = [0.0,0X1.921FB54442D19P+1]; atan2 [-0.0, -0.0] [0.0, 1.0] = [0.0,0.0]; atan2 [-0.0, -0.0] [-0.0, 1.0] = [0.0,0.0]; atan2 [-0.0, -0.0] [0.1, 1.0] = [0.0,0.0]; atan2 [-2.0, -0.1] [empty] = [empty]; atan2 [-2.0, -0.1] [entire] = [-0X1.921FB54442D19P+1,0.0]; atan2 [-2.0, -0.1] [0.0, 0.0] = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]; atan2 [-2.0, -0.1] [0.0, -0.0] = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]; atan2 [-2.0, -0.1] [-0.0, 0.0] = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]; atan2 [-2.0, -0.1] [0.0, -0.0] = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]; atan2 [-2.0, -0.1] [-2.0, -0.1] = [-0X1.8BBAABDE5E29CP+1, -0X1.9EE9C8100C211P+0]; atan2 [-2.0, -0.1] [-2.0, 0.0] = [-0X1.8BBAABDE5E29CP+1, -0X1.921FB54442D18P+0]; atan2 [-2.0, -0.1] [-2.0, -0.0] = [-0X1.8BBAABDE5E29CP+1, -0X1.921FB54442D18P+0]; atan2 [-2.0, -0.1] [-2.0, 1.0] = [-0X1.8BBAABDE5E29CP+1, -0X1.983E282E2CC4CP-4]; atan2 [-2.0, -0.1] [0.0, 1.0] = [-0X1.921FB54442D19P+0, -0X1.983E282E2CC4CP-4]; atan2 [-2.0, -0.1] [-0.0, 1.0] = [-0X1.921FB54442D19P+0, -0X1.983E282E2CC4CP-4]; atan2 [-2.0, -0.1] [0.1, 1.0] = [-0X1.8555A2787982P+0, -0X1.983E282E2CC4CP-4]; atan2 [-2.0, 0.0] [empty] = [empty]; atan2 [-2.0, 0.0] [entire] = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]; atan2 [-2.0, 0.0] [0.0, 0.0] = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]; atan2 [-2.0, 0.0] [-0.0, 0.0] = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]; atan2 [-2.0, 0.0] [0.0, -0.0] = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]; atan2 [-2.0, 0.0] [-0.0, -0.0] = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]; atan2 [-2.0, 0.0] [-2.0, -0.1] = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]; atan2 [-2.0, 0.0] [-2.0, 0.0] = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]; atan2 [-2.0, 0.0] [-2.0, -0.0] = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]; atan2 [-2.0, 0.0] [-2.0, 1.0] = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]; atan2 [-2.0, 0.0] [0.0, 1.0] = [-0X1.921FB54442D19P+0, 0.0]; atan2 [-2.0, 0.0] [-0.0, 1.0] = [-0X1.921FB54442D19P+0, 0.0]; atan2 [-2.0, 0.0] [0.1, 1.0] = [-0X1.8555A2787982P+0, 0.0]; atan2 [-2.0, -0.0] [empty] = [empty]; atan2 [-2.0, -0.0] [entire] = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]; atan2 [-2.0, -0.0] [0.0, 0.0] = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]; atan2 [-2.0, -0.0] [-0.0, 0.0] = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]; atan2 [-2.0, -0.0] [0.0, -0.0] = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]; atan2 [-2.0, -0.0] [-0.0, -0.0] = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]; atan2 [-2.0, -0.0] [-2.0, -0.1] = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]; atan2 [-2.0, -0.0] [-2.0, 0.0] = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]; atan2 [-2.0, -0.0] [-2.0, -0.0] = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]; atan2 [-2.0, -0.0] [-2.0, 1.0] = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]; atan2 [-2.0, -0.0] [0.0, 1.0] = [-0X1.921FB54442D19P+0, 0.0]; atan2 [-2.0, -0.0] [-0.0, 1.0] = [-0X1.921FB54442D19P+0, 0.0]; atan2 [-2.0, -0.0] [0.1, 1.0] = [-0X1.8555A2787982P+0, 0.0]; atan2 [-2.0, 1.0] [empty] = [empty]; atan2 [-2.0, 1.0] [entire] = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]; atan2 [-2.0, 1.0] [0.0, 0.0] = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]; atan2 [-2.0, 1.0] [-0.0, 0.0] = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]; atan2 [-2.0, 1.0] [0.0, -0.0] = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]; atan2 [-2.0, 1.0] [-0.0, -0.0] = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]; atan2 [-2.0, 1.0] [-2.0, -0.1] = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]; atan2 [-2.0, 1.0] [-2.0, 0.0] = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]; atan2 [-2.0, 1.0] [-2.0, -0.0] = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]; atan2 [-2.0, 1.0] [-2.0, 1.0] = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]; atan2 [-2.0, 1.0] [0.0, 1.0] = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]; atan2 [-2.0, 1.0] [-0.0, 1.0] = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]; atan2 [-2.0, 1.0] [0.1, 1.0] = [-0X1.8555A2787982P+0, 0X1.789BD2C160054P+0]; atan2 [-0.0, 1.0] [empty] = [empty]; atan2 [-0.0, 1.0] [entire] = [0.0, 0X1.921FB54442D19P+1]; atan2 [-0.0, 1.0] [0.0, 0.0] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; atan2 [-0.0, 1.0] [-0.0, 0.0] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; atan2 [-0.0, 1.0] [0.0, -0.0] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; atan2 [-0.0, 1.0] [-0.0, -0.0] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; atan2 [-0.0, 1.0] [-2.0, -0.1] = [0X1.ABA397C7259DDP+0, 0X1.921FB54442D19P+1]; atan2 [-0.0, 1.0] [-2.0, 0.0] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+1]; atan2 [-0.0, 1.0] [-2.0, -0.0] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+1]; atan2 [-0.0, 1.0] [-2.0, 1.0] = [0.0, 0X1.921FB54442D19P+1]; atan2 [-0.0, 1.0] [0.0, 1.0] = [0.0,0X1.921FB54442D19P+0]; atan2 [-0.0, 1.0] [-0.0, 1.0] = [0.0,0X1.921FB54442D19P+0]; atan2 [-0.0, 1.0] [0.1, 1.0] = [0.0, 0X1.789BD2C160054P+0]; atan2 [0.0, 1.0] [empty] = [empty]; atan2 [0.0, 1.0] [entire] = [0.0, 0X1.921FB54442D19P+1]; atan2 [0.0, 1.0] [0.0, 0.0] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; atan2 [0.0, 1.0] [-0.0, 0.0] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; atan2 [0.0, 1.0] [0.0, -0.0] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; atan2 [0.0, 1.0] [-0.0, -0.0] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; atan2 [0.0, 1.0] [-2.0, -0.1] = [0X1.ABA397C7259DDP+0, 0X1.921FB54442D19P+1]; atan2 [0.0, 1.0] [-2.0, 0.0] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+1]; atan2 [0.0, 1.0] [-2.0, -0.0] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+1]; atan2 [0.0, 1.0] [-2.0, 1.0] = [0.0, 0X1.921FB54442D19P+1]; atan2 [0.0, 1.0] [0.0, 1.0] = [0.0,0X1.921FB54442D19P+0]; atan2 [0.0, 1.0] [-0.0, 1.0] = [0.0,0X1.921FB54442D19P+0]; atan2 [0.0, 1.0] [0.1, 1.0] = [0.0,0X1.789BD2C160054P+0]; atan2 [0.1, 1.0] [empty] = [empty]; atan2 [0.1, 1.0] [entire] = [0.0, 0X1.921FB54442D19P+1]; atan2 [0.1, 1.0] [0.0, 0.0] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; atan2 [0.1, 1.0] [-0.0, 0.0] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; atan2 [0.1, 1.0] [0.0, -0.0] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; atan2 [0.1, 1.0] [-0.0, -0.0] = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]; atan2 [0.1, 1.0] [-2.0, -0.1] = [0X1.ABA397C7259DDP+0, 0X1.8BBAABDE5E29CP+1]; atan2 [0.1, 1.0] [-2.0, 0.0] = [0X1.921FB54442D18P+0, 0X1.8BBAABDE5E29CP+1]; atan2 [0.1, 1.0] [-2.0, -0.0] = [0X1.921FB54442D18P+0, 0X1.8BBAABDE5E29CP+1]; atan2 [0.1, 1.0] [-2.0, 1.0] = [0X1.983E282E2CC4CP-4, 0X1.8BBAABDE5E29CP+1]; atan2 [0.1, 1.0] [0.0, 1.0] = [0X1.983E282E2CC4CP-4, 0X1.921FB54442D19P+0]; atan2 [0.1, 1.0] [-0.0, 1.0] = [0X1.983E282E2CC4CP-4, 0X1.921FB54442D19P+0]; atan2 [0.1, 1.0] [0.1, 1.0] = [0X1.983E282E2CC4CP-4, 0X1.789BD2C160054P+0]; } testcase minimal_atan2_dec_test { atan2 [empty]_trv [entire]_def = [empty]_trv; atan2 [empty]_trv [0.0, 0.0]_com = [empty]_trv; atan2 [empty]_trv [-0.0, 0.0]_dac = [empty]_trv; atan2 [empty]_trv [0.0, -0.0]_def = [empty]_trv; atan2 [empty]_trv [-0.0, -0.0]_trv = [empty]_trv; atan2 [empty]_trv [-2.0, -0.1]_com = [empty]_trv; atan2 [empty]_trv [-2.0, 0.0]_dac = [empty]_trv; atan2 [empty]_trv [-2.0, -0.0]_def = [empty]_trv; atan2 [empty]_trv [-2.0, 1.0]_trv = [empty]_trv; atan2 [empty]_trv [0.0, 1.0]_com = [empty]_trv; atan2 [empty]_trv [-0.0, 1.0]_dac = [empty]_trv; atan2 [empty]_trv [0.1, 1.0]_def = [empty]_trv; atan2 [entire]_def [empty]_trv = [empty]_trv; atan2 [entire]_def [entire]_def = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]_trv; atan2 [entire]_def [0.0, 0.0]_com = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]_trv; atan2 [entire]_def [0.0, -0.0]_def = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]_trv; atan2 [entire]_def [-0.0, 0.0]_dac = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]_trv; atan2 [entire]_def [-0.0, -0.0]_trv = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]_trv; atan2 [entire]_def [-2.0, -0.1]_com = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]_def; atan2 [entire]_def [-2.0, 0.0]_dac = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]_trv; atan2 [entire]_def [-2.0, -0.0]_def = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]_trv; atan2 [entire]_def [-2.0, 1.0]_trv = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]_trv; atan2 [entire]_def [0.0, 1.0]_dac = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]_trv; atan2 [entire]_def [-0.0, 1.0]_def = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]_trv; atan2 [entire]_def [0.1, 1.0]_com = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]_def; atan2 [0.0, 0.0]_com [empty]_trv = [empty]_trv; atan2 [0.0, 0.0]_dac [entire]_def = [0.0,0X1.921FB54442D19P+1]_trv; atan2 [0.0, 0.0]_def [0.0, 0.0]_trv = [empty]_trv; atan2 [0.0, 0.0]_trv [-0.0, 0.0]_dac = [empty]_trv; atan2 [0.0, 0.0]_com [0.0, -0.0]_def = [empty]_trv; atan2 [0.0, 0.0]_dac [-0.0, -0.0]_com = [empty]_trv; atan2 [0.0, 0.0]_com [-2.0, -0.1]_dac = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]_dac; atan2 [0.0, 0.0]_trv [-2.0, 0.0]_com = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]_trv; atan2 [0.0, 0.0]_com [-2.0, -0.0]_trv = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]_trv; atan2 [0.0, 0.0]_dac [-2.0, 1.0]_def = [0.0,0X1.921FB54442D19P+1]_trv; atan2 [0.0, 0.0]_def [0.0, 1.0]_com = [0.0,0.0]_trv; atan2 [0.0, 0.0]_trv [-0.0, 1.0]_dac = [0.0,0.0]_trv; atan2 [0.0, 0.0]_com [0.1, 1.0]_com = [0.0,0.0]_com; atan2 [-0.0, 0.0]_com [empty]_trv = [empty]_trv; atan2 [-0.0, 0.0]_dac [entire]_def = [0.0,0X1.921FB54442D19P+1]_trv; atan2 [-0.0, 0.0]_def [0.0, 0.0]_com = [empty]_trv; atan2 [-0.0, 0.0]_trv [-0.0, 0.0]_trv = [empty]_trv; atan2 [-0.0, 0.0]_com [0.0, -0.0]_def = [empty]_trv; atan2 [-0.0, 0.0]_dac [-0.0, -0.0]_com = [empty]_trv; atan2 [-0.0, 0.0]_dac [-2.0, -0.1]_dac = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]_dac; atan2 [-0.0, 0.0]_trv [-2.0, 0.0]_com = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]_trv; atan2 [-0.0, 0.0]_com [-2.0, -0.0]_trv = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]_trv; atan2 [-0.0, 0.0]_dac [-2.0, 1.0]_def = [0.0,0X1.921FB54442D19P+1]_trv; atan2 [-0.0, 0.0]_com [0.0, 1.0]_com = [0.0,0.0]_trv; atan2 [-0.0, 0.0]_def [-0.0, 1.0]_dac = [0.0,0.0]_trv; atan2 [-0.0, 0.0]_com [0.1, 1.0]_com = [0.0,0.0]_com; atan2 [0.0, -0.0]_com [empty]_trv = [empty]_trv; atan2 [0.0, -0.0]_dac [entire]_def = [0.0,0X1.921FB54442D19P+1]_trv; atan2 [0.0, -0.0]_def [0.0, 0.0]_dac = [empty]_trv; atan2 [0.0, -0.0]_trv [-0.0, 0.0]_com = [empty]_trv; atan2 [0.0, -0.0]_dac [0.0, -0.0]_def = [empty]_trv; atan2 [0.0, -0.0]_com [-0.0, -0.0]_trv = [empty]_trv; atan2 [0.0, -0.0]_com [-2.0, -0.1]_dac = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]_dac; atan2 [0.0, -0.0]_def [-2.0, 0.0]_com = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]_trv; atan2 [0.0, -0.0]_com [-2.0, -0.0]_dac = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]_trv; atan2 [0.0, -0.0]_dac [-2.0, 1.0]_com = [0.0,0X1.921FB54442D19P+1]_trv; atan2 [0.0, -0.0]_com [0.0, 1.0]_trv = [0.0,0.0]_trv; atan2 [0.0, -0.0]_def [-0.0, 1.0]_com = [0.0,0.0]_trv; atan2 [0.0, -0.0]_com [0.1, 1.0]_def = [0.0,0.0]_def; atan2 [-0.0, -0.0]_com [empty]_trv = [empty]_trv; atan2 [-0.0, -0.0]_def [entire]_def = [0.0,0X1.921FB54442D19P+1]_trv; atan2 [-0.0, -0.0]_dac [0.0, 0.0]_com = [empty]_trv; atan2 [-0.0, -0.0]_trv [-0.0, 0.0]_def = [empty]_trv; atan2 [-0.0, -0.0]_com [0.0, -0.0]_trv = [empty]_trv; atan2 [-0.0, -0.0]_dac [-0.0, -0.0]_com = [empty]_trv; atan2 [-0.0, -0.0]_def [-2.0, -0.1]_dac = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]_def; atan2 [-0.0, -0.0]_trv [-2.0, 0.0]_def = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]_trv; atan2 [-0.0, -0.0]_dac [-2.0, -0.0]_trv = [0X1.921FB54442D18P+1, 0X1.921FB54442D19P+1]_trv; atan2 [-0.0, -0.0]_def [-2.0, 1.0]_com = [0.0,0X1.921FB54442D19P+1]_trv; atan2 [-0.0, -0.0]_com [0.0, 1.0]_com = [0.0,0.0]_trv; atan2 [-0.0, -0.0]_trv [-0.0, 1.0]_dac = [0.0,0.0]_trv; atan2 [-0.0, -0.0]_com [0.1, 1.0]_com = [0.0,0.0]_com; atan2 [-2.0, -0.1]_dac [empty]_trv = [empty]_trv; atan2 [-2.0, -0.1]_def [entire]_def = [-0X1.921FB54442D19P+1,0.0]_def; atan2 [-2.0, -0.1]_trv [0.0, 0.0]_com = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]_trv; atan2 [-2.0, -0.1]_com [0.0, -0.0]_dac = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]_dac; atan2 [-2.0, -0.1]_dac [-0.0, 0.0]_def = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]_def; atan2 [-2.0, -0.1]_com [0.0, -0.0]_trv = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]_trv; atan2 [-2.0, -0.1]_def [-2.0, -0.1]_com = [-0X1.8BBAABDE5E29CP+1, -0X1.9EE9C8100C211P+0]_def; atan2 [-2.0, -0.1]_com [-2.0, 0.0]_def = [-0X1.8BBAABDE5E29CP+1, -0X1.921FB54442D18P+0]_def; atan2 [-2.0, -0.1]_trv [-2.0, -0.0]_dac = [-0X1.8BBAABDE5E29CP+1, -0X1.921FB54442D18P+0]_trv; atan2 [-2.0, -0.1]_def [-2.0, 1.0]_trv = [-0X1.8BBAABDE5E29CP+1, -0X1.983E282E2CC4CP-4]_trv; atan2 [-2.0, -0.1]_com [0.0, 1.0]_def = [-0X1.921FB54442D19P+0, -0X1.983E282E2CC4CP-4]_def; atan2 [-2.0, -0.1]_dac [-0.0, 1.0]_com = [-0X1.921FB54442D19P+0, -0X1.983E282E2CC4CP-4]_dac; atan2 [-2.0, -0.1]_com [0.1, 1.0]_com = [-0X1.8555A2787982P+0, -0X1.983E282E2CC4CP-4]_com; atan2 [-2.0, 0.0]_def [empty]_trv = [empty]_trv; atan2 [-2.0, 0.0]_def [entire]_def = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]_trv; atan2 [-2.0, 0.0]_dac [0.0, 0.0]_dac = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]_trv; atan2 [-2.0, 0.0]_trv [-0.0, 0.0]_com = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]_trv; atan2 [-2.0, 0.0]_com [0.0, -0.0]_trv = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]_trv; atan2 [-2.0, 0.0]_def [-0.0, -0.0]_def = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]_trv; atan2 [-2.0, 0.0]_com [-2.0, -0.1]_dac = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]_def; atan2 [-2.0, 0.0]_dac [-2.0, 0.0]_com = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]_trv; atan2 [-2.0, 0.0]_com [-2.0, -0.0]_dac = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]_trv; atan2 [-2.0, 0.0]_trv [-2.0, 1.0]_com = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]_trv; atan2 [-2.0, 0.0]_def [0.0, 1.0]_def = [-0X1.921FB54442D19P+0, 0.0]_trv; atan2 [-2.0, 0.0]_com [-0.0, 1.0]_dac = [-0X1.921FB54442D19P+0, 0.0]_trv; atan2 [-2.0, 0.0]_com [0.1, 1.0]_com = [-0X1.8555A2787982P+0, 0.0]_com; atan2 [-2.0, -0.0]_trv [empty]_trv = [empty]_trv; atan2 [-2.0, -0.0]_dac [entire]_def = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]_trv; atan2 [-2.0, -0.0]_com [0.0, 0.0]_com = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]_trv; atan2 [-2.0, -0.0]_def [-0.0, 0.0]_dac = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]_trv; atan2 [-2.0, -0.0]_dac [0.0, -0.0]_def = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]_trv; atan2 [-2.0, -0.0]_com [-0.0, -0.0]_trv = [-0X1.921FB54442D19P+0, -0X1.921FB54442D18P+0]_trv; atan2 [-2.0, -0.0]_def [-2.0, -0.1]_com = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]_def; atan2 [-2.0, -0.0]_com [-2.0, 0.0]_dac = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]_trv; atan2 [-2.0, -0.0]_dac [-2.0, -0.0]_def = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]_trv; atan2 [-2.0, -0.0]_def [-2.0, 1.0]_trv = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]_trv; atan2 [-2.0, -0.0]_trv [0.0, 1.0]_dac = [-0X1.921FB54442D19P+0, 0.0]_trv; atan2 [-2.0, -0.0]_com [-0.0, 1.0]_com = [-0X1.921FB54442D19P+0, 0.0]_trv; atan2 [-2.0, -0.0]_com [0.1, 1.0]_com = [-0X1.8555A2787982P+0, 0.0]_com; atan2 [-2.0, 1.0]_def [empty]_trv = [empty]_trv; atan2 [-2.0, 1.0]_dac [entire]_def = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]_trv; atan2 [-2.0, 1.0]_def [0.0, 0.0]_def = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]_trv; atan2 [-2.0, 1.0]_com [-0.0, 0.0]_dac = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]_trv; atan2 [-2.0, 1.0]_trv [0.0, -0.0]_trv = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]_trv; atan2 [-2.0, 1.0]_com [-0.0, -0.0]_com = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]_trv; atan2 [-2.0, 1.0]_dac [-2.0, -0.1]_dac = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]_def; atan2 [-2.0, 1.0]_def [-2.0, 0.0]_def = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]_trv; atan2 [-2.0, 1.0]_trv [-2.0, -0.0]_trv = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]_trv; atan2 [-2.0, 1.0]_dac [-2.0, 1.0]_com = [-0X1.921FB54442D19P+1, 0X1.921FB54442D19P+1]_trv; atan2 [-2.0, 1.0]_com [0.0, 1.0]_dac = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]_trv; atan2 [-2.0, 1.0]_trv [-0.0, 1.0]_dac = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]_trv; atan2 [-2.0, 1.0]_com [0.1, 1.0]_com = [-0X1.8555A2787982P+0, 0X1.789BD2C160054P+0]_com; atan2 [-0.0, 1.0]_com [empty]_trv = [empty]_trv; atan2 [-0.0, 1.0]_dac [entire]_def = [0.0, 0X1.921FB54442D19P+1]_trv; atan2 [-0.0, 1.0]_def [0.0, 0.0]_def = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]_trv; atan2 [-0.0, 1.0]_trv [-0.0, 0.0]_trv = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]_trv; atan2 [-0.0, 1.0]_dac [0.0, -0.0]_dac = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]_trv; atan2 [-0.0, 1.0]_com [-0.0, -0.0]_def = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]_trv; atan2 [-0.0, 1.0]_com [-2.0, -0.1]_com = [0X1.ABA397C7259DDP+0, 0X1.921FB54442D19P+1]_dac; atan2 [-0.0, 1.0]_def [-2.0, 0.0]_com = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+1]_trv; atan2 [-0.0, 1.0]_def [-2.0, -0.0]_def = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+1]_trv; atan2 [-0.0, 1.0]_dac [-2.0, 1.0]_dac = [0.0, 0X1.921FB54442D19P+1]_trv; atan2 [-0.0, 1.0]_dac [0.0, 1.0]_dac = [0.0,0X1.921FB54442D19P+0]_trv; atan2 [-0.0, 1.0]_trv [-0.0, 1.0]_com = [0.0,0X1.921FB54442D19P+0]_trv; atan2 [-0.0, 1.0]_trv [0.1, 1.0]_com = [0.0, 0X1.789BD2C160054P+0]_trv; atan2 [0.0, 1.0]_def [empty]_trv = [empty]_trv; atan2 [0.0, 1.0]_dac [entire]_def = [0.0, 0X1.921FB54442D19P+1]_trv; atan2 [0.0, 1.0]_dac [0.0, 0.0]_def = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]_trv; atan2 [0.0, 1.0]_trv [-0.0, 0.0]_trv = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]_trv; atan2 [0.0, 1.0]_trv [0.0, -0.0]_dac = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]_trv; atan2 [0.0, 1.0]_def [-0.0, -0.0]_com = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]_trv; atan2 [0.0, 1.0]_dac [-2.0, -0.1]_dac = [0X1.ABA397C7259DDP+0, 0X1.921FB54442D19P+1]_dac; atan2 [0.0, 1.0]_def [-2.0, 0.0]_trv = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+1]_trv; atan2 [0.0, 1.0]_dac [-2.0, -0.0]_dac = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+1]_trv; atan2 [0.0, 1.0]_dac [-2.0, 1.0]_def = [0.0, 0X1.921FB54442D19P+1]_trv; atan2 [0.0, 1.0]_dac [0.0, 1.0]_trv = [0.0,0X1.921FB54442D19P+0]_trv; atan2 [0.0, 1.0]_dac [-0.0, 1.0]_def = [0.0,0X1.921FB54442D19P+0]_trv; atan2 [0.0, 1.0]_com [0.1, 1.0]_com = [0.0,0X1.789BD2C160054P+0]_com; atan2 [0.1, 1.0]_dac [empty]_trv = [empty]_trv; atan2 [0.1, 1.0]_dac [entire]_def = [0.0, 0X1.921FB54442D19P+1]_def; atan2 [0.1, 1.0]_def [0.0, 0.0]_com = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]_def; atan2 [0.1, 1.0]_trv [-0.0, 0.0]_def = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]_trv; atan2 [0.1, 1.0]_trv [0.0, -0.0]_def = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]_trv; atan2 [0.1, 1.0]_dac [-0.0, -0.0]_def = [0X1.921FB54442D18P+0, 0X1.921FB54442D19P+0]_def; atan2 [0.1, 1.0]_com [-2.0, -0.1]_trv = [0X1.ABA397C7259DDP+0, 0X1.8BBAABDE5E29CP+1]_trv; atan2 [0.1, 1.0]_com [-2.0, 0.0]_dac = [0X1.921FB54442D18P+0, 0X1.8BBAABDE5E29CP+1]_dac; atan2 [0.1, 1.0]_com [-2.0, -0.0]_dac = [0X1.921FB54442D18P+0, 0X1.8BBAABDE5E29CP+1]_dac; atan2 [0.1, 1.0]_def [-2.0, 1.0]_dac = [0X1.983E282E2CC4CP-4, 0X1.8BBAABDE5E29CP+1]_def; atan2 [0.1, 1.0]_def [0.0, 1.0]_def = [0X1.983E282E2CC4CP-4, 0X1.921FB54442D19P+0]_def; atan2 [0.1, 1.0]_dac [-0.0, 1.0]_def = [0X1.983E282E2CC4CP-4, 0X1.921FB54442D19P+0]_def; atan2 [0.1, 1.0]_dac [0.1, 1.0]_def = [0X1.983E282E2CC4CP-4, 0X1.789BD2C160054P+0]_def; } testcase minimal_sinh_test { sinh [empty] = [empty]; sinh [0.0,infinity] = [0.0,infinity]; sinh [-0.0,infinity] = [0.0,infinity]; sinh [-infinity,0.0] = [-infinity,0.0]; sinh [-infinity,-0.0] = [-infinity,0.0]; sinh [entire] = [entire]; sinh [0.0,0.0] = [0.0,0.0]; sinh [-0.0,-0.0] = [0.0,0.0]; sinh [1.0,0X1.2C903022DD7AAP+8] = [0X1.2CD9FC44EB982P+0,0X1.89BCA168970C6P+432]; sinh [-0X1.FD219490EAAC1P+38,-0X1.1AF1C9D74F06DP+9] = [-infinity,-0X1.53045B4F849DEP+815]; sinh [-0X1.199999999999AP+0,0X1.2666666666666P+1] = [-0X1.55ECFE1B2B215P+0,0X1.3BF72EA61AF1BP+2]; } testcase minimal_sinh_dec_test { sinh [entire]_def = [entire]_def; sinh [0.0,infinity]_dac = [0.0,infinity]_dac; sinh [-infinity,0.0]_def = [-infinity,0.0]_def; sinh [1.0,0X1.2C903022DD7AAP+8]_com = [0X1.2CD9FC44EB982P+0,0X1.89BCA168970C6P+432]_com; sinh [-0X1.FD219490EAAC1P+38,-0X1.1AF1C9D74F06DP+9]_com = [-infinity,-0X1.53045B4F849DEP+815]_dac; } testcase minimal_cosh_test { cosh [empty] = [empty]; cosh [0.0,infinity] = [1.0,infinity]; cosh [-0.0,infinity] = [1.0,infinity]; cosh [-infinity,0.0] = [1.0,infinity]; cosh [-infinity,-0.0] = [1.0,infinity]; cosh [entire] = [1.0,infinity]; cosh [0.0,0.0] = [1.0,1.0]; cosh [-0.0,-0.0] = [1.0,1.0]; cosh [1.0,0X1.2C903022DD7AAP+8] = [0X1.8B07551D9F55P+0,0X1.89BCA168970C6P+432]; cosh [-0X1.FD219490EAAC1P+38,-0X1.1AF1C9D74F06DP+9] = [0X1.53045B4F849DEP+815,infinity]; cosh [-0X1.199999999999AP+0,0X1.2666666666666P+1] = [1.0,0X1.4261D2B7D6181P+2]; } testcase minimal_cosh_dec_test { cosh [0.0,infinity]_dac = [1.0,infinity]_dac; cosh [-infinity,0.0]_def = [1.0,infinity]_def; cosh [entire]_def = [1.0,infinity]_def; cosh [1.0,0X1.2C903022DD7AAP+8]_def = [0X1.8B07551D9F55P+0,0X1.89BCA168970C6P+432]_def; cosh [-0X1.FD219490EAAC1P+38,-0X1.1AF1C9D74F06DP+9]_com = [0X1.53045B4F849DEP+815,infinity]_dac; } testcase minimal_tanh_test { tanh [empty] = [empty]; tanh [0.0,infinity] = [0.0,1.0]; tanh [-0.0,infinity] = [0.0,1.0]; tanh [-infinity,0.0] = [-1.0,0.0]; tanh [-infinity,-0.0] = [-1.0,0.0]; tanh [entire] = [-1.0,1.0]; tanh [0.0,0.0] = [0.0,0.0]; tanh [-0.0,-0.0] = [0.0,0.0]; tanh [1.0,0X1.2C903022DD7AAP+8] = [0X1.85EFAB514F394P-1,0X1P+0]; tanh [-0X1.FD219490EAAC1P+38,-0X1.1AF1C9D74F06DP+9] = [-0X1P+0,-0X1.FFFFFFFFFFFFFP-1]; tanh [-0X1.199999999999AP+0,0X1.2666666666666P+1] = [-0X1.99DB01FDE2406P-1,0X1.F5CF31E1C8103P-1]; } testcase minimal_tanh_dec_test { tanh [0.0,infinity]_dac = [0.0,1.0]_dac; tanh [-infinity,0.0]_def = [-1.0,0.0]_def; tanh [entire]_def = [-1.0,1.0]_def; tanh [1.0,0X1.2C903022DD7AAP+8]_com = [0X1.85EFAB514F394P-1,0X1P+0]_com; tanh [-0X1.FD219490EAAC1P+38,-0X1.1AF1C9D74F06DP+9]_trv = [-0X1P+0,-0X1.FFFFFFFFFFFFFP-1]_trv; } testcase minimal_asinh_test { asinh [empty] = [empty]; asinh [0.0,infinity] = [0.0,infinity]; asinh [-0.0,infinity] = [0.0,infinity]; asinh [-infinity,0.0] = [-infinity,0.0]; asinh [-infinity,-0.0] = [-infinity,0.0]; asinh [entire] = [entire]; asinh [0.0,0.0] = [0.0,0.0]; asinh [-0.0,-0.0] = [0.0,0.0]; asinh [1.0,0X1.2C903022DD7AAP+8] = [0X1.C34366179D426P-1,0X1.9986127438A87P+2]; asinh [-0X1.FD219490EAAC1P+38,-0X1.1AF1C9D74F06DP+9] = [-0X1.BB86380A6CC45P+4,-0X1.C204D8EB20827P+2]; asinh [-0X1.199999999999AP+0,0X1.2666666666666P+1] = [-0X1.E693DF6EDF1E7P-1,0X1.91FDC64DE0E51P+0]; } testcase minimal_asinh_dec_test { asinh [0.0,infinity]_dac = [0.0,infinity]_dac; asinh [-infinity,0.0]_trv = [-infinity,0.0]_trv; asinh [entire]_def = [entire]_def; asinh [1.0,0X1.2C903022DD7AAP+8]_com = [0X1.C34366179D426P-1,0X1.9986127438A87P+2]_com; asinh [-0X1.FD219490EAAC1P+38,-0X1.1AF1C9D74F06DP+9]_def = [-0X1.BB86380A6CC45P+4,-0X1.C204D8EB20827P+2]_def; } testcase minimal_acosh_test { acosh [empty] = [empty]; acosh [0.0,infinity] = [0.0,infinity]; acosh [-0.0,infinity] = [0.0,infinity]; acosh [1.0,infinity] = [0.0,infinity]; acosh [-infinity,1.0] = [0.0,0.0]; acosh [-infinity,0X1.FFFFFFFFFFFFFP-1] = [empty]; acosh [entire] = [0.0,infinity]; acosh [1.0,1.0] = [0.0,0.0]; acosh [1.0,0X1.2C903022DD7AAP+8] = [0.0,0X1.9985FB3D532AFP+2]; acosh [0X1.199999999999AP+0,0X1.2666666666666P+1] = [0X1.C636C1A882F2CP-2,0X1.799C88E79140DP+0]; acosh [0X1.14D4E82B2B26FP+15,0X1.72DBE91C837B5P+29] = [0X1.656510B4BAEC3P+3,0X1.52A415EE8455AP+4]; } testcase minimal_acosh_dec_test { acosh [0.0,infinity]_dac = [0.0,infinity]_trv; acosh [1.0,infinity]_dac = [0.0,infinity]_dac; acosh [entire]_def = [0.0,infinity]_trv; acosh [1.0,1.0]_com = [0.0,0.0]_com; acosh [0.9,1.0]_com = [0.0,0.0]_trv; acosh [1.0,0X1.2C903022DD7AAP+8]_dac = [0.0,0X1.9985FB3D532AFP+2]_dac; acosh [0.9,0X1.2C903022DD7AAP+8]_com = [0.0,0X1.9985FB3D532AFP+2]_trv; acosh [0X1.14D4E82B2B26FP+15,0X1.72DBE91C837B5P+29]_def = [0X1.656510B4BAEC3P+3,0X1.52A415EE8455AP+4]_def; } testcase minimal_atanh_test { atanh [empty] = [empty]; atanh [0.0,infinity] = [0.0,infinity]; atanh [-0.0,infinity] = [0.0,infinity]; atanh [1.0,infinity] = [empty]; atanh [-infinity,0.0] = [-infinity,0.0]; atanh [-infinity,-0.0] = [-infinity,0.0]; atanh [-infinity,-1.0] = [empty]; atanh [-1.0,1.0] = [entire]; atanh [0.0,0.0] = [0.0,0.0]; atanh [-0.0,-0.0] = [0.0,0.0]; atanh [-1.0,-1.0] = [empty]; atanh [1.0,1.0] = [empty]; atanh [entire] = [entire]; atanh [0X1.4C0420F6F08CCP-2,0X1.FFFFFFFFFFFFFP-1] = [0X1.5871DD2DF9102P-2,0X1.2B708872320E2P+4]; atanh [-0X1.FFB88E9EB6307P-1,0X1.999999999999AP-4] = [-0X1.06A3A97D7979CP+2,0X1.9AF93CD234413P-4]; } testcase minimal_atanh_dec_test { atanh [0.0,infinity]_dac = [0.0,infinity]_trv; atanh [-infinity,0.0]_def = [-infinity,0.0]_trv; atanh [-1.0,1.0]_com = [entire]_trv; atanh [0.0,0.0]_com = [0.0,0.0]_com; atanh [1.0,1.0]_def = [empty]_trv; atanh [0X1.4C0420F6F08CCP-2,0X1.FFFFFFFFFFFFFP-1]_com = [0X1.5871DD2DF9102P-2,0X1.2B708872320E2P+4]_com; atanh [-1.0,0X1.FFFFFFFFFFFFFP-1]_com = [-infinity,0X1.2B708872320E2P+4]_trv; atanh [-0X1.FFB88E9EB6307P-1,0X1.999999999999AP-4]_def = [-0X1.06A3A97D7979CP+2,0X1.9AF93CD234413P-4]_def; atanh [-0X1.FFB88E9EB6307P-1,1.0]_com = [-0X1.06A3A97D7979CP+2,infinity]_trv; } testcase minimal_sign_test { sign [empty] = [empty]; sign [1.0,2.0] = [1.0,1.0]; sign [-1.0,2.0] = [-1.0,1.0]; sign [-1.0,0.0] = [-1.0,0.0]; sign [0.0,2.0] = [0.0,1.0]; sign [-0.0,2.0] = [0.0,1.0]; sign [-5.0,-2.0] = [-1.0,-1.0]; sign [0.0,0.0] = [0.0,0.0]; sign [-0.0,-0.0] = [0.0,0.0]; sign [-0.0,0.0] = [0.0,0.0]; sign [entire] = [-1.0,1.0]; } testcase minimal_sign_dec_test { sign [1.0,2.0]_com = [1.0,1.0]_com; sign [-1.0,2.0]_com = [-1.0,1.0]_def; sign [-1.0,0.0]_com = [-1.0,0.0]_def; sign [0.0,2.0]_com = [0.0,1.0]_def; sign [-0.0,2.0]_def = [0.0,1.0]_def; sign [-5.0,-2.0]_trv = [-1.0,-1.0]_trv; sign [0.0,0.0]_dac = [0.0,0.0]_dac; } testcase minimal_ceil_test { ceil [empty] = [empty]; ceil [entire] = [entire]; ceil [1.1,2.0] = [2.0,2.0]; ceil [-1.1,2.0] = [-1.0,2.0]; ceil [-1.1,0.0] = [-1.0,0.0]; ceil [-1.1,-0.0] = [-1.0,0.0]; ceil [-1.1,-0.4] = [-1.0,0.0]; ceil [-1.9,2.2] = [-1.0,3.0]; ceil [-1.0,2.2] = [-1.0,3.0]; ceil [0.0,2.2] = [0.0,3.0]; ceil [-0.0,2.2] = [0.0,3.0]; ceil [-1.5,infinity] = [-1.0,infinity]; ceil [0x1.FFFFFFFFFFFFFp1023,infinity] = [0x1.FFFFFFFFFFFFFp1023,infinity]; ceil [-infinity,2.2] = [-infinity,3.0]; ceil [-infinity,-0x1.FFFFFFFFFFFFFp1023] = [-infinity,-0x1.FFFFFFFFFFFFFp1023]; } testcase minimal_ceil_dec_test { ceil [1.1,2.0]_com = [2.0,2.0]_dac; ceil [-1.1,2.0]_com = [-1.0,2.0]_def; ceil [-1.1,0.0]_dac = [-1.0,0.0]_def; ceil [-1.1,-0.0]_trv = [-1.0,0.0]_trv; ceil [-1.1,-0.4]_dac = [-1.0,0.0]_def; ceil [-1.9,2.2]_com = [-1.0,3.0]_def; ceil [-1.0,2.2]_dac = [-1.0,3.0]_def; ceil [0.0,2.2]_trv = [0.0,3.0]_trv; ceil [-0.0,2.2]_def = [0.0,3.0]_def; ceil [-1.5,infinity]_trv = [-1.0,infinity]_trv; ceil [0x1.FFFFFFFFFFFFFp1023,infinity]_dac = [0x1.FFFFFFFFFFFFFp1023,infinity]_def; ceil [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_com = [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_dac; ceil [-infinity,2.2]_trv = [-infinity,3.0]_trv; ceil [-infinity,-0x1.FFFFFFFFFFFFFp1023]_dac = [-infinity,-0x1.FFFFFFFFFFFFFp1023]_def; } testcase minimal_floor_test { floor [empty] = [empty]; floor [entire] = [entire]; floor [1.1,2.0] = [1.0,2.0]; floor [-1.1,2.0] = [-2.0,2.0]; floor [-1.1,0.0] = [-2.0,0.0]; floor [-1.1,-0.0] = [-2.0,0.0]; floor [-1.1,-0.4] = [-2.0,-1.0]; floor [-1.9,2.2] = [-2.0,2.0]; floor [-1.0,2.2] = [-1.0,2.0]; floor [0.0,2.2] = [0.0,2.0]; floor [-0.0,2.2] = [0.0,2.0]; floor [-1.5,infinity] = [-2.0,infinity]; floor [-infinity,2.2] = [-infinity,2.0]; } testcase minimal_floor_dec_test { floor [1.1,2.0]_com = [1.0,2.0]_def; floor [-1.1,2.0]_def = [-2.0,2.0]_def; floor [-1.1,0.0]_dac = [-2.0,0.0]_def; floor [-1.2,-1.1]_com = [-2.0,-2.0]_com; floor [-1.1,-0.4]_def = [-2.0,-1.0]_def; floor [-1.9,2.2]_com = [-2.0,2.0]_def; floor [-1.0,2.2]_trv = [-1.0,2.0]_trv; floor [0.0,2.2]_trv = [0.0,2.0]_trv; floor [-0.0,2.2]_com = [0.0,2.0]_def; floor [-1.5,infinity]_dac = [-2.0,infinity]_def; floor [-infinity,2.2]_trv = [-infinity,2.0]_trv; } testcase minimal_trunc_test { trunc [empty] = [empty]; trunc [entire] = [entire]; trunc [1.1,2.1] = [1.0,2.0]; trunc [-1.1,2.0] = [-1.0,2.0]; trunc [-1.1,0.0] = [-1.0,0.0]; trunc [-1.1,-0.0] = [-1.0,0.0]; trunc [-1.1,-0.4] = [-1.0,0.0]; trunc [-1.9,2.2] = [-1.0,2.0]; trunc [-1.0,2.2] = [-1.0,2.0]; trunc [0.0,2.2] = [0.0,2.0]; trunc [-0.0,2.2] = [0.0,2.0]; trunc [-1.5,infinity] = [-1.0,infinity]; trunc [-infinity,2.2] = [-infinity,2.0]; } testcase minimal_trunc_dec_test { trunc [1.1,2.1]_com = [1.0,2.0]_def; trunc [1.1,1.9]_com = [1.0,1.0]_com; trunc [-1.1,2.0]_dac = [-1.0,2.0]_def; trunc [-1.1,0.0]_trv = [-1.0,0.0]_trv; trunc [-1.1,-0.0]_def = [-1.0,0.0]_def; trunc [-1.1,-0.4]_com = [-1.0,0.0]_def; trunc [-1.9,2.2]_def = [-1.0,2.0]_def; trunc [-1.0,2.2]_dac = [-1.0,2.0]_def; trunc [-1.5,infinity]_dac = [-1.0,infinity]_def; trunc [-infinity,2.2]_trv = [-infinity,2.0]_trv; } testcase minimal_roundTiesToEven_test { roundTiesToEven [empty] = [empty]; roundTiesToEven [entire] = [entire]; roundTiesToEven [1.1,2.1] = [1.0,2.0]; roundTiesToEven [-1.1,2.0] = [-1.0,2.0]; roundTiesToEven [-1.1,-0.4] = [-1.0,0.0]; roundTiesToEven [-1.1,0.0] = [-1.0,0.0]; roundTiesToEven [-1.1,-0.0] = [-1.0,0.0]; roundTiesToEven [-1.9,2.2] = [-2.0,2.0]; roundTiesToEven [-1.0,2.2] = [-1.0,2.0]; roundTiesToEven [1.5,2.1] = [2.0,2.0]; roundTiesToEven [-1.5,2.0] = [-2.0,2.0]; roundTiesToEven [-1.1,-0.5] = [-1.0,0.0]; roundTiesToEven [-1.9,2.5] = [-2.0,2.0]; roundTiesToEven [0.0,2.5] = [0.0,2.0]; roundTiesToEven [-0.0,2.5] = [0.0,2.0]; roundTiesToEven [-1.5,2.5] = [-2.0,2.0]; roundTiesToEven [-1.5,infinity] = [-2.0,infinity]; roundTiesToEven [-infinity,2.2] = [-infinity,2.0]; } testcase minimal_roundTiesToEven_dec_test { roundTiesToEven [1.1,2.1]_com = [1.0,2.0]_def; roundTiesToEven [-1.1,2.0]_trv = [-1.0,2.0]_trv; roundTiesToEven [-1.6,-1.5]_com = [-2.0,-2.0]_dac; roundTiesToEven [-1.6,-1.4]_com = [-2.0,-1.0]_def; roundTiesToEven [-1.5,infinity]_dac = [-2.0,infinity]_def; roundTiesToEven [-infinity,2.2]_trv = [-infinity,2.0]_trv; } testcase minimal_roundTiesToAway_test { roundTiesToAway [empty] = [empty]; roundTiesToAway [entire] = [entire]; roundTiesToAway [1.1,2.1] = [1.0,2.0]; roundTiesToAway [-1.1,2.0] = [-1.0,2.0]; roundTiesToAway [-1.1,0.0] = [-1.0,0.0]; roundTiesToAway [-1.1,-0.0] = [-1.0,-0.0]; roundTiesToAway [-1.1,-0.4] = [-1.0,0.0]; roundTiesToAway [-1.9,2.2] = [-2.0,2.0]; roundTiesToAway [-1.0,2.2] = [-1.0,2.0]; roundTiesToAway [0.5,2.1] = [1.0,2.0]; roundTiesToAway [-2.5,2.0] = [-3.0,2.0]; roundTiesToAway [-1.1,-0.5] = [-1.0,-1.0]; roundTiesToAway [-1.9,2.5] = [-2.0,3.0]; roundTiesToAway [-1.5,2.5] = [-2.0,3.0]; roundTiesToAway [0.0,2.5] = [0.0,3.0]; roundTiesToAway [-0.0,2.5] = [0.0,3.0]; roundTiesToAway [-1.5,infinity] = [-2.0,infinity]; roundTiesToAway [-infinity,2.2] = [-infinity,2.0]; } testcase minimal_roundTiesToAway_dec_test { roundTiesToAway [1.1,2.1]_com = [1.0,2.0]_def; roundTiesToAway [-1.9,2.2]_com = [-2.0,2.0]_def; roundTiesToAway [1.9,2.2]_com = [2.0,2.0]_com; roundTiesToAway [-1.0,2.2]_trv = [-1.0,2.0]_trv; roundTiesToAway [2.5,2.6]_com = [3.0,3.0]_dac; roundTiesToAway [-1.5,infinity]_dac = [-2.0,infinity]_def; roundTiesToAway [-infinity,2.2]_def = [-infinity,2.0]_def; } testcase minimal_abs_test { abs [empty] = [empty]; abs [entire] = [0.0,infinity]; abs [1.1,2.1] = [1.1,2.1]; abs [-1.1,2.0] = [0.0,2.0]; abs [-1.1,0.0] = [0.0,1.1]; abs [-1.1,-0.0] = [0.0,1.1]; abs [-1.1,-0.4] = [0.4,1.1]; abs [-1.9,0.2] = [0.0,1.9]; abs [0.0,0.2] = [0.0,0.2]; abs [-0.0,0.2] = [0.0,0.2]; abs [-1.5,infinity] = [0.0,infinity]; abs [-infinity,-2.2] = [2.2,infinity]; } testcase minimal_abs_dec_test { abs [-1.1,2.0]_com = [0.0,2.0]_com; abs [-1.1,0.0]_dac = [0.0,1.1]_dac; abs [-1.1,-0.0]_def = [0.0,1.1]_def; abs [-1.1,-0.4]_trv = [0.4,1.1]_trv; abs [-1.9,0.2]_dac = [0.0,1.9]_dac; abs [0.0,0.2]_def = [0.0,0.2]_def; abs [-0.0,0.2]_com = [0.0,0.2]_com; abs [-1.5,infinity]_dac = [0.0,infinity]_dac; } testcase minimal_min_test { min [empty] [1.0,2.0] = [empty]; min [1.0,2.0] [empty] = [empty]; min [empty] [empty] = [empty]; min [entire] [1.0,2.0] = [-infinity,2.0]; min [1.0,2.0] [entire] = [-infinity,2.0]; min [entire] [entire] = [entire]; min [empty] [entire] = [empty]; min [1.0,5.0] [2.0,4.0] = [1.0,4.0]; min [0.0,5.0] [2.0,4.0] = [0.0,4.0]; min [-0.0,5.0] [2.0,4.0] = [0.0,4.0]; min [1.0,5.0] [2.0,8.0] = [1.0,5.0]; min [1.0,5.0] [entire] = [-infinity,5.0]; min [-7.0,-5.0] [2.0,4.0] = [-7.0,-5.0]; min [-7.0,0.0] [2.0,4.0] = [-7.0,0.0]; min [-7.0,-0.0] [2.0,4.0] = [-7.0,0.0]; } testcase minimal_min_dec_test { min [entire]_def [1.0,2.0]_com = [-infinity,2.0]_def; min [-7.0,-5.0]_trv [2.0,4.0]_def = [-7.0,-5.0]_trv; min [-7.0,0.0]_dac [2.0,4.0]_def = [-7.0,0.0]_def; min [-7.0,-0.0]_com [2.0,4.0]_com = [-7.0,0.0]_com; } testcase minimal_max_test { max [empty] [1.0,2.0] = [empty]; max [1.0,2.0] [empty] = [empty]; max [empty] [empty] = [empty]; max [entire] [1.0,2.0] = [1.0,infinity]; max [1.0,2.0] [entire] = [1.0,infinity]; max [entire] [entire] = [entire]; max [empty] [entire] = [empty]; max [1.0,5.0] [2.0,4.0] = [2.0,5.0]; max [1.0,5.0] [2.0,8.0] = [2.0,8.0]; max [-1.0,5.0] [entire] = [-1.0,infinity]; max [-7.0,-5.0] [2.0,4.0] = [2.0,4.0]; max [-7.0,-5.0] [0.0,4.0] = [0.0,4.0]; max [-7.0,-5.0] [-0.0,4.0] = [0.0,4.0]; max [-7.0,-5.0] [-2.0,0.0] = [-2.0,0.0]; max [-7.0,-5.0] [-2.0,-0.0] = [-2.0,0.0]; } testcase minimal_max_dec_test { max [entire]_def [1.0,2.0]_com = [1.0,infinity]_def; max [-7.0,-5.0]_trv [2.0,4.0]_def = [2.0,4.0]_trv; max [-7.0,5.0]_dac [2.0,4.0]_def = [2.0,5.0]_def; max [3.0,3.5]_com [2.0,4.0]_com = [3.0,4.0]_com; } interval-1.4.1/test/libieeep1788_tests_mul_rev.itl0000644000000000000000000007103212657475772020272 0ustar 00000000000000/* Copyright 2013-2015 Marco Nehmeier (nehmeier@informatik.uni-wuerzburg.de) Copyright 2015-2016 Oliver Heimlich Original author: Marco Nehmeier (unit tests in libieeep1788, original license: Apache License 2.0) Converted into portable ITL format by Oliver Heimlich with minor corrections. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ testcase minimal_mulRevToPair_test { mulRevToPair [empty] [1.0, 2.0] = [empty] [empty]; mulRevToPair [1.0, 2.0] [empty] = [empty] [empty]; mulRevToPair [empty] [empty] = [empty] [empty]; mulRevToPair [-2.0, -0.1] [-2.1, -0.4] = [0X1.999999999999AP-3, 0X1.5P+4] [empty]; mulRevToPair [-2.0, 0.0] [-2.1, -0.4] = [0X1.999999999999AP-3, infinity] [empty]; mulRevToPair [-2.0, 1.1] [-2.1, -0.4] = [-infinity, -0X1.745D1745D1745P-2] [0X1.999999999999AP-3, infinity]; mulRevToPair [0.0, 1.1] [-2.1, -0.4] = [-infinity, -0X1.745D1745D1745P-2] [empty]; mulRevToPair [0.01, 1.1] [-2.1, -0.4] = [-0X1.A400000000001P+7, -0X1.745D1745D1745P-2] [empty]; mulRevToPair [0.0, 0.0] [-2.1, -0.4] = [empty] [empty]; mulRevToPair [-infinity, -0.1] [-2.1, -0.4] = [0.0, 0X1.5P+4] [empty]; mulRevToPair [-infinity, 0.0] [-2.1, -0.4] = [0.0, infinity] [empty]; mulRevToPair [-infinity, 1.1] [-2.1, -0.4] = [-infinity, -0X1.745D1745D1745P-2] [0.0, infinity]; mulRevToPair [-2.0, infinity] [-2.1, -0.4] = [-infinity, 0.0] [0X1.999999999999AP-3, infinity]; mulRevToPair [0.0, infinity] [-2.1, -0.4] = [-infinity, 0.0] [empty]; mulRevToPair [0.01, infinity] [-2.1, -0.4] = [-0X1.A400000000001P+7, 0.0] [empty]; mulRevToPair [entire] [-2.1, -0.4] = [-infinity, 0.0] [0.0, infinity]; mulRevToPair [-2.0, -0.1] [-2.1, 0.0] = [0.0, 0X1.5P+4] [empty]; mulRevToPair [-2.0, 0.0] [-2.1, 0.0] = [entire] [empty]; mulRevToPair [-2.0, 1.1] [-2.1, 0.0] = [entire] [empty]; mulRevToPair [0.0, 1.1] [-2.1, 0.0] = [entire] [empty]; mulRevToPair [0.01, 1.1] [-2.1, 0.0] = [-0X1.A400000000001P+7, 0.0] [empty]; mulRevToPair [0.0, 0.0] [-2.1, 0.0] = [entire] [empty]; mulRevToPair [-infinity, -0.1] [-2.1, 0.0] = [0.0, 0X1.5P+4] [empty]; mulRevToPair [-infinity, 0.0] [-2.1, 0.0] = [entire] [empty]; mulRevToPair [-infinity, 1.1] [-2.1, 0.0] = [entire] [empty]; mulRevToPair [-2.0, infinity] [-2.1, 0.0] = [entire] [empty]; mulRevToPair [0.0, infinity] [-2.1, 0.0] = [entire] [empty]; mulRevToPair [0.01, infinity] [-2.1, 0.0] = [-0X1.A400000000001P+7, 0.0] [empty]; mulRevToPair [entire] [-2.1, 0.0] = [entire] [empty]; mulRevToPair [-2.0, -0.1] [-2.1, 0.12] = [-0X1.3333333333333P+0, 0X1.5P+4] [empty]; mulRevToPair [-2.0, 0.0] [-2.1, 0.12] = [entire] [empty]; mulRevToPair [-2.0, 1.1] [-2.1, 0.12] = [entire] [empty]; mulRevToPair [0.0, 1.1] [-2.1, 0.12] = [entire] [empty]; mulRevToPair [0.01, 1.1] [-2.1, 0.12] = [-0X1.A400000000001P+7 , 0X1.8P+3] [empty]; mulRevToPair [0.0, 0.0] [-2.1, 0.12] = [entire] [empty]; mulRevToPair [-infinity, -0.1] [-2.1, 0.12] = [-0X1.3333333333333P+0, 0X1.5P+4] [empty]; mulRevToPair [-infinity, 0.0] [-2.1, 0.12] = [entire] [empty]; mulRevToPair [-infinity, 1.1] [-2.1, 0.12] = [entire] [empty]; mulRevToPair [-2.0, infinity] [-2.1, 0.12] = [entire] [empty]; mulRevToPair [0.0, infinity] [-2.1, 0.12] = [entire] [empty]; mulRevToPair [0.01, infinity] [-2.1, 0.12] = [-0X1.A400000000001P+7 , 0X1.8P+3] [empty]; mulRevToPair [entire] [-2.1, 0.12] = [entire] [empty]; mulRevToPair [-2.0, -0.1] [0.0, 0.12] = [-0X1.3333333333333P+0, 0.0] [empty]; mulRevToPair [-2.0, 0.0] [0.0, 0.12] = [entire] [empty]; mulRevToPair [-2.0, 1.1] [0.0, 0.12] = [entire] [empty]; mulRevToPair [0.0, 1.1] [0.0, 0.12] = [entire] [empty]; mulRevToPair [0.01, 1.1] [0.0, 0.12] = [0.0, 0X1.8P+3] [empty]; mulRevToPair [0.0, 0.0] [0.0, 0.12] = [entire] [empty]; mulRevToPair [-infinity, -0.1] [0.0, 0.12] = [-0X1.3333333333333P+0, 0.0] [empty]; mulRevToPair [-infinity, 0.0] [0.0, 0.12] = [entire] [empty]; mulRevToPair [-infinity, 1.1] [0.0, 0.12] = [entire] [empty]; mulRevToPair [-2.0, infinity] [0.0, 0.12] = [entire] [empty]; mulRevToPair [0.0, infinity] [0.0, 0.12] = [entire] [empty]; mulRevToPair [0.01, infinity] [0.0, 0.12] = [0.0, 0X1.8P+3] [empty]; mulRevToPair [entire] [0.0, 0.12] = [entire] [empty]; mulRevToPair [-2.0, -0.1] [0.01, 0.12] = [-0X1.3333333333333P+0, -0X1.47AE147AE147BP-8] [empty]; mulRevToPair [-2.0, 0.0] [0.01, 0.12] = [-infinity, -0X1.47AE147AE147BP-8] [empty]; mulRevToPair [-2.0, 1.1] [0.01, 0.12] = [-infinity, -0X1.47AE147AE147BP-8] [0X1.29E4129E4129DP-7, infinity]; mulRevToPair [0.0, 1.1] [0.01, 0.12] = [0X1.29E4129E4129DP-7, infinity] [empty]; mulRevToPair [0.01, 1.1] [0.01, 0.12] = [0X1.29E4129E4129DP-7, 0X1.8P+3] [empty]; mulRevToPair [0.0, 0.0] [0.01, 0.12] = [empty] [empty]; mulRevToPair [-infinity, -0.1] [0.01, 0.12] = [-0X1.3333333333333P+0, 0.0] [empty]; mulRevToPair [-infinity, 0.0] [0.01, 0.12] = [-infinity, 0.0] [empty]; mulRevToPair [-infinity, 1.1] [0.01, 0.12] = [-infinity, 0.0] [0X1.29E4129E4129DP-7, infinity]; mulRevToPair [-2.0, infinity] [0.01, 0.12] = [-infinity, -0X1.47AE147AE147BP-8] [0.0, infinity]; mulRevToPair [0.0, infinity] [0.01, 0.12] = [0.0, infinity] [empty]; mulRevToPair [0.01, infinity] [0.01, 0.12] = [0.0, 0X1.8P+3] [empty]; mulRevToPair [entire] [0.01, 0.12] = [-infinity, 0.0] [0.0, infinity]; mulRevToPair [-2.0, -0.1] [0.0, 0.0] = [0.0, 0.0] [empty]; mulRevToPair [-2.0, 0.0] [0.0, 0.0] = [entire] [empty]; mulRevToPair [-2.0, 1.1] [0.0, 0.0] = [entire] [empty]; mulRevToPair [0.0, 1.1] [0.0, 0.0] = [entire] [empty]; mulRevToPair [0.01, 1.1] [0.0, 0.0] = [0.0, 0.0] [empty]; mulRevToPair [0.0, 0.0] [0.0, 0.0] = [entire] [empty]; mulRevToPair [-infinity, -0.1] [0.0, 0.0] = [0.0, 0.0] [empty]; mulRevToPair [-infinity, 0.0] [0.0, 0.0] = [entire] [empty]; mulRevToPair [-infinity, 1.1] [0.0, 0.0] = [entire] [empty]; mulRevToPair [-2.0, infinity] [0.0, 0.0] = [entire] [empty]; mulRevToPair [0.0, infinity] [0.0, 0.0] = [entire] [empty]; mulRevToPair [0.01, infinity] [0.0, 0.0] = [0.0, 0.0] [empty]; mulRevToPair [entire] [0.0, 0.0] = [entire] [empty]; mulRevToPair [-2.0, -0.1] [-infinity, -0.1] = [0X1.999999999999AP-5, infinity] [empty]; mulRevToPair [-2.0, 0.0] [-infinity, -0.1] = [0X1.999999999999AP-5 , infinity] [empty]; mulRevToPair [-2.0, 1.1] [-infinity, -0.1] = [-infinity , -0X1.745D1745D1745P-4] [0X1.999999999999AP-5 , infinity]; mulRevToPair [0.0, 1.1] [-infinity, -0.1] = [-infinity, -0X1.745D1745D1745P-4] [empty]; mulRevToPair [0.01, 1.1] [-infinity, -0.1] = [-infinity, -0X1.745D1745D1745P-4] [empty]; mulRevToPair [0.0, 0.0] [-infinity, -0.1] = [empty] [empty]; mulRevToPair [-infinity, -0.1] [-infinity, -0.1] = [0.0, infinity] [empty]; mulRevToPair [-infinity, 0.0] [-infinity, -0.1] = [0.0, infinity] [empty]; mulRevToPair [-infinity, 1.1] [-infinity, -0.1] = [-infinity, -0X1.745D1745D1745P-4] [0.0, infinity]; mulRevToPair [-2.0, infinity] [-infinity, -0.1] = [-infinity, 0.0] [0X1.999999999999AP-5 , infinity]; mulRevToPair [0.0, infinity] [-infinity, -0.1] = [-infinity, 0.0] [empty]; mulRevToPair [0.01, infinity] [-infinity, -0.1] = [-infinity, 0.0] [empty]; mulRevToPair [entire] [-infinity, -0.1] = [-infinity, 0.0] [0.0, infinity]; mulRevToPair [-2.0, -0.1] [-infinity, 0.0] = [0.0, infinity] [empty]; mulRevToPair [-2.0, 0.0] [-infinity, 0.0] = [entire] [empty]; mulRevToPair [-2.0, 1.1] [-infinity, 0.0] = [entire] [empty]; mulRevToPair [0.0, 1.1] [-infinity, 0.0] = [entire] [empty]; mulRevToPair [0.01, 1.1] [-infinity, 0.0] = [-infinity, 0.0] [empty]; mulRevToPair [0.0, 0.0] [-infinity, 0.0] = [entire] [empty]; mulRevToPair [-infinity, -0.1] [-infinity, 0.0] = [0.0, infinity] [empty]; mulRevToPair [-infinity, 0.0] [-infinity, 0.0] = [entire] [empty]; mulRevToPair [-infinity, 1.1] [-infinity, 0.0] = [entire] [empty]; mulRevToPair [-2.0, infinity] [-infinity, 0.0] = [entire] [empty]; mulRevToPair [0.0, infinity] [-infinity, 0.0] = [entire] [empty]; mulRevToPair [0.01, infinity] [-infinity, 0.0] = [-infinity, 0.0] [empty]; mulRevToPair [entire] [-infinity, 0.0] = [entire] [empty]; mulRevToPair [-2.0, -0.1] [-infinity, 0.3] = [-0X1.8P+1, infinity] [empty]; mulRevToPair [-2.0, 0.0] [-infinity, 0.3] = [entire] [empty]; mulRevToPair [-2.0, 1.1] [-infinity, 0.3] = [entire] [empty]; mulRevToPair [0.0, 1.1] [-infinity, 0.3] = [entire] [empty]; mulRevToPair [0.01, 1.1] [-infinity, 0.3] = [-infinity, 0X1.EP+4] [empty]; mulRevToPair [0.0, 0.0] [-infinity, 0.3] = [entire] [empty]; mulRevToPair [-infinity, -0.1] [-infinity, 0.3] = [-0X1.8P+1, infinity] [empty]; mulRevToPair [-infinity, 0.0] [-infinity, 0.3] = [entire] [empty]; mulRevToPair [-infinity, 1.1] [-infinity, 0.3] = [entire] [empty]; mulRevToPair [-2.0, infinity] [-infinity, 0.3] = [entire] [empty]; mulRevToPair [0.0, infinity] [-infinity, 0.3] = [entire] [empty]; mulRevToPair [0.01, infinity] [-infinity, 0.3] = [-infinity, 0X1.EP+4] [empty]; mulRevToPair [entire] [-infinity, 0.3] = [entire] [empty]; mulRevToPair [-2.0, -0.1] [-0.21, infinity] = [-infinity , 0X1.0CCCCCCCCCCCDP+1] [empty]; mulRevToPair [-2.0, 0.0] [-0.21, infinity] = [entire] [empty]; mulRevToPair [-2.0, 1.1] [-0.21, infinity] = [entire] [empty]; mulRevToPair [0.0, 1.1] [-0.21, infinity] = [entire] [empty]; mulRevToPair [0.01, 1.1] [-0.21, infinity] = [-0X1.5P+4, infinity] [empty]; mulRevToPair [0.0, 0.0] [-0.21, infinity] = [entire] [empty]; mulRevToPair [-infinity, -0.1] [-0.21, infinity] = [-infinity, 0X1.0CCCCCCCCCCCDP+1] [empty]; mulRevToPair [-infinity, 0.0] [-0.21, infinity] = [entire] [empty]; mulRevToPair [-infinity, 1.1] [-0.21, infinity] = [entire] [empty]; mulRevToPair [-2.0, infinity] [-0.21, infinity] = [entire] [empty]; mulRevToPair [0.0, infinity] [-0.21, infinity] = [entire] [empty]; mulRevToPair [0.01, infinity] [-0.21, infinity] = [-0X1.5P+4, infinity] [empty]; mulRevToPair [entire] [-0.21, infinity] = [entire] [empty]; mulRevToPair [-2.0, -0.1] [0.0, infinity] = [-infinity, 0.0] [empty]; mulRevToPair [-2.0, 0.0] [0.0, infinity] = [entire] [empty]; mulRevToPair [-2.0, 1.1] [0.0, infinity] = [entire] [empty]; mulRevToPair [0.0, 1.1] [0.0, infinity] = [entire] [empty]; mulRevToPair [0.01, 1.1] [0.0, infinity] = [0.0, infinity] [empty]; mulRevToPair [0.0, 0.0] [0.0, infinity] = [entire] [empty]; mulRevToPair [-infinity, -0.1] [0.0, infinity] = [-infinity, 0.0] [empty]; mulRevToPair [-infinity, 0.0] [0.0, infinity] = [entire] [empty]; mulRevToPair [-infinity, 1.1] [0.0, infinity] = [entire] [empty]; mulRevToPair [-2.0, infinity] [0.0, infinity] = [entire] [empty]; mulRevToPair [0.0, infinity] [0.0, infinity] = [entire] [empty]; mulRevToPair [0.01, infinity] [0.0, infinity] = [0.0, infinity] [empty]; mulRevToPair [entire] [0.0, infinity] = [entire] [empty]; mulRevToPair [-2.0, -0.1] [0.04, infinity] = [-infinity, -0X1.47AE147AE147BP-6] [empty]; mulRevToPair [-2.0, 0.0] [0.04, infinity] = [-infinity, -0X1.47AE147AE147BP-6] [empty]; mulRevToPair [-2.0, 1.1] [0.04, infinity] = [-infinity, -0X1.47AE147AE147BP-6] [0X1.29E4129E4129DP-5, infinity]; mulRevToPair [0.0, 1.1] [0.04, infinity] = [0X1.29E4129E4129DP-5, infinity] [empty]; mulRevToPair [0.01, 1.1] [0.04, infinity] = [0X1.29E4129E4129DP-5, infinity] [empty]; mulRevToPair [0.0, 0.0] [0.04, infinity] = [empty] [empty]; mulRevToPair [-infinity, -0.1] [0.04, infinity] = [-infinity, 0.0] [empty]; mulRevToPair [-infinity, 0.0] [0.04, infinity] = [-infinity, 0.0] [empty]; mulRevToPair [-infinity, 1.1] [0.04, infinity] = [-infinity, 0.0] [0X1.29E4129E4129DP-5, infinity]; mulRevToPair [-2.0, infinity] [0.04, infinity] = [-infinity, -0X1.47AE147AE147BP-6] [0.0, infinity]; mulRevToPair [0.0, infinity] [0.04, infinity] = [0.0, infinity] [empty]; mulRevToPair [0.01, infinity] [0.04, infinity] = [0.0, infinity] [empty]; mulRevToPair [entire] [0.04, infinity] = [-infinity, 0.0] [0.0, infinity]; mulRevToPair [-2.0, -0.1] [entire] = [entire] [empty]; mulRevToPair [-2.0, 0.0] [entire] = [entire] [empty]; mulRevToPair [-2.0, 1.1] [entire] = [entire] [empty]; mulRevToPair [0.0, 1.1] [entire] = [entire] [empty]; mulRevToPair [0.01, 1.1] [entire] = [entire] [empty]; mulRevToPair [0.0, 0.0] [entire] = [entire] [empty]; mulRevToPair [-infinity, -0.1] [entire] = [entire] [empty]; mulRevToPair [-infinity, 0.0] [entire] = [entire] [empty]; mulRevToPair [-infinity, 1.1] [entire] = [entire] [empty]; mulRevToPair [-2.0, infinity] [entire] = [entire] [empty]; mulRevToPair [0.0, infinity] [entire] = [entire] [empty]; mulRevToPair [0.01, infinity] [entire] = [entire] [empty]; mulRevToPair [entire] [entire] = [entire] [empty]; } testcase minimal_mulRevToPair_dec_test { mulRevToPair [empty]_trv [1.0, 2.0]_def = [empty]_trv [empty]_trv; mulRevToPair [1.0, 2.0]_com [empty]_trv = [empty]_trv [empty]_trv; mulRevToPair [empty]_trv [empty]_trv = [empty]_trv [empty]_trv; mulRevToPair [-2.0, -0.1]_com [-2.1, -0.4]_com = [0X1.999999999999AP-3, 0X1.5P+4]_com [empty]_trv; mulRevToPair [-2.0, 0.0]_dac [-2.1, -0.4]_com = [0X1.999999999999AP-3, infinity]_trv [empty]_trv; mulRevToPair [-2.0, 1.1]_com [-2.1, -0.4]_dac = [-infinity, -0X1.745D1745D1745P-2]_trv [0X1.999999999999AP-3, infinity]_trv; mulRevToPair [0.0, 1.1]_trv [-2.1, -0.4]_def = [-infinity, -0X1.745D1745D1745P-2]_trv [empty]_trv; mulRevToPair [0.01, 1.1]_com [-2.1, -0.4]_com = [-0X1.A400000000001P+7, -0X1.745D1745D1745P-2]_com [empty]_trv; mulRevToPair [0.0, 0.0]_dac [-2.1, -0.4]_def = [empty]_trv [empty]_trv; mulRevToPair [-infinity, -0.1]_dac [-2.1, -0.4]_dac = [0.0, 0X1.5P+4]_dac [empty]_trv; mulRevToPair [-infinity, 0.0]_def [-2.1, -0.4]_com = [0.0, infinity]_trv [empty]_trv; mulRevToPair [-infinity, 1.1]_trv [-2.1, -0.4]_def = [-infinity, -0X1.745D1745D1745P-2]_trv [0.0, infinity]_trv; mulRevToPair [-2.0, infinity]_dac [-2.1, -0.4]_dac = [-infinity, 0.0]_trv [0X1.999999999999AP-3, infinity]_trv; mulRevToPair [0.0, infinity]_def [-2.1, -0.4]_com = [-infinity, 0.0]_trv [empty]_trv; mulRevToPair [0.01, infinity]_def [-2.1, -0.4]_def = [-0X1.A400000000001P+7, 0.0]_def [empty]_trv; mulRevToPair [entire]_dac [-2.1, -0.4]_dac = [-infinity, 0.0]_trv [0.0, infinity]_trv; mulRevToPair [-2.0, -0.1]_dac [-2.1, 0.0]_com = [0.0, 0X1.5P+4]_dac [empty]_trv; mulRevToPair [-2.0, 0.0]_dac [-2.1, 0.0]_com = [entire]_trv [empty]_trv; mulRevToPair [-2.0, 1.1]_dac [-2.1, 0.0]_com = [entire]_trv [empty]_trv; mulRevToPair [0.0, 1.1]_dac [-2.1, 0.0]_com = [entire]_trv [empty]_trv; mulRevToPair [0.01, 1.1]_dac [-2.1, 0.0]_com = [-0X1.A400000000001P+7, 0.0]_dac [empty]_trv; mulRevToPair [0.0, 0.0]_dac [-2.1, 0.0]_com = [entire]_trv [empty]_trv; mulRevToPair [-infinity, -0.1]_dac [-2.1, 0.0]_com = [0.0, 0X1.5P+4]_dac [empty]_trv; mulRevToPair [-infinity, 0.0]_dac [-2.1, 0.0]_com = [entire]_trv [empty]_trv; mulRevToPair [-infinity, 1.1]_dac [-2.1, 0.0]_com = [entire]_trv [empty]_trv; mulRevToPair [-2.0, infinity]_dac [-2.1, 0.0]_com = [entire]_trv [empty]_trv; mulRevToPair [0.0, infinity]_dac [-2.1, 0.0]_com = [entire]_trv [empty]_trv; mulRevToPair [0.01, infinity]_dac [-2.1, 0.0]_com = [-0X1.A400000000001P+7, 0.0]_dac [empty]_trv; mulRevToPair [entire]_dac [-2.1, 0.0]_com = [entire]_trv [empty]_trv; mulRevToPair [-2.0, -0.1]_def [-2.1, 0.12]_dac = [-0X1.3333333333333P+0, 0X1.5P+4]_def [empty]_trv; mulRevToPair [-2.0, 0.0]_def [-2.1, 0.12]_dac = [entire]_trv [empty]_trv; mulRevToPair [-2.0, 1.1]_def [-2.1, 0.12]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.0, 1.1]_def [-2.1, 0.12]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.01, 1.1]_def [-2.1, 0.12]_dac = [-0X1.A400000000001P+7 , 0X1.8P+3]_def [empty]_trv; mulRevToPair [0.0, 0.0]_def [-2.1, 0.12]_dac = [entire]_trv [empty]_trv; mulRevToPair [-infinity, -0.1]_def [-2.1, 0.12]_dac = [-0X1.3333333333333P+0, 0X1.5P+4]_def [empty]_trv; mulRevToPair [-infinity, 0.0]_def [-2.1, 0.12]_dac = [entire]_trv [empty]_trv; mulRevToPair [-infinity, 1.1]_def [-2.1, 0.12]_dac = [entire]_trv [empty]_trv; mulRevToPair [-2.0, infinity]_def [-2.1, 0.12]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.0, infinity]_def [-2.1, 0.12]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.01, infinity]_def [-2.1, 0.12]_dac = [-0X1.A400000000001P+7 , 0X1.8P+3]_def [empty]_trv; mulRevToPair [entire]_def [-2.1, 0.12]_dac = [entire]_trv [empty]_trv; mulRevToPair [-2.0, -0.1]_com [0.0, 0.12]_com = [-0X1.3333333333333P+0, 0.0]_com [empty]_trv; mulRevToPair [-2.0, 0.0]_com [0.0, 0.12]_com = [entire]_trv [empty]_trv; mulRevToPair [-2.0, 1.1]_com [0.0, 0.12]_com = [entire]_trv [empty]_trv; mulRevToPair [0.0, 1.1]_com [0.0, 0.12]_com = [entire]_trv [empty]_trv; mulRevToPair [0.01, 1.1]_com [0.0, 0.12]_com = [0.0, 0X1.8P+3]_com [empty]_trv; mulRevToPair [0.0, 0.0]_com [0.0, 0.12]_com = [entire]_trv [empty]_trv; mulRevToPair [-infinity, -0.1]_dac [0.0, 0.12]_com = [-0X1.3333333333333P+0, 0.0]_dac [empty]_trv; mulRevToPair [-infinity, 0.0]_dac [0.0, 0.12]_com = [entire]_trv [empty]_trv; mulRevToPair [-infinity, 1.1]_dac [0.0, 0.12]_com = [entire]_trv [empty]_trv; mulRevToPair [-2.0, infinity]_dac [0.0, 0.12]_com = [entire]_trv [empty]_trv; mulRevToPair [0.0, infinity]_dac [0.0, 0.12]_com = [entire]_trv [empty]_trv; mulRevToPair [0.01, infinity]_dac [0.0, 0.12]_com = [0.0, 0X1.8P+3]_dac [empty]_trv; mulRevToPair [entire]_dac [0.0, 0.12]_com = [entire]_trv [empty]_trv; mulRevToPair [-2.0, -0.1]_dac [0.01, 0.12]_dac = [-0X1.3333333333333P+0, -0X1.47AE147AE147BP-8]_dac [empty]_trv; mulRevToPair [-2.0, 0.0]_dac [0.01, 0.12]_dac = [-infinity, -0X1.47AE147AE147BP-8]_trv [empty]_trv; mulRevToPair [-2.0, 1.1]_dac [0.01, 0.12]_dac = [-infinity, -0X1.47AE147AE147BP-8]_trv [0X1.29E4129E4129DP-7, infinity]_trv; mulRevToPair [0.0, 1.1]_dac [0.01, 0.12]_dac = [0X1.29E4129E4129DP-7, infinity]_trv [empty]_trv; mulRevToPair [0.01, 1.1]_dac [0.01, 0.12]_dac = [0X1.29E4129E4129DP-7, 0X1.8P+3]_dac [empty]_trv; mulRevToPair [0.0, 0.0]_dac [0.01, 0.12]_dac = [empty]_trv [empty]_trv; mulRevToPair [-infinity, -0.1]_dac [0.01, 0.12]_dac = [-0X1.3333333333333P+0, 0.0]_dac [empty]_trv; mulRevToPair [-infinity, 0.0]_dac [0.01, 0.12]_dac = [-infinity, 0.0]_trv [empty]_trv; mulRevToPair [-infinity, 1.1]_dac [0.01, 0.12]_dac = [-infinity, 0.0]_trv [0X1.29E4129E4129DP-7, infinity]_trv; mulRevToPair [-2.0, infinity]_dac [0.01, 0.12]_dac = [-infinity, -0X1.47AE147AE147BP-8]_trv [0.0, infinity]_trv; mulRevToPair [0.0, infinity]_dac [0.01, 0.12]_dac = [0.0, infinity]_trv [empty]_trv; mulRevToPair [0.01, infinity]_dac [0.01, 0.12]_dac = [0.0, 0X1.8P+3]_dac [empty]_trv; mulRevToPair [entire]_dac [0.01, 0.12]_dac = [-infinity, 0.0]_trv [0.0, infinity]_trv; mulRevToPair [-2.0, -0.1]_com [0.0, 0.0]_com = [0.0, 0.0]_com [empty]_trv; mulRevToPair [-2.0, 0.0]_com [0.0, 0.0]_com = [entire]_trv [empty]_trv; mulRevToPair [-2.0, 1.1]_com [0.0, 0.0]_com = [entire]_trv [empty]_trv; mulRevToPair [0.0, 1.1]_com [0.0, 0.0]_com = [entire]_trv [empty]_trv; mulRevToPair [0.01, 1.1]_com [0.0, 0.0]_com = [0.0, 0.0]_com [empty]_trv; mulRevToPair [0.0, 0.0]_com [0.0, 0.0]_com = [entire]_trv [empty]_trv; mulRevToPair [-infinity, -0.1]_dac [0.0, 0.0]_com = [0.0, 0.0]_dac [empty]_trv; mulRevToPair [-infinity, 0.0]_dac [0.0, 0.0]_com = [entire]_trv [empty]_trv; mulRevToPair [-infinity, 1.1]_dac [0.0, 0.0]_com = [entire]_trv [empty]_trv; mulRevToPair [-2.0, infinity]_dac [0.0, 0.0]_com = [entire]_trv [empty]_trv; mulRevToPair [0.0, infinity]_dac [0.0, 0.0]_com = [entire]_trv [empty]_trv; mulRevToPair [0.01, infinity]_dac [0.0, 0.0]_com = [0.0, 0.0]_dac [empty]_trv; mulRevToPair [entire]_dac [0.0, 0.0]_com = [entire]_trv [empty]_trv; mulRevToPair [-2.0, -0.1]_dac [-infinity, -0.1]_dac = [0X1.999999999999AP-5, infinity]_dac [empty]_trv; mulRevToPair [-2.0, 0.0]_dac [-infinity, -0.1]_dac = [0X1.999999999999AP-5 , infinity]_trv [empty]_trv; mulRevToPair [-2.0, 1.1]_dac [-infinity, -0.1]_dac = [-infinity , -0X1.745D1745D1745P-4]_trv [0X1.999999999999AP-5 , infinity]_trv; mulRevToPair [0.0, 1.1]_dac [-infinity, -0.1]_dac = [-infinity, -0X1.745D1745D1745P-4]_trv [empty]_trv; mulRevToPair [0.01, 1.1]_dac [-infinity, -0.1]_dac = [-infinity, -0X1.745D1745D1745P-4]_dac [empty]_trv; mulRevToPair [0.0, 0.0]_dac [-infinity, -0.1]_dac = [empty]_trv [empty]_trv; mulRevToPair [-infinity, -0.1]_dac [-infinity, -0.1]_dac = [0.0, infinity]_dac [empty]_trv; mulRevToPair [-infinity, 0.0]_dac [-infinity, -0.1]_dac = [0.0, infinity]_trv [empty]_trv; mulRevToPair [-infinity, 1.1]_dac [-infinity, -0.1]_dac = [-infinity, -0X1.745D1745D1745P-4]_trv [0.0, infinity]_trv; mulRevToPair [-2.0, infinity]_dac [-infinity, -0.1]_dac = [-infinity, 0.0]_trv [0X1.999999999999AP-5 , infinity]_trv; mulRevToPair [0.0, infinity]_dac [-infinity, -0.1]_dac = [-infinity, 0.0]_trv [empty]_trv; mulRevToPair [0.01, infinity]_dac [-infinity, -0.1]_dac = [-infinity, 0.0]_dac [empty]_trv; mulRevToPair [entire]_dac [-infinity, -0.1]_dac = [-infinity, 0.0]_trv [0.0, infinity]_trv; mulRevToPair [-2.0, -0.1]_dac [-infinity, 0.0]_dac = [0.0, infinity]_dac [empty]_trv; mulRevToPair [-2.0, 0.0]_dac [-infinity, 0.0]_dac = [entire]_trv [empty]_trv; mulRevToPair [-2.0, 1.1]_dac [-infinity, 0.0]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.0, 1.1]_dac [-infinity, 0.0]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.01, 1.1]_dac [-infinity, 0.0]_dac = [-infinity, 0.0]_dac [empty]_trv; mulRevToPair [0.0, 0.0]_dac [-infinity, 0.0]_dac = [entire]_trv [empty]_trv; mulRevToPair [-infinity, -0.1]_dac [-infinity, 0.0]_dac = [0.0, infinity]_dac [empty]_trv; mulRevToPair [-infinity, 0.0]_dac [-infinity, 0.0]_dac = [entire]_trv [empty]_trv; mulRevToPair [-infinity, 1.1]_dac [-infinity, 0.0]_dac = [entire]_trv [empty]_trv; mulRevToPair [-2.0, infinity]_dac [-infinity, 0.0]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.0, infinity]_dac [-infinity, 0.0]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.01, infinity]_dac [-infinity, 0.0]_dac = [-infinity, 0.0]_dac [empty]_trv; mulRevToPair [entire]_dac [-infinity, 0.0]_dac = [entire]_trv [empty]_trv; mulRevToPair [-2.0, -0.1]_dac [-infinity, 0.3]_dac = [-0X1.8P+1, infinity]_dac [empty]_trv; mulRevToPair [-2.0, 0.0]_dac [-infinity, 0.3]_dac = [entire]_trv [empty]_trv; mulRevToPair [-2.0, 1.1]_dac [-infinity, 0.3]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.0, 1.1]_dac [-infinity, 0.3]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.01, 1.1]_dac [-infinity, 0.3]_dac = [-infinity, 0X1.EP+4]_dac [empty]_trv; mulRevToPair [0.0, 0.0]_dac [-infinity, 0.3]_dac = [entire]_trv [empty]_trv; mulRevToPair [-infinity, -0.1]_dac [-infinity, 0.3]_dac = [-0X1.8P+1, infinity]_dac [empty]_trv; mulRevToPair [-infinity, 0.0]_dac [-infinity, 0.3]_dac = [entire]_trv [empty]_trv; mulRevToPair [-infinity, 1.1]_dac [-infinity, 0.3]_dac = [entire]_trv [empty]_trv; mulRevToPair [-2.0, infinity]_dac [-infinity, 0.3]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.0, infinity]_dac [-infinity, 0.3]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.01, infinity]_dac [-infinity, 0.3]_dac = [-infinity, 0X1.EP+4]_dac [empty]_trv; mulRevToPair [entire]_dac [-infinity, 0.3]_dac = [entire]_trv [empty]_trv; mulRevToPair [-2.0, -0.1]_dac [-0.21, infinity]_dac = [-infinity , 0X1.0CCCCCCCCCCCDP+1]_dac [empty]_trv; mulRevToPair [-2.0, 0.0]_dac [-0.21, infinity]_dac = [entire]_trv [empty]_trv; mulRevToPair [-2.0, 1.1]_dac [-0.21, infinity]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.0, 1.1]_dac [-0.21, infinity]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.01, 1.1]_dac [-0.21, infinity]_dac = [-0X1.5P+4, infinity]_dac [empty]_trv; mulRevToPair [0.0, 0.0]_dac [-0.21, infinity]_dac = [entire]_trv [empty]_trv; mulRevToPair [-infinity, -0.1]_dac [-0.21, infinity]_dac = [-infinity, 0X1.0CCCCCCCCCCCDP+1]_dac [empty]_trv; mulRevToPair [-infinity, 0.0]_dac [-0.21, infinity]_dac = [entire]_trv [empty]_trv; mulRevToPair [-infinity, 1.1]_dac [-0.21, infinity]_dac = [entire]_trv [empty]_trv; mulRevToPair [-2.0, infinity]_dac [-0.21, infinity]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.0, infinity]_dac [-0.21, infinity]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.01, infinity]_dac [-0.21, infinity]_dac = [-0X1.5P+4, infinity]_dac [empty]_trv; mulRevToPair [entire]_dac [-0.21, infinity]_dac = [entire]_trv [empty]_trv; mulRevToPair [-2.0, -0.1]_dac [0.0, infinity]_dac = [-infinity, 0.0]_dac [empty]_trv; mulRevToPair [-2.0, 0.0]_dac [0.0, infinity]_dac = [entire]_trv [empty]_trv; mulRevToPair [-2.0, 1.1]_dac [0.0, infinity]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.0, 1.1]_dac [0.0, infinity]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.01, 1.1]_dac [0.0, infinity]_dac = [0.0, infinity]_dac [empty]_trv; mulRevToPair [0.0, 0.0]_dac [0.0, infinity]_dac = [entire]_trv [empty]_trv; mulRevToPair [-infinity, -0.1]_dac [0.0, infinity]_dac = [-infinity, 0.0]_dac [empty]_trv; mulRevToPair [-infinity, 0.0]_dac [0.0, infinity]_dac = [entire]_trv [empty]_trv; mulRevToPair [-infinity, 1.1]_dac [0.0, infinity]_dac = [entire]_trv [empty]_trv; mulRevToPair [-2.0, infinity]_dac [0.0, infinity]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.0, infinity]_dac [0.0, infinity]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.01, infinity]_dac [0.0, infinity]_dac = [0.0, infinity]_dac [empty]_trv; mulRevToPair [entire]_dac [0.0, infinity]_dac = [entire]_trv [empty]_trv; mulRevToPair [-2.0, -0.1]_dac [0.04, infinity]_dac = [-infinity, -0X1.47AE147AE147BP-6]_dac [empty]_trv; mulRevToPair [-2.0, 0.0]_dac [0.04, infinity]_dac = [-infinity, -0X1.47AE147AE147BP-6]_trv [empty]_trv; mulRevToPair [-2.0, 1.1]_dac [0.04, infinity]_dac = [-infinity, -0X1.47AE147AE147BP-6]_trv [0X1.29E4129E4129DP-5, infinity]_trv; mulRevToPair [0.0, 1.1]_dac [0.04, infinity]_dac = [0X1.29E4129E4129DP-5, infinity]_trv [empty]_trv; mulRevToPair [0.01, 1.1]_dac [0.04, infinity]_dac = [0X1.29E4129E4129DP-5, infinity]_dac [empty]_trv; mulRevToPair [0.0, 0.0]_dac [0.04, infinity]_dac = [empty]_trv [empty]_trv; mulRevToPair [-infinity, -0.1]_dac [0.04, infinity]_dac = [-infinity, 0.0]_dac [empty]_trv; mulRevToPair [-infinity, 0.0]_dac [0.04, infinity]_dac = [-infinity, 0.0]_trv [empty]_trv; mulRevToPair [-infinity, 1.1]_dac [0.04, infinity]_dac = [-infinity, 0.0]_trv [0X1.29E4129E4129DP-5, infinity]_trv; mulRevToPair [-2.0, infinity]_dac [0.04, infinity]_dac = [-infinity, -0X1.47AE147AE147BP-6]_trv [0.0, infinity]_trv; mulRevToPair [0.0, infinity]_dac [0.04, infinity]_dac = [0.0, infinity]_trv [empty]_trv; mulRevToPair [0.01, infinity]_dac [0.04, infinity]_dac = [0.0, infinity]_dac [empty]_trv; mulRevToPair [entire]_dac [0.04, infinity]_dac = [-infinity, 0.0]_trv [0.0, infinity]_trv; mulRevToPair [-2.0, -0.1]_dac [entire]_dac = [entire]_dac [empty]_trv; mulRevToPair [-2.0, 0.0]_dac [entire]_dac = [entire]_trv [empty]_trv; mulRevToPair [-2.0, 1.1]_dac [entire]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.0, 1.1]_dac [entire]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.01, 1.1]_dac [entire]_dac = [entire]_dac [empty]_trv; mulRevToPair [0.0, 0.0]_dac [entire]_dac = [entire]_trv [empty]_trv; mulRevToPair [-infinity, -0.1]_dac [entire]_dac = [entire]_dac [empty]_trv; mulRevToPair [-infinity, 0.0]_dac [entire]_dac = [entire]_trv [empty]_trv; mulRevToPair [-infinity, 1.1]_dac [entire]_dac = [entire]_trv [empty]_trv; mulRevToPair [-2.0, infinity]_dac [entire]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.0, infinity]_dac [entire]_dac = [entire]_trv [empty]_trv; mulRevToPair [0.01, infinity]_dac [entire]_dac = [entire]_dac [empty]_trv; mulRevToPair [entire]_dac [entire]_dac = [entire]_trv [empty]_trv; } interval-1.4.1/test/libieeep1788_tests_num.itl0000644000000000000000000001304612657475772017421 0ustar 00000000000000/* Copyright 2013-2015 Marco Nehmeier (nehmeier@informatik.uni-wuerzburg.de) Copyright 2015-2016 Oliver Heimlich Original author: Marco Nehmeier (unit tests in libieeep1788, original license: Apache License 2.0) Converted into portable ITL format by Oliver Heimlich with minor corrections. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ testcase minimal_inf_test { inf [empty] = +infinity; inf [-infinity,+infinity] = -infinity; inf [1.0,2.0] = 1.0; inf [-3.0,-2.0] = -3.0; inf [-infinity,2.0] = -infinity; inf [-infinity,0.0] = -infinity; inf [-infinity,-0.0] = -infinity; inf [-2.0,infinity] = -2.0; inf [0.0,infinity] = -0.0; inf [-0.0,infinity] = -0.0; inf [-0.0,0.0] = -0.0; inf [0.0,-0.0] = -0.0; inf [0.0,0.0] = -0.0; inf [-0.0,-0.0] = -0.0; } testcase minimal_inf_dec_test { inf [empty]_trv = +infinity; inf [-infinity,+infinity]_def = -infinity; inf [1.0,2.0]_com = 1.0; inf [-3.0,-2.0]_trv = -3.0; inf [-infinity,2.0]_dac = -infinity; inf [-infinity,0.0]_def = -infinity; inf [-infinity,-0.0]_trv = -infinity; inf [-2.0,infinity]_trv = -2.0; inf [0.0,infinity]_def = -0.0; inf [-0.0,infinity]_trv = -0.0; inf [-0.0,0.0]_dac = -0.0; inf [0.0,-0.0]_trv = -0.0; inf [0.0,0.0]_trv = -0.0; inf [-0.0,-0.0]_trv = -0.0; } testcase minimal_sup_test { sup [empty] = -infinity; sup [-infinity,+infinity] = +infinity; sup [1.0,2.0] = 2.0; sup [-3.0,-2.0] = -2.0; sup [-infinity,2.0] = 2.0; sup [-infinity,0.0] = 0.0; sup [-infinity,-0.0] = 0.0; sup [-2.0,infinity] = infinity; sup [0.0,infinity] = infinity; sup [-0.0,infinity] = infinity; sup [-0.0,0.0] = 0.0; sup [0.0,-0.0] = 0.0; sup [0.0,0.0] = 0.0; sup [-0.0,-0.0] = 0.0; } testcase minimal_sup_dec_test { sup [empty]_trv = -infinity; sup [-infinity,+infinity]_def = +infinity; sup [1.0,2.0]_com = 2.0; sup [-3.0,-2.0]_trv = -2.0; sup [-infinity,2.0]_dac = 2.0; sup [-infinity,0.0]_def = 0.0; sup [-infinity,-0.0]_trv = 0.0; sup [-2.0,infinity]_trv = infinity; sup [0.0,infinity]_def = infinity; sup [-0.0,infinity]_trv = infinity; sup [-0.0,0.0]_dac = +0.0; sup [0.0,-0.0]_trv = +0.0; sup [0.0,0.0]_trv = +0.0; sup [-0.0,-0.0]_trv = +0.0; } testcase minimal_mid_test { mid [-infinity,+infinity] = 0.0; mid [-0x1.FFFFFFFFFFFFFp1023,+0x1.FFFFFFFFFFFFFp1023] = 0.0; mid [0.0,2.0] = 1.0; mid [2.0,2.0] = 2.0; mid [-2.0,2.0] = 0.0; mid [-0X0.0000000000002P-1022,0X0.0000000000001P-1022] = 0.0; mid [-0X0.0000000000001P-1022,0X0.0000000000002P-1022] = 0.0; } testcase minimal_mid_dec_test { mid [-infinity,+infinity]_def = 0.0; mid [-0x1.FFFFFFFFFFFFFp1023,+0x1.FFFFFFFFFFFFFp1023]_trv = 0.0; mid [0.0,2.0]_com = 1.0; mid [2.0,2.0]_dac = 2.0; mid [-2.0,2.0]_trv = 0.0; mid [-0X0.0000000000002P-1022,0X0.0000000000001P-1022]_trv = 0.0; mid [-0X0.0000000000001P-1022,0X0.0000000000002P-1022]_trv = 0.0; } testcase minimal_rad_test { rad [0.0,2.0] = 1.0; rad [2.0,2.0] = 0.0; rad [-infinity,+infinity] = infinity; rad [0.0,infinity] = infinity; rad [-infinity, 1.2] = infinity; } testcase minimal_rad_dec_test { rad [0.0,2.0]_trv = 1.0; rad [2.0,2.0]_com = 0.0; rad [-infinity,+infinity]_trv = infinity; rad [0.0,infinity]_def = infinity; rad [-infinity, 1.2]_trv = infinity; } testcase minimal_wid_test { wid [2.0,2.0] = 0.0; wid [1.0,2.0] = 1.0; wid [1.0,infinity] = infinity; wid [-infinity,2.0] = infinity; wid [-infinity,+infinity] = infinity; } testcase minimal_wid_dec_test { wid [2.0,2.0]_com = 0.0; wid [1.0,2.0]_trv = 1.0; wid [1.0,infinity]_trv = infinity; wid [-infinity,2.0]_def = infinity; wid [-infinity,+infinity]_trv = infinity; } testcase minimal_mag_test { mag [1.0,2.0] = 2.0; mag [-4.0,2.0] = 4.0; mag [-infinity,2.0] = infinity; mag [1.0,infinity] = infinity; mag [-infinity,+infinity] = infinity; mag [-0.0,0.0] = 0.0; mag [-0.0,-0.0] = 0.0; } testcase minimal_mag_dec_test { mag [1.0,2.0]_com = 2.0; mag [-4.0,2.0]_trv = 4.0; mag [-infinity,2.0]_trv = infinity; mag [1.0,infinity]_def = infinity; mag [-infinity,+infinity]_trv = infinity; mag [-0.0,0.0]_trv = 0.0; mag [-0.0,-0.0]_trv = 0.0; } testcase minimal_mig_test { mig [1.0,2.0] = 1.0; mig [-4.0,2.0] = 0.0; mig [-4.0,-2.0] = 2.0; mig [-infinity,2.0] = 0.0; mig [-infinity,-2.0] = 2.0; mig [-1.0,infinity] = 0.0; mig [1.0,infinity] = 1.0; mig [-infinity,+infinity] = 0.0; mig [-0.0,0.0] = 0.0; mig [-0.0,-0.0] = 0.0; } testcase minimal_mig_dec_test { mig [1.0,2.0]_com = 1.0; mig [-4.0,2.0]_trv = 0.0; mig [-4.0,-2.0]_trv = 2.0; mig [-infinity,2.0]_def = 0.0; mig [-infinity,-2.0]_trv = 2.0; mig [-1.0,infinity]_trv = 0.0; mig [1.0,infinity]_trv = 1.0; mig [-infinity,+infinity]_trv = 0.0; mig [-0.0,0.0]_trv = 0.0; mig [-0.0,-0.0]_trv = 0.0; } interval-1.4.1/test/libieeep1788_tests_overlap.itl0000644000000000000000000001112412657475772020265 0ustar 00000000000000/* Copyright 2013-2015 Marco Nehmeier (nehmeier@informatik.uni-wuerzburg.de) Copyright 2015-2016 Oliver Heimlich Original author: Marco Nehmeier (unit tests in libieeep1788, original license: Apache License 2.0) Converted into portable ITL format by Oliver Heimlich with minor corrections. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ testcase minimal_overlap_test { overlap [empty] [empty] = bothEmpty; overlap [empty] [1.0,2.0] = firstEmpty; overlap [1.0,2.0] [empty] = secondEmpty; overlap [-infinity,2.0] [3.0,infinity] = before; overlap [-infinity,2.0] [3.0,4.0] = before; overlap [2.0,2.0] [3.0,4.0] = before; overlap [1.0,2.0] [3.0,4.0] = before; overlap [1.0,2.0] [3.0,3.0] = before; overlap [2.0,2.0] [3.0,3.0] = before; overlap [2.0,2.0] [3.0,infinity] = before; overlap [-infinity,2.0] [2.0,3.0] = meets; overlap [1.0,2.0] [2.0,3.0] = meets; overlap [1.0,2.0] [2.0,infinity] = meets; overlap [1.0,2.0] [1.5,2.5] = overlaps; overlap [1.0,2.0] [1.0,infinity] = starts; overlap [1.0,2.0] [1.0,3.0] = starts; overlap [1.0,1.0] [1.0,3.0] = starts; overlap [1.0,2.0] [entire] = containedBy; overlap [1.0,2.0] [-infinity,3.0] = containedBy; overlap [1.0,2.0] [0.0,3.0] = containedBy; overlap [2.0,2.0] [0.0,3.0] = containedBy; overlap [2.0,2.0] [0.0,infinity] = containedBy; overlap [1.0,2.0] [-infinity,2.0] = finishes; overlap [1.0,2.0] [0.0,2.0] = finishes; overlap [2.0,2.0] [0.0,2.0] = finishes; overlap [1.0,2.0] [1.0,2.0] = equals; overlap [1.0,1.0] [1.0,1.0] = equals; overlap [-infinity,1.0] [-infinity,1.0] = equals; overlap [entire] [entire] = equals; overlap [3.0,4.0] [2.0,2.0] = after; overlap [3.0,4.0] [1.0,2.0] = after; overlap [3.0,3.0] [1.0,2.0] = after; overlap [3.0,3.0] [2.0,2.0] = after; overlap [3.0,infinity] [2.0,2.0] = after; overlap [2.0,3.0] [1.0,2.0] = metBy; overlap [2.0,3.0] [-infinity,2.0] = metBy; overlap [1.5,2.5] [1.0,2.0] = overlappedBy; overlap [1.5,2.5] [-infinity,2.0] = overlappedBy; overlap [1.0,infinity] [1.0,2.0] = startedBy; overlap [1.0,3.0] [1.0,2.0] = startedBy; overlap [1.0,3.0] [1.0,1.0] = startedBy; overlap [-infinity,3.0] [1.0,2.0] = contains; overlap [entire] [1.0,2.0] = contains; overlap [0.0,3.0] [1.0,2.0] = contains; overlap [0.0,3.0] [2.0,2.0] = contains; overlap [-infinity,2.0] [1.0,2.0] = finishedBy; overlap [0.0,2.0] [1.0,2.0] = finishedBy; overlap [0.0,2.0] [2.0,2.0] = finishedBy; } testcase minimal_overlap_dec_test { overlap [empty]_trv [empty]_trv = bothEmpty; overlap [empty]_trv [1.0,2.0]_com = firstEmpty; overlap [1.0,2.0]_def [empty]_trv = secondEmpty; overlap [2.0,2.0]_def [3.0,4.0]_def = before; overlap [1.0,2.0]_dac [3.0,4.0]_com = before; overlap [1.0,2.0]_com [3.0,3.0]_trv = before; overlap [2.0,2.0]_trv [3.0,3.0]_def = before; overlap [1.0,2.0]_def [2.0,3.0]_def = meets; overlap [1.0,2.0]_dac [1.5,2.5]_def = overlaps; overlap [1.0,2.0]_def [1.0,3.0]_com = starts; overlap [1.0,1.0]_trv [1.0,3.0]_def = starts; overlap [1.0,2.0]_def [0.0,3.0]_dac = containedBy; overlap [2.0,2.0]_trv [0.0,3.0]_def = containedBy; overlap [1.0,2.0]_trv [0.0,2.0]_com = finishes; overlap [2.0,2.0]_def [0.0,2.0]_dac = finishes; overlap [1.0,2.0]_def [1.0,2.0]_def = equals; overlap [1.0,1.0]_dac [1.0,1.0]_dac = equals; overlap [3.0,4.0]_trv [2.0,2.0]_trv = after; overlap [3.0,4.0]_def [1.0,2.0]_def = after; overlap [3.0,3.0]_com [1.0,2.0]_dac = after; overlap [3.0,3.0]_def [2.0,2.0]_trv = after; overlap [2.0,3.0]_def [1.0,2.0]_trv = metBy; overlap [1.5,2.5]_com [1.0,2.0]_com = overlappedBy; overlap [1.0,3.0]_dac [1.0,2.0]_def = startedBy; overlap [1.0,3.0]_com [1.0,1.0]_dac = startedBy; overlap [0.0,3.0]_com [1.0,2.0]_dac = contains; overlap [0.0,3.0]_com [2.0,2.0]_def = contains; overlap [0.0,2.0]_def [1.0,2.0]_trv = finishedBy; overlap [0.0,2.0]_dac [2.0,2.0]_def = finishedBy; } interval-1.4.1/test/libieeep1788_tests_rec_bool.itl0000644000000000000000000001446512657475772020414 0ustar 00000000000000/* Copyright 2013-2015 Marco Nehmeier (nehmeier@informatik.uni-wuerzburg.de) Copyright 2015-2016 Oliver Heimlich Original author: Marco Nehmeier (unit tests in libieeep1788, original license: Apache License 2.0) Converted into portable ITL format by Oliver Heimlich with minor corrections. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ testcase minimal_isCommonInterval_test { isCommonInterval [-27.0,-27.0] = true; isCommonInterval [-27.0, 0.0] = true; isCommonInterval [0.0,0.0] = true; isCommonInterval [-0.0,-0.0] = true; isCommonInterval [-0.0,0.0] = true; isCommonInterval [0.0,-0.0] = true; isCommonInterval [5.0, 12.4] = true; isCommonInterval [-0x1.FFFFFFFFFFFFFp1023, 0x1.FFFFFFFFFFFFFp1023] = true; isCommonInterval [entire] = false; isCommonInterval [empty] = false; isCommonInterval [-infinity, 0.0] = false; isCommonInterval [0.0, infinity] = false; } testcase minimal_isCommonInterval_dec_test { isCommonInterval [-27.0,-27.0]_com = true; isCommonInterval [-27.0, 0.0]_com = true; isCommonInterval [0.0,0.0]_com = true; isCommonInterval [-0.0,-0.0]_com = true; isCommonInterval [-0.0,0.0]_com = true; isCommonInterval [0.0,-0.0]_com = true; isCommonInterval [5.0, 12.4]_com = true; isCommonInterval [-0x1.FFFFFFFFFFFFFp1023, 0x1.FFFFFFFFFFFFFp1023]_com = true; isCommonInterval [-27.0,-27.0]_trv = true; isCommonInterval [-27.0, 0.0]_def = true; isCommonInterval [0.0,0.0]_dac = true; isCommonInterval [-0.0,-0.0]_trv = true; isCommonInterval [-0.0,0.0]_def = true; isCommonInterval [0.0,-0.0]_dac = true; isCommonInterval [5.0, 12.4]_def = true; isCommonInterval [-0x1.FFFFFFFFFFFFFp1023, 0x1.FFFFFFFFFFFFFp1023]_trv = true; isCommonInterval [entire]_dac = false; isCommonInterval [empty]_trv = false; isCommonInterval [empty]_trv = false; isCommonInterval [-infinity, 0.0]_trv = false; isCommonInterval [0.0, infinity]_def = false; } testcase minimal_isSingleton_test { isSingleton [-27.0,-27.0] = true; isSingleton [-2.0, -2.0] = true; isSingleton [12.0,12.0] = true; isSingleton [17.1, 17.1] = true; isSingleton [-0.0,-0.0] = true; isSingleton [0.0,0.0] = true; isSingleton [-0.0, 0.0] = true; isSingleton [0.0, -0.0] = true; isSingleton [empty] = false; isSingleton [entire] = false; isSingleton [-1.0, 0.0] = false; isSingleton [-1.0, -0.5] = false; isSingleton [1.0, 2.0] = false; isSingleton [-infinity,-0x1.FFFFFFFFFFFFFp1023] = false; isSingleton [-1.0,infinity] = false; } testcase minimal_isSingleton_dec_test { isSingleton [-27.0,-27.0]_def = true; isSingleton [-2.0, -2.0]_trv = true; isSingleton [12.0,12.0]_dac = true; isSingleton [17.1, 17.1]_com = true; isSingleton [-0.0,-0.0]_def = true; isSingleton [0.0,0.0]_com = true; isSingleton [-0.0, 0.0]_def = true; isSingleton [0.0, -0.0]_dac = true; isSingleton [empty]_trv = false; isSingleton [empty]_trv = false; isSingleton [entire]_def = false; isSingleton [-1.0, 0.0]_dac = false; isSingleton [-1.0, -0.5]_com = false; isSingleton [1.0, 2.0]_def = false; isSingleton [-infinity,-0x1.FFFFFFFFFFFFFp1023]_dac = false; isSingleton [-1.0,infinity]_trv = false; } testcase minimal_isMember_test { isMember -27.0 [-27.0,-27.0] = true; isMember -27.0 [-27.0, 0.0] = true; isMember -7.0 [-27.0, 0.0] = true; isMember 0.0 [-27.0, 0.0] = true; isMember -0.0 [0.0,0.0] = true; isMember 0.0 [0.0,0.0] = true; isMember 0.0 [-0.0,-0.0] = true; isMember 0.0 [-0.0,0.0] = true; isMember 0.0 [0.0,-0.0] = true; isMember 5.0 [5.0, 12.4] = true; isMember 6.3 [5.0, 12.4] = true; isMember 12.4 [5.0, 12.4] = true; isMember 0.0 [entire] = true; isMember 5.0 [entire] = true; isMember 6.3 [entire] = true; isMember 12.4 [entire] = true; isMember -71.0 [-27.0, 0.0] = false; isMember 0.1 [-27.0, 0.0] = false; isMember -0.01 [0.0,0.0] = false; isMember 0.000001 [0.0,0.0] = false; isMember 111110.0 [-0.0,-0.0] = false; isMember 4.9 [5.0, 12.4] = false; isMember -6.3 [5.0, 12.4] = false; isMember 0.0 [empty] = false; isMember -4535.3 [empty] = false; isMember -infinity [empty] = false; isMember infinity [empty] = false; isMember -infinity [entire] = false; isMember infinity [entire] = false; } testcase minimal_isMember_dec_test { isMember -27.0 [-27.0,-27.0]_trv = true; isMember -27.0 [-27.0, 0.0]_def = true; isMember -7.0 [-27.0, 0.0]_dac = true; isMember 0.0 [-27.0, 0.0]_com = true; isMember -0.0 [0.0,0.0]_trv = true; isMember 0.0 [0.0,0.0]_def = true; isMember 0.0 [-0.0,-0.0]_dac = true; isMember 0.0 [-0.0,0.0]_com = true; isMember 0.0 [0.0,-0.0]_trv = true; isMember 5.0 [5.0, 12.4]_def = true; isMember 6.3 [5.0, 12.4]_dac = true; isMember 12.4 [5.0, 12.4]_com = true; isMember 0.0 [entire]_trv = true; isMember 5.0 [entire]_def = true; isMember 6.3 [entire]_dac = true; isMember 12.4 [entire]_trv = true; isMember -71.0 [-27.0, 0.0]_trv = false; isMember 0.1 [-27.0, 0.0]_def = false; isMember -0.01 [0.0,0.0]_dac = false; isMember 0.000001 [0.0,0.0]_com = false; isMember 111110.0 [-0.0,-0.0]_trv = false; isMember 4.9 [5.0, 12.4]_def = false; isMember -6.3 [5.0, 12.4]_dac = false; isMember 0.0 [empty]_trv = false; isMember 0.0 [empty]_trv = false; isMember -4535.3 [empty]_trv = false; isMember -4535.3 [empty]_trv = false; isMember -infinity [empty]_trv = false; isMember -infinity [empty]_trv = false; isMember infinity [empty]_trv = false; isMember infinity [empty]_trv = false; isMember -infinity [entire]_trv = false; isMember infinity [entire]_def = false; } interval-1.4.1/test/libieeep1788_tests_rev.itl0000644000000000000000000015334112657475772017421 0ustar 00000000000000/* Copyright 2013-2015 Marco Nehmeier (nehmeier@informatik.uni-wuerzburg.de) Copyright 2015-2016 Oliver Heimlich Original author: Marco Nehmeier (unit tests in libieeep1788, original license: Apache License 2.0) Converted into portable ITL format by Oliver Heimlich with minor corrections. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ testcase minimal_sqrRev_test { sqrRev [empty] = [empty]; sqrRev [-10.0,-1.0] = [empty]; sqrRev [0.0,infinity] = [entire]; sqrRev [0.0,1.0] = [-1.0,1.0]; sqrRev [-0.5,1.0] = [-1.0,1.0]; sqrRev [-1000.0,1.0] = [-1.0,1.0]; sqrRev [0.0,25.0] = [-5.0,5.0]; sqrRev [-1.0,25.0] = [-5.0,5.0]; sqrRev [0X1.47AE147AE147BP-7,0X1.47AE147AE147CP-7] = [-0X1.999999999999BP-4,0X1.999999999999BP-4]; sqrRev [0.0,0X1.FFFFFFFFFFFE1P+1] = [-0x1.ffffffffffff1p+0,0x1.ffffffffffff1p+0]; } testcase minimal_sqrRevBin_test { sqrRevBin [empty] [-5.0,1.0] = [empty]; sqrRevBin [-10.0,-1.0] [-5.0,1.0] = [empty]; sqrRevBin [0.0,infinity] [-5.0,1.0] = [-5.0,1.0]; sqrRevBin [0.0,1.0] [-0.1,1.0] = [-0.1,1.0]; sqrRevBin [-0.5,1.0] [-0.1,1.0] = [-0.1,1.0]; sqrRevBin [-1000.0,1.0] [-0.1,1.0] = [-0.1,1.0]; sqrRevBin [0.0,25.0] [-4.1,6.0] = [-4.1,5.0]; sqrRevBin [-1.0,25.0] [-4.1,7.0] = [-4.1,5.0]; sqrRevBin [1.0,25.0] [0.0,7.0] = [1.0,5.0]; sqrRevBin [0X1.47AE147AE147BP-7,0X1.47AE147AE147CP-7] [-0.1,infinity] = [-0.1,0X1.999999999999BP-4]; sqrRevBin [0.0,0X1.FFFFFFFFFFFE1P+1] [-0.1,infinity] = [-0.1,0x1.ffffffffffff1p+0]; } testcase minimal_sqrRev_dec_test { sqrRev [empty]_trv = [empty]_trv; sqrRev [-10.0,-1.0]_com = [empty]_trv; sqrRev [0.0,infinity]_dac = [entire]_trv; sqrRev [0.0,1.0]_def = [-1.0,1.0]_trv; sqrRev [-0.5,1.0]_dac = [-1.0,1.0]_trv; sqrRev [-1000.0,1.0]_com = [-1.0,1.0]_trv; sqrRev [0.0,25.0]_def = [-5.0,5.0]_trv; sqrRev [-1.0,25.0]_dac = [-5.0,5.0]_trv; sqrRev [0X1.47AE147AE147BP-7,0X1.47AE147AE147CP-7]_com = [-0X1.999999999999BP-4,0X1.999999999999BP-4]_trv; sqrRev [0.0,0X1.FFFFFFFFFFFE1P+1]_def = [-0x1.ffffffffffff1p+0,0x1.ffffffffffff1p+0]_trv; } testcase minimal_sqrRev_dec_bin_test { sqrRevBin [empty]_trv [-5.0,1.0]_def = [empty]_trv; sqrRevBin [-10.0,-1.0]_com [-5.0,1.0]_dac = [empty]_trv; sqrRevBin [0.0,infinity]_def [-5.0,1.0]_dac = [-5.0,1.0]_trv; sqrRevBin [0.0,1.0]_dac [-0.1,1.0]_def = [-0.1,1.0]_trv; sqrRevBin [-0.5,1.0]_def [-0.1,1.0]_dac = [-0.1,1.0]_trv; sqrRevBin [-1000.0,1.0]_com [-0.1,1.0]_def = [-0.1,1.0]_trv; sqrRevBin [0.0,25.0]_def [-4.1,6.0]_com = [-4.1,5.0]_trv; sqrRevBin [-1.0,25.0]_dac [-4.1,7.0]_def = [-4.1,5.0]_trv; sqrRevBin [1.0,25.0]_dac [0.0,7.0]_def = [1.0,5.0]_trv; sqrRevBin [0X1.47AE147AE147BP-7,0X1.47AE147AE147CP-7]_def [-0.1,infinity]_dac = [-0.1,0X1.999999999999BP-4]_trv; sqrRevBin [0.0,0X1.FFFFFFFFFFFE1P+1]_dac [-0.1,infinity]_dac = [-0.1,0x1.ffffffffffff1p+0]_trv; } testcase minimal_absRev_test { absRev [empty] = [empty]; absRev [-1.1,-0.4] = [empty]; absRev [0.0,infinity] = [entire]; absRev [1.1,2.1] = [-2.1,2.1]; absRev [-1.1,2.0] = [-2.0,2.0]; absRev [-1.1,0.0] = [0.0,0.0]; absRev [-1.9,0.2] = [-0.2,0.2]; absRev [0.0,0.2] = [-0.2,0.2]; absRev [-1.5,infinity] = [entire]; } testcase minimal_absRevBin_test { absRevBin [empty] [-1.1,5.0] = [empty]; absRevBin [-1.1,-0.4] [-1.1,5.0] = [empty]; absRevBin [0.0,infinity] [-1.1,5.0] = [-1.1,5.0]; absRevBin [1.1,2.1] [-1.0,5.0] = [1.1,2.1]; absRevBin [-1.1,2.0] [-1.1,5.0] = [-1.1,2.0]; absRevBin [-1.1,0.0] [-1.1,5.0] = [0.0,0.0]; absRevBin [-1.9,0.2] [-1.1,5.0] = [-0.2,0.2]; } testcase minimal_absRev_dec_test { absRev [empty]_trv = [empty]_trv; absRev [-1.1,-0.4]_dac = [empty]_trv; absRev [0.0,infinity]_dac = [entire]_trv; absRev [1.1,2.1]_com = [-2.1,2.1]_trv; absRev [-1.1,2.0]_def = [-2.0,2.0]_trv; absRev [-1.1,0.0]_dac = [0.0,0.0]_trv; absRev [-1.9,0.2]_com = [-0.2,0.2]_trv; absRev [0.0,0.2]_def = [-0.2,0.2]_trv; absRev [-1.5,infinity]_def = [entire]_trv; } testcase minimal_absRev_dec_bin_test { absRevBin [empty]_trv [-1.1,5.0]_com = [empty]_trv; absRevBin [-1.1,-0.4]_dac [-1.1,5.0]_dac = [empty]_trv; absRevBin [0.0,infinity]_def [-1.1,5.0]_def = [-1.1,5.0]_trv; absRevBin [1.1,2.1]_dac [-1.0,5.0]_def = [1.1,2.1]_trv; absRevBin [-1.1,2.0]_com [-1.1,5.0]_def = [-1.1,2.0]_trv; absRevBin [-1.1,0.0]_def [-1.1,5.0]_def = [0.0,0.0]_trv; absRevBin [-1.9,0.2]_dac [-1.1,5.0]_def = [-0.2,0.2]_trv; } testcase minimal_pownRev_test { pownRev [empty] 0 = [empty]; pownRev [1.0,1.0] 0 = [entire]; pownRev [-1.0,5.0] 0 = [entire]; pownRev [-1.0,0.0] 0 = [empty]; pownRev [-1.0,-0.0] 0 = [empty]; pownRev [1.1,10.0] 0 = [empty]; pownRev [empty] 1 = [empty]; pownRev [entire] 1 = [entire]; pownRev [0.0,0.0] 1 = [0.0,0.0]; pownRev [-0.0,-0.0] 1 = [0.0,0.0]; pownRev [13.1,13.1] 1 = [13.1,13.1]; pownRev [-7451.145,-7451.145] 1 = [-7451.145,-7451.145]; pownRev [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] 1 = [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]; pownRev [-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023] 1 = [-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023]; pownRev [0.0,infinity] 1 = [0.0,infinity]; pownRev [-0.0,infinity] 1 = [0.0,infinity]; pownRev [-infinity,0.0] 1 = [-infinity,0.0]; pownRev [-infinity,-0.0] 1 = [-infinity,0.0]; pownRev [-324.3,2.5] 1 = [-324.3,2.5]; pownRev [0.01,2.33] 1 = [0.01,2.33]; pownRev [-1.9,-0.33] 1 = [-1.9,-0.33]; pownRev [empty] 2 = [empty]; pownRev [-5.0,-1.0] 2 = [empty]; pownRev [0.0,infinity] 2 = [entire]; pownRev [-0.0,infinity] 2 = [entire]; pownRev [0.0,0.0] 2 = [0.0,0.0]; pownRev [-0.0,-0.0] 2 = [0.0,0.0]; pownRev [0X1.573851EB851EBP+7,0X1.573851EB851ECP+7] 2 = [-0x1.a333333333334p+3,0x1.a333333333334p+3]; pownRev [0X1.A794A4E7CFAADP+25,0X1.A794A4E7CFAAEP+25] 2 = [-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12]; pownRev [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] 2 = [-0x1p+512,0x1p+512]; pownRev [0.0,0X1.9AD27D70A3D72P+16] 2 = [-0x1.444cccccccccep+8,0x1.444cccccccccep+8]; pownRev [-0.0,0X1.9AD27D70A3D72P+16] 2 = [-0x1.444cccccccccep+8,0x1.444cccccccccep+8]; pownRev [0X1.A36E2EB1C432CP-14,0X1.5B7318FC50482P+2] 2 = [-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1]; pownRev [0X1.BE0DED288CE7P-4,0X1.CE147AE147AE1P+1] 2 = [-0x1.e666666666667p+0,0x1.e666666666667p+0]; pownRev [empty] 8 = [empty]; pownRev [entire] 8 = [entire]; pownRev [0.0,infinity] 8 = [entire]; pownRev [-0.0,infinity] 8 = [entire]; pownRev [0.0,0.0] 8 = [0.0,0.0]; pownRev [-0.0,-0.0] 8 = [0.0,0.0]; pownRev [0X1.9D8FD495853F5P+29,0X1.9D8FD495853F6P+29] 8 = [-0x1.a333333333334p+3,0x1.a333333333334p+3]; pownRev [0X1.DFB1BB622E70DP+102,0X1.DFB1BB622E70EP+102] 8 = [-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12]; pownRev [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] 8 = [-0x1p+128,0x1p+128]; pownRev [0.0,0X1.A87587109655P+66] 8 = [-0x1.444cccccccccep+8,0x1.444cccccccccep+8]; pownRev [-0.0,0X1.A87587109655P+66] 8 = [-0x1.444cccccccccep+8,0x1.444cccccccccep+8]; pownRev [0X1.CD2B297D889BDP-54,0X1.B253D9F33CE4DP+9] 8 = [-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1]; pownRev [0X1.26F1FCDD502A3P-13,0X1.53ABD7BFC4FC6P+7] 8 = [-0x1.e666666666667p+0,0x1.e666666666667p+0]; pownRev [empty] 3 = [empty]; pownRev [entire] 3 = [entire]; pownRev [0.0,0.0] 3 = [0.0,0.0]; pownRev [-0.0,-0.0] 3 = [0.0,0.0]; pownRev [0X1.1902E978D4FDEP+11,0X1.1902E978D4FDFP+11] 3 = [0x1.a333333333332p+3,0x1.a333333333334p+3]; pownRev [-0X1.81460637B9A3DP+38,-0X1.81460637B9A3CP+38] 3 = [-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12]; pownRev [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] 3 = [0x1.428a2f98d728ap+341,0x1.428a2f98d728bp+341]; pownRev [-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023] 3 = [-0x1.428a2f98d728bp+341, -0x1.428a2f98d728ap+341]; pownRev [0.0,infinity] 3 = [0.0,infinity]; pownRev [-0.0,infinity] 3 = [0.0,infinity]; pownRev [-infinity,0.0] 3 = [-infinity,0.0]; pownRev [-infinity,-0.0] 3 = [-infinity,0.0]; pownRev [-0X1.0436D2F418938P+25,0X1.F4P+3] 3 = [-0x1.444cccccccccep+8,0x1.4p+1]; pownRev [0X1.0C6F7A0B5ED8DP-20,0X1.94C75E6362A6P+3] 3 = [0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1]; pownRev [-0X1.B6F9DB22D0E55P+2,-0X1.266559F6EC5B1P-5] 3 = [-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2]; pownRev [empty] 7 = [empty]; pownRev [entire] 7 = [entire]; pownRev [0.0,0.0] 7 = [0.0,0.0]; pownRev [-0.0,-0.0] 7 = [0.0,0.0]; pownRev [0X1.F91D1B185493BP+25,0X1.F91D1B185493CP+25] 7 = [0x1.a333333333332p+3,0x1.a333333333334p+3]; pownRev [-0X1.07B1DA32F9B59P+90,-0X1.07B1DA32F9B58P+90] 7 = [-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12]; pownRev [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023] 7 = [0x1.381147622f886p+146,0x1.381147622f887p+146]; pownRev [-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023] 7 = [-0x1.381147622f887p+146,-0x1.381147622f886p+146]; pownRev [0.0,infinity] 7 = [0.0,infinity]; pownRev [-0.0,infinity] 7 = [0.0,infinity]; pownRev [-infinity,0.0] 7 = [-infinity,0.0]; pownRev [-infinity,-0.0] 7 = [-infinity,0.0]; pownRev [-0X1.4F109959E6D7FP+58,0X1.312DP+9] 7 = [-0x1.444cccccccccep+8,0x1.4p+1]; pownRev [0X1.6849B86A12B9BP-47,0X1.74D0373C76313P+8] 7 = [0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1]; pownRev [-0X1.658C775099757P+6,-0X1.BEE30301BF47AP-12] 7 = [-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2]; pownRev [empty] -2 = [empty]; pownRev [0.0,infinity] -2 = [entire]; pownRev [-0.0,infinity] -2 = [entire]; pownRev [0.0,0.0] -2 = [empty]; pownRev [-0.0,-0.0] -2 = [empty]; pownRev [-10.0,0.0] -2 = [empty]; pownRev [-10.0,-0.0] -2 = [empty]; pownRev [0X1.7DE3A077D1568P-8,0X1.7DE3A077D1569P-8] -2 = [-0x1.a333333333334p+3,0x1.a333333333334p+3]; pownRev [0X1.3570290CD6E14P-26,0X1.3570290CD6E15P-26] -2 = [-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12]; pownRev [0X0P+0,0X0.0000000000001P-1022] -2 = [entire]; pownRev [0X1.3F0C482C977C9P-17,infinity] -2 = [-0x1.444cccccccccep+8,0x1.444cccccccccep+8]; pownRev [0X1.793D85EF38E47P-3,0X1.388P+13] -2 = [-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1]; pownRev [0X1.1BA81104F6C8P-2,0X1.25D8FA1F801E1P+3] -2 = [-0x1.e666666666667p+0,0x1.e666666666667p+0]; pownRev [empty] -8 = [empty]; pownRev [0.0,infinity] -8 = [entire]; pownRev [-0.0,infinity] -8 = [entire]; pownRev [0.0,0.0] -8 = [empty]; pownRev [-0.0,-0.0] -8 = [empty]; pownRev [0X1.3CEF39247CA6DP-30,0X1.3CEF39247CA6EP-30] -8 = [-0x1.a333333333334p+3,0x1.a333333333334p+3]; pownRev [0X1.113D9EF0A99ACP-103,0X1.113D9EF0A99ADP-103] -8 = [-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12]; pownRev [0X0P+0,0X0.0000000000001P-1022] -8 = [entire]; pownRev [0X1.34CC3764D1E0CP-67,infinity] -8 = [-0x1.444cccccccccep+8,0x1.444cccccccccep+8]; pownRev [0X1.2DC80DB11AB7CP-10,0X1.1C37937E08P+53] -8 = [-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1]; pownRev [0X1.81E104E61630DP-8,0X1.BC64F21560E34P+12] -8 = [-0x1.e666666666667p+0,0x1.e666666666667p+0]; pownRev [empty] -1 = [empty]; pownRev [entire] -1 = [entire]; pownRev [0.0,0.0] -1 = [empty]; pownRev [-0.0,-0.0] -1 = [empty]; pownRev [0X1.38ABF82EE6986P-4,0X1.38ABF82EE6987P-4] -1 = [0x1.a333333333332p+3,0x1.a333333333335p+3]; pownRev [-0X1.197422C9048BFP-13,-0X1.197422C9048BEP-13] -1 = [-0x1.d1b251eb851eep+12,-0x1.d1b251eb851ebp+12]; pownRev [0X0.4P-1022,0X0.4000000000001P-1022] -1 = [0x1.ffffffffffff8p+1023,infinity]; pownRev [-0X0.4000000000001P-1022,-0X0.4P-1022] -1 = [-infinity,-0x1.ffffffffffff8p+1023]; pownRev [0.0,infinity] -1 = [0.0,infinity]; pownRev [-0.0,infinity] -1 = [0.0,infinity]; pownRev [-infinity,0.0] -1 = [-infinity,0.0]; pownRev [-infinity,-0.0] -1 = [-infinity,0.0]; pownRev [0X1.B77C278DBBE13P-2,0X1.9P+6] -1 = [0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1]; pownRev [-0X1.83E0F83E0F83EP+1,-0X1.0D79435E50D79P-1] -1 = [-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2]; pownRev [empty] -3 = [empty]; pownRev [entire] -3 = [entire]; pownRev [0.0,0.0] -3 = [empty]; pownRev [-0.0,-0.0] -3 = [empty]; pownRev [0X1.D26DF4D8B1831P-12,0X1.D26DF4D8B1832P-12] -3 = [0x1.a333333333332p+3,0x1.a333333333334p+3]; pownRev [-0X1.54347DED91B19P-39,-0X1.54347DED91B18P-39] -3 = [-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12]; pownRev [0X0P+0,0X0.0000000000001P-1022] -3 = [0x1p+358,infinity]; pownRev [-0X0.0000000000001P-1022,-0X0P+0] -3 = [-infinity,-0x1p+358]; pownRev [0.0,infinity] -3 = [0.0,infinity]; pownRev [-0.0,infinity] -3 = [0.0,infinity]; pownRev [-infinity,0.0] -3 = [-infinity,0.0]; pownRev [-infinity,-0.0] -3 = [-infinity,0.0]; pownRev [0X1.43CFBA61AACABP-4,0X1.E848P+19] -3 = [0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1]; pownRev [-0X1.BD393CE9E8E7CP+4,-0X1.2A95F6F7C066CP-3] -3 = [-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2]; pownRev [empty] -7 = [empty]; pownRev [entire] -7 = [entire]; pownRev [0.0,0.0] -7 = [empty]; pownRev [-0.0,-0.0] -7 = [empty]; pownRev [0X1.037D76C912DBCP-26,0X1.037D76C912DBDP-26] -7 = [0x1.a333333333332p+3,0x1.a333333333334p+3]; pownRev [-0X1.F10F41FB8858FP-91,-0X1.F10F41FB8858EP-91] -7 = [-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12]; pownRev [0X0P+0,0X0.0000000000001P-1022] -7 = [0x1.588cea3f093bcp+153,infinity]; pownRev [-0X0.0000000000001P-1022,-0X0P+0] -7 = [-infinity,-0x1.588cea3f093bcp+153]; pownRev [0.0,infinity] -7 = [0.0,infinity]; pownRev [-0.0,infinity] -7 = [0.0,infinity]; pownRev [-infinity,0.0] -7 = [-infinity,0.0]; pownRev [-infinity,-0.0] -7 = [-infinity,0.0]; pownRev [0X1.5F934D64162A9P-9,0X1.6BCC41E9P+46] -7 = [0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1]; pownRev [-0X1.254CDD3711DDBP+11,-0X1.6E95C4A761E19P-7] -7 = [-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2]; } testcase minimal_pownRevBin_test { pownRevBin [empty] [1.0,1.0] 0 = [empty]; pownRevBin [1.0,1.0] [1.0,1.0] 0 = [1.0,1.0]; pownRevBin [-1.0,5.0] [-51.0,12.0] 0 = [-51.0,12.0]; pownRevBin [-1.0,0.0] [5.0,10.0] 0 = [empty]; pownRevBin [-1.0,-0.0] [-1.0,1.0] 0 = [empty]; pownRevBin [1.1,10.0] [1.0,41.0] 0 = [empty]; pownRevBin [empty] [0.0,100.1] 1 = [empty]; pownRevBin [entire] [-5.1,10.0] 1 = [-5.1,10.0]; pownRevBin [0.0,0.0] [-10.0,5.1] 1 = [0.0,0.0]; pownRevBin [-0.0,-0.0] [1.0,5.0] 1 = [empty]; pownRevBin [empty] [5.0,17.1] 2 = [empty]; pownRevBin [-5.0,-1.0] [5.0,17.1] 2 = [empty]; pownRevBin [0.0,infinity] [5.6,27.544] 2 = [5.6,27.544]; pownRevBin [0.0,0.0] [1.0,2.0] 2 = [empty]; pownRevBin [0X1.A36E2EB1C432CP-14,0X1.5B7318FC50482P+2] [1.0,infinity] 2 = [1.0,0x1.2a3d70a3d70a5p+1]; pownRevBin [0X1.BE0DED288CE7P-4,0X1.CE147AE147AE1P+1] [-infinity,-1.0] 2 = [-0x1.e666666666667p+0,-1.0]; pownRevBin [empty] [-23.0,-1.0] 3 = [empty]; pownRevBin [entire] [-23.0,-1.0] 3 = [-23.0,-1.0]; pownRevBin [0.0,0.0] [1.0,2.0] 3 = [empty]; pownRevBin [0X1.0C6F7A0B5ED8DP-20,0X1.94C75E6362A6P+3] [1.0,infinity] 3 = [1.0,0x1.2a3d70a3d70a5p+1]; pownRevBin [-0X1.B6F9DB22D0E55P+2,-0X1.266559F6EC5B1P-5] [-infinity,-1.0] 3 = [-0x1.e666666666667p+0,-1.0]; pownRevBin [empty] [-3.0,17.3] -2 = [empty]; pownRevBin [0.0,infinity] [-5.1,-0.1] -2 = [-5.1,-0.1]; pownRevBin [0.0,0.0] [27.2,55.1] -2 = [empty]; pownRevBin [0X1.3F0C482C977C9P-17,infinity] [-infinity,-0x1.FFFFFFFFFFFFFp1023] -2 = [empty]; pownRevBin [0X1.793D85EF38E47P-3,0X1.388P+13] [1.0,infinity] -2 = [1.0,0x1.2a3d70a3d70a5p+1]; pownRevBin [0X1.1BA81104F6C8P-2,0X1.25D8FA1F801E1P+3] [-infinity,-1.0] -2 = [-0x1.e666666666667p+0,-1.0]; pownRevBin [empty] [-5.1,55.5] -1 = [empty]; pownRevBin [entire] [-5.1,55.5] -1 = [-5.1,55.5]; pownRevBin [0.0,0.0] [-5.1,55.5] -1 = [empty]; pownRevBin [-infinity,-0.0] [-1.0,1.0] -1 = [-1.0,0.0]; pownRevBin [0X1.B77C278DBBE13P-2,0X1.9P+6] [-1.0,0.0] -1 = [empty]; pownRevBin [empty] [-5.1,55.5] -3 = [empty]; pownRevBin [entire] [-5.1,55.5] -3 = [-5.1,55.5]; pownRevBin [0.0,0.0] [-5.1,55.5] -3 = [empty]; pownRevBin [-infinity,0.0] [5.1,55.5] -3 = [empty]; pownRevBin [-infinity,-0.0] [-32.0,1.1] -3 = [-32.0,0.0]; } testcase minimal_pownRev_dec_test { pownRev [empty]_trv 0 = [empty]_trv; pownRev [1.0,1.0]_com 0 = [entire]_trv; pownRev [-1.0,5.0]_dac 0 = [entire]_trv; pownRev [-1.0,0.0]_def 0 = [empty]_trv; pownRev [-1.0,-0.0]_dac 0 = [empty]_trv; pownRev [1.1,10.0]_com 0 = [empty]_trv; pownRev [empty]_trv 1 = [empty]_trv; pownRev [entire]_def 1 = [entire]_trv; pownRev [0.0,0.0]_com 1 = [0.0,0.0]_trv; pownRev [-0.0,-0.0]_dac 1 = [0.0,0.0]_trv; pownRev [13.1,13.1]_def 1 = [13.1,13.1]_trv; pownRev [-7451.145,-7451.145]_dac 1 = [-7451.145,-7451.145]_trv; pownRev [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_com 1 = [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_trv; pownRev [-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023]_com 1 = [-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023]_trv; pownRev [0.0,infinity]_dac 1 = [0.0,infinity]_trv; pownRev [-0.0,infinity]_dac 1 = [0.0,infinity]_trv; pownRev [-infinity,0.0]_def 1 = [-infinity,0.0]_trv; pownRev [-infinity,-0.0]_def 1 = [-infinity,0.0]_trv; pownRev [-324.3,2.5]_dac 1 = [-324.3,2.5]_trv; pownRev [0.01,2.33]_com 1 = [0.01,2.33]_trv; pownRev [-1.9,-0.33]_def 1 = [-1.9,-0.33]_trv; pownRev [empty]_trv 2 = [empty]_trv; pownRev [0.0,infinity]_dac 2 = [entire]_trv; pownRev [-0.0,infinity]_def 2 = [entire]_trv; pownRev [0.0,0.0]_com 2 = [0.0,0.0]_trv; pownRev [-0.0,-0.0]_dac 2 = [0.0,0.0]_trv; pownRev [0X1.573851EB851EBP+7,0X1.573851EB851ECP+7]_def 2 = [-0x1.a333333333334p+3,0x1.a333333333334p+3]_trv; pownRev [0X1.A794A4E7CFAADP+25,0X1.A794A4E7CFAAEP+25]_def 2 = [-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12]_trv; pownRev [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_dac 2 = [-0x1p+512,0x1p+512]_trv; pownRev [0.0,0X1.9AD27D70A3D72P+16]_dac 2 = [-0x1.444cccccccccep+8,0x1.444cccccccccep+8]_trv; pownRev [-0.0,0X1.9AD27D70A3D72P+16]_def 2 = [-0x1.444cccccccccep+8,0x1.444cccccccccep+8]_trv; pownRev [0X1.A36E2EB1C432CP-14,0X1.5B7318FC50482P+2]_com 2 = [-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1]_trv; pownRev [0X1.BE0DED288CE7P-4,0X1.CE147AE147AE1P+1]_def 2 = [-0x1.e666666666667p+0,0x1.e666666666667p+0]_trv; pownRev [empty]_trv 8 = [empty]_trv; pownRev [entire]_def 8 = [entire]_trv; pownRev [0.0,infinity]_dac 8 = [entire]_trv; pownRev [-0.0,infinity]_dac 8 = [entire]_trv; pownRev [0.0,0.0]_def 8 = [0.0,0.0]_trv; pownRev [-0.0,-0.0]_dac 8 = [0.0,0.0]_trv; pownRev [0X1.9D8FD495853F5P+29,0X1.9D8FD495853F6P+29]_com 8 = [-0x1.a333333333334p+3,0x1.a333333333334p+3]_trv; pownRev [0X1.DFB1BB622E70DP+102,0X1.DFB1BB622E70EP+102]_dac 8 = [-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12]_trv; pownRev [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_def 8 = [-0x1p+128,0x1p+128]_trv; pownRev [0.0,0X1.A87587109655P+66]_dac 8 = [-0x1.444cccccccccep+8,0x1.444cccccccccep+8]_trv; pownRev [-0.0,0X1.A87587109655P+66]_def 8 = [-0x1.444cccccccccep+8,0x1.444cccccccccep+8]_trv; pownRev [0X1.CD2B297D889BDP-54,0X1.B253D9F33CE4DP+9]_com 8 = [-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1]_trv; pownRev [0X1.26F1FCDD502A3P-13,0X1.53ABD7BFC4FC6P+7]_dac 8 = [-0x1.e666666666667p+0,0x1.e666666666667p+0]_trv; pownRev [empty]_trv 3 = [empty]_trv; pownRev [entire]_def 3 = [entire]_trv; pownRev [0.0,0.0]_dac 3 = [0.0,0.0]_trv; pownRev [-0.0,-0.0]_def 3 = [0.0,0.0]_trv; pownRev [0X1.1902E978D4FDEP+11,0X1.1902E978D4FDFP+11]_com 3 = [0x1.a333333333332p+3,0x1.a333333333334p+3]_trv; pownRev [-0X1.81460637B9A3DP+38,-0X1.81460637B9A3CP+38]_def 3 = [-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12]_trv; pownRev [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_dac 3 = [0x1.428a2f98d728ap+341,0x1.428a2f98d728bp+341]_trv; pownRev [-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023]_com 3 = [-0x1.428a2f98d728bp+341, -0x1.428a2f98d728ap+341]_trv; pownRev [0.0,infinity]_def 3 = [0.0,infinity]_trv; pownRev [-0.0,infinity]_def 3 = [0.0,infinity]_trv; pownRev [-infinity,0.0]_dac 3 = [-infinity,0.0]_trv; pownRev [-infinity,-0.0]_def 3 = [-infinity,0.0]_trv; pownRev [-0X1.0436D2F418938P+25,0X1.F4P+3]_com 3 = [-0x1.444cccccccccep+8,0x1.4p+1]_trv; pownRev [0X1.0C6F7A0B5ED8DP-20,0X1.94C75E6362A6P+3]_dac 3 = [0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1]_trv; pownRev [-0X1.B6F9DB22D0E55P+2,-0X1.266559F6EC5B1P-5]_def 3 = [-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2]_trv; pownRev [empty]_trv 7 = [empty]_trv; pownRev [entire]_def 7 = [entire]_trv; pownRev [0.0,0.0]_com 7 = [0.0,0.0]_trv; pownRev [-0.0,-0.0]_dac 7 = [0.0,0.0]_trv; pownRev [0X1.F91D1B185493BP+25,0X1.F91D1B185493CP+25]_def 7 = [0x1.a333333333332p+3,0x1.a333333333334p+3]_trv; pownRev [-0X1.07B1DA32F9B59P+90,-0X1.07B1DA32F9B58P+90]_dac 7 = [-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12]_trv; pownRev [0x1.FFFFFFFFFFFFFp1023,0x1.FFFFFFFFFFFFFp1023]_com 7 = [0x1.381147622f886p+146,0x1.381147622f887p+146]_trv; pownRev [-0x1.FFFFFFFFFFFFFp1023,-0x1.FFFFFFFFFFFFFp1023]_def 7 = [-0x1.381147622f887p+146,-0x1.381147622f886p+146]_trv; pownRev [0.0,infinity]_dac 7 = [0.0,infinity]_trv; pownRev [-0.0,infinity]_dac 7 = [0.0,infinity]_trv; pownRev [-infinity,0.0]_def 7 = [-infinity,0.0]_trv; pownRev [-infinity,-0.0]_def 7 = [-infinity,0.0]_trv; pownRev [-0X1.4F109959E6D7FP+58,0X1.312DP+9]_dac 7 = [-0x1.444cccccccccep+8,0x1.4p+1]_trv; pownRev [0X1.6849B86A12B9BP-47,0X1.74D0373C76313P+8]_com 7 = [0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1]_trv; pownRev [-0X1.658C775099757P+6,-0X1.BEE30301BF47AP-12]_def 7 = [-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2]_trv; pownRev [empty]_trv -2 = [empty]_trv; pownRev [0.0,infinity]_dac -2 = [entire]_trv; pownRev [-0.0,infinity]_dac -2 = [entire]_trv; pownRev [0.0,0.0]_def -2 = [empty]_trv; pownRev [-0.0,-0.0]_com -2 = [empty]_trv; pownRev [-10.0,0.0]_dac -2 = [empty]_trv; pownRev [-10.0,-0.0]_def -2 = [empty]_trv; pownRev [0X1.7DE3A077D1568P-8,0X1.7DE3A077D1569P-8]_dac -2 = [-0x1.a333333333334p+3,0x1.a333333333334p+3]_trv; pownRev [0X1.3570290CD6E14P-26,0X1.3570290CD6E15P-26]_def -2 = [-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12]_trv; pownRev [0X0P+0,0X0.0000000000001P-1022]_com -2 = [entire]_trv; pownRev [0X1.3F0C482C977C9P-17,infinity]_dac -2 = [-0x1.444cccccccccep+8,0x1.444cccccccccep+8]_trv; pownRev [0X1.793D85EF38E47P-3,0X1.388P+13]_def -2 = [-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1]_trv; pownRev [0X1.1BA81104F6C8P-2,0X1.25D8FA1F801E1P+3]_com -2 = [-0x1.e666666666667p+0,0x1.e666666666667p+0]_trv; pownRev [empty]_trv -8 = [empty]_trv; pownRev [0.0,infinity]_def -8 = [entire]_trv; pownRev [-0.0,infinity]_dac -8 = [entire]_trv; pownRev [0.0,0.0]_def -8 = [empty]_trv; pownRev [-0.0,-0.0]_dac -8 = [empty]_trv; pownRev [0X1.3CEF39247CA6DP-30,0X1.3CEF39247CA6EP-30]_com -8 = [-0x1.a333333333334p+3,0x1.a333333333334p+3]_trv; pownRev [0X1.113D9EF0A99ACP-103,0X1.113D9EF0A99ADP-103]_def -8 = [-0x1.d1b251eb851edp+12,0x1.d1b251eb851edp+12]_trv; pownRev [0X0P+0,0X0.0000000000001P-1022]_dac -8 = [entire]_trv; pownRev [0X1.34CC3764D1E0CP-67,infinity]_def -8 = [-0x1.444cccccccccep+8,0x1.444cccccccccep+8]_trv; pownRev [0X1.2DC80DB11AB7CP-10,0X1.1C37937E08P+53]_com -8 = [-0x1.2a3d70a3d70a5p+1,0x1.2a3d70a3d70a5p+1]_trv; pownRev [0X1.81E104E61630DP-8,0X1.BC64F21560E34P+12]_def -8 = [-0x1.e666666666667p+0,0x1.e666666666667p+0]_trv; pownRev [empty]_trv -1 = [empty]_trv; pownRev [entire]_def -1 = [entire]_trv; pownRev [0.0,0.0]_dac -1 = [empty]_trv; pownRev [-0.0,-0.0]_dac -1 = [empty]_trv; pownRev [0X1.38ABF82EE6986P-4,0X1.38ABF82EE6987P-4]_def -1 = [0x1.a333333333332p+3,0x1.a333333333335p+3]_trv; pownRev [-0X1.197422C9048BFP-13,-0X1.197422C9048BEP-13]_dac -1 = [-0x1.d1b251eb851eep+12,-0x1.d1b251eb851ebp+12]_trv; pownRev [0X0.4P-1022,0X0.4000000000001P-1022]_dac -1 = [0x1.ffffffffffff8p+1023,infinity]_trv; pownRev [-0X0.4000000000001P-1022,-0X0.4P-1022]_def -1 = [-infinity,-0x1.ffffffffffff8p+1023]_trv; pownRev [0.0,infinity]_dac -1 = [0.0,infinity]_trv; pownRev [-0.0,infinity]_dac -1 = [0.0,infinity]_trv; pownRev [-infinity,0.0]_dac -1 = [-infinity,0.0]_trv; pownRev [-infinity,-0.0]_def -1 = [-infinity,0.0]_trv; pownRev [0X1.B77C278DBBE13P-2,0X1.9P+6]_com -1 = [0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1]_trv; pownRev [-0X1.83E0F83E0F83EP+1,-0X1.0D79435E50D79P-1]_com -1 = [-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2]_trv; pownRev [empty]_trv -3 = [empty]_trv; pownRev [entire]_def -3 = [entire]_trv; pownRev [0.0,0.0]_def -3 = [empty]_trv; pownRev [-0.0,-0.0]_dac -3 = [empty]_trv; pownRev [0X1.D26DF4D8B1831P-12,0X1.D26DF4D8B1832P-12]_com -3 = [0x1.a333333333332p+3,0x1.a333333333334p+3]_trv; pownRev [-0X1.54347DED91B19P-39,-0X1.54347DED91B18P-39]_def -3 = [-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12]_trv; pownRev [0X0P+0,0X0.0000000000001P-1022]_dac -3 = [0x1p+358,infinity]_trv; pownRev [-0X0.0000000000001P-1022,-0X0P+0]_def -3 = [-infinity,-0x1p+358]_trv; pownRev [0.0,infinity]_dac -3 = [0.0,infinity]_trv; pownRev [-0.0,infinity]_dac -3 = [0.0,infinity]_trv; pownRev [-infinity,0.0]_def -3 = [-infinity,0.0]_trv; pownRev [-infinity,-0.0]_def -3 = [-infinity,0.0]_trv; pownRev [0X1.43CFBA61AACABP-4,0X1.E848P+19]_com -3 = [0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1]_trv; pownRev [-0X1.BD393CE9E8E7CP+4,-0X1.2A95F6F7C066CP-3]_def -3 = [-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2]_trv; pownRev [empty]_trv -7 = [empty]_trv; pownRev [entire]_def -7 = [entire]_trv; pownRev [0.0,0.0]_com -7 = [empty]_trv; pownRev [-0.0,-0.0]_def -7 = [empty]_trv; pownRev [0X1.037D76C912DBCP-26,0X1.037D76C912DBDP-26]_dac -7 = [0x1.a333333333332p+3,0x1.a333333333334p+3]_trv; pownRev [-0X1.F10F41FB8858FP-91,-0X1.F10F41FB8858EP-91]_dac -7 = [-0x1.d1b251eb851edp+12,-0x1.d1b251eb851ebp+12]_trv; pownRev [0X0P+0,0X0.0000000000001P-1022]_def -7 = [0x1.588cea3f093bcp+153,infinity]_trv; pownRev [-0X0.0000000000001P-1022,-0X0P+0]_def -7 = [-infinity,-0x1.588cea3f093bcp+153]_trv; pownRev [0.0,infinity]_dac -7 = [0.0,infinity]_trv; pownRev [-0.0,infinity]_def -7 = [0.0,infinity]_trv; pownRev [-infinity,0.0]_dac -7 = [-infinity,0.0]_trv; pownRev [-infinity,-0.0]_def -7 = [-infinity,0.0]_trv; pownRev [0X1.5F934D64162A9P-9,0X1.6BCC41E9P+46]_com -7 = [0x1.47ae147ae147ap-7,0x1.2a3d70a3d70a5p+1]_trv; pownRev [-0X1.254CDD3711DDBP+11,-0X1.6E95C4A761E19P-7]_com -7 = [-0x1.e666666666667p+0,-0x1.51eb851eb851ep-2]_trv; } testcase minimal_pownRev_dec_bin_test { pownRevBin [empty]_trv [1.0,1.0]_def 0 = [empty]_trv; pownRevBin [1.0,1.0]_dac [1.0,1.0]_dac 0 = [1.0,1.0]_trv; pownRevBin [-1.0,5.0]_def [-51.0,12.0]_dac 0 = [-51.0,12.0]_trv; pownRevBin [-1.0,0.0]_com [5.0,10.0]_dac 0 = [empty]_trv; pownRevBin [-1.0,-0.0]_dac [-1.0,1.0]_def 0 = [empty]_trv; pownRevBin [1.1,10.0]_def [1.0,41.0]_dac 0 = [empty]_trv; pownRevBin [empty]_trv [0.0,100.1]_dac 1 = [empty]_trv; pownRevBin [entire]_def [-5.1,10.0]_def 1 = [-5.1,10.0]_trv; pownRevBin [0.0,0.0]_com [-10.0,5.1]_dac 1 = [0.0,0.0]_trv; pownRevBin [-0.0,-0.0]_def [1.0,5.0]_dac 1 = [empty]_trv; pownRevBin [empty]_trv [5.0,17.1]_def 2 = [empty]_trv; pownRevBin [0.0,infinity]_dac [5.6,27.544]_dac 2 = [5.6,27.544]_trv; pownRevBin [0.0,0.0]_def [1.0,2.0]_def 2 = [empty]_trv; pownRevBin [0X1.A36E2EB1C432CP-14,0X1.5B7318FC50482P+2]_com [1.0,infinity]_def 2 = [1.0,0x1.2a3d70a3d70a5p+1]_trv; pownRevBin [0X1.BE0DED288CE7P-4,0X1.CE147AE147AE1P+1]_dac [-infinity,-1.0]_def 2 = [-0x1.e666666666667p+0,-1.0]_trv; pownRevBin [empty]_trv [-23.0,-1.0]_dac 3 = [empty]_trv; pownRevBin [entire]_def [-23.0,-1.0]_com 3 = [-23.0,-1.0]_trv; pownRevBin [0.0,0.0]_def [1.0,2.0]_dac 3 = [empty]_trv; pownRevBin [0X1.0C6F7A0B5ED8DP-20,0X1.94C75E6362A6P+3]_com [1.0,infinity]_dac 3 = [1.0,0x1.2a3d70a3d70a5p+1]_trv; pownRevBin [-0X1.B6F9DB22D0E55P+2,-0X1.266559F6EC5B1P-5]_com [-infinity,-1.0]_dac 3 = [-0x1.e666666666667p+0,-1.0]_trv; pownRevBin [empty]_trv [-3.0,17.3]_def -2 = [empty]_trv; pownRevBin [0.0,infinity]_dac [-5.1,-0.1]_dac -2 = [-5.1,-0.1]_trv; pownRevBin [0.0,0.0]_def [27.2,55.1]_dac -2 = [empty]_trv; pownRevBin [0X1.3F0C482C977C9P-17,infinity]_def [-infinity,-0x1.FFFFFFFFFFFFFp1023]_dac -2 = [empty]_trv; pownRevBin [0X1.793D85EF38E47P-3,0X1.388P+13]_com [1.0,infinity]_dac -2 = [1.0,0x1.2a3d70a3d70a5p+1]_trv; pownRevBin [0X1.1BA81104F6C8P-2,0X1.25D8FA1F801E1P+3]_com [-infinity,-1.0]_dac -2 = [-0x1.e666666666667p+0,-1.0]_trv; pownRevBin [empty]_trv [-5.1,55.5]_def -1 = [empty]_trv; pownRevBin [entire]_def [-5.1,55.5]_dac -1 = [-5.1,55.5]_trv; pownRevBin [0.0,0.0]_dac [-5.1,55.5]_def -1 = [empty]_trv; pownRevBin [-infinity,-0.0]_dac [-1.0,1.0]_com -1 = [-1.0,0.0]_trv; pownRevBin [0X1.B77C278DBBE13P-2,0X1.9P+6]_def [-1.0,0.0]_dac -1 = [empty]_trv; pownRevBin [empty]_trv [-5.1,55.5]_dac -3 = [empty]_trv; pownRevBin [entire]_def [-5.1,55.5]_def -3 = [-5.1,55.5]_trv; pownRevBin [0.0,0.0]_def [-5.1,55.5]_def -3 = [empty]_trv; pownRevBin [-infinity,0.0]_dac [5.1,55.5]_com -3 = [empty]_trv; pownRevBin [-infinity,-0.0]_dac [-32.0,1.1]_def -3 = [-32.0,0.0]_trv; } testcase minimal_sinRev_test { sinRev [empty] = [empty]; sinRev [-2.0,-1.1] = [empty]; sinRev [1.1, 2.0] = [empty]; sinRev [-1.0,1.0] = [entire]; sinRev [0.0,0.0] = [entire]; sinRev [0X1.1A62633145C06P-53,0X1.1A62633145C07P-53] = [entire]; } testcase minimal_sinRevBin_test { sinRevBin [empty] [-1.2,12.1] = [empty]; sinRevBin [-2.0,-1.1] [-5.0, 5.0] = [empty]; sinRevBin [1.1, 2.0] [-5.0, 5.0] = [empty]; sinRevBin [-1.0,1.0] [-1.2,12.1] = [-1.2,12.1]; sinRevBin [0.0,0.0] [-1.0,1.0] = [0.0,0.0]; sinRevBin [-0.0,-0.0] [2.0,2.5] = [empty]; sinRevBin [-0.0,-0.0] [3.0,3.5] = [0x1.921fb54442d18p+1,0x1.921fb54442d19p+1]; sinRevBin [0X1.FFFFFFFFFFFFFP-1,0X1P+0] [1.57,1.58 ] = [0x1.921fb50442d18p+0,0x1.921fb58442d1ap+0]; sinRevBin [0.0,0X1P+0] [-0.1,1.58] = [0.0,1.58]; sinRevBin [0X1.1A62633145C06P-53,0X1.1A62633145C07P-53] [3.14,3.15] = [0X1.921FB54442D17P+1,0X1.921FB54442D19P+1]; sinRevBin [-0X1.72CECE675D1FDP-52,-0X1.72CECE675D1FCP-52] [3.14,3.15] = [0X1.921FB54442D18P+1,0X1.921FB54442D1aP+1]; sinRevBin [-0X1.72CECE675D1FDP-52,0X1.1A62633145C07P-53] [3.14,3.15] = [0X1.921FB54442D17P+1,0X1.921FB54442D1aP+1]; sinRevBin [0.0,1.0] [-0.1,3.15] = [0.0,0X1.921FB54442D19P+1]; sinRevBin [0.0,1.0] [-0.1,3.15] = [-0.0,0X1.921FB54442D19P+1]; sinRevBin [-0X1.72CECE675D1FDP-52,1.0] [-0.1,3.15] = [-0x1.72cece675d1fep-52,0X1.921FB54442D1aP+1]; sinRevBin [-0X1.72CECE675D1FDP-52,1.0] [0.0,3.15] = [0.0,0X1.921FB54442D1aP+1]; sinRevBin [0X1.1A62633145C06P-53,0X1P+0] [3.14,3.15] = [3.14,0X1.921FB54442D19P+1]; sinRevBin [-0X1.72CECE675D1FDP-52,0X1P+0] [1.57,3.15] = [1.57,0X1.921FB54442D1AP+1]; sinRevBin [0X1.1A62633145C06P-53,0X1.1A62633145C07P-53] [-infinity,3.15] = [-infinity,0X1.921FB54442D19P+1]; sinRevBin [-0X1.72CECE675D1FDP-52,-0X1.72CECE675D1FCP-52] [3.14,infinity] = [0X1.921FB54442D18P+1,infinity]; } testcase minimal_sinRev_dec_test { sinRev [empty]_trv = [empty]_trv; sinRev [-2.0,-1.1]_com = [empty]_trv; sinRev [1.1, 2.0]_dac = [empty]_trv; sinRev [-1.0,1.0]_com = [entire]_trv; sinRev [0.0,0.0]_dac = [entire]_trv; sinRev [0X1.1A62633145C06P-53,0X1.1A62633145C07P-53]_def = [entire]_trv; } testcase minimal_sinRev_dec_bin_test { sinRevBin [empty]_trv [-1.2,12.1]_com = [empty]_trv; sinRevBin [-2.0,-1.1]_def [-5.0, 5.0]_def = [empty]_trv; sinRevBin [1.1, 2.0]_dac [-5.0, 5.0]_com = [empty]_trv; sinRevBin [-1.0,1.0]_com [-1.2,12.1]_def = [-1.2,12.1]_trv; sinRevBin [0.0,0.0]_dac [-1.0,1.0]_def = [0.0,0.0]_trv; sinRevBin [-0.0,-0.0]_def [2.0,2.5]_trv = [empty]_trv; sinRevBin [-0.0,-0.0]_def [3.0,3.5]_dac = [0x1.921fb54442d18p+1,0x1.921fb54442d19p+1]_trv; sinRevBin [0X1.FFFFFFFFFFFFFP-1,0X1P+0]_dac [1.57,1.58]_dac = [0x1.921fb50442d18p+0,0x1.921fb58442d1ap+0]_trv; sinRevBin [0.0,0X1P+0]_com [-0.1,1.58]_dac = [0.0,1.58]_trv; sinRevBin [0X1.1A62633145C06P-53,0X1.1A62633145C07P-53]_com [3.14,3.15]_def = [0X1.921FB54442D17P+1,0X1.921FB54442D19P+1]_trv; sinRevBin [-0X1.72CECE675D1FDP-52,-0X1.72CECE675D1FCP-52]_com [3.14,3.15]_dac = [0X1.921FB54442D18P+1,0X1.921FB54442D1aP+1]_trv; sinRevBin [-0X1.72CECE675D1FDP-52,0X1.1A62633145C07P-53]_dac [3.14,3.15]_com = [0X1.921FB54442D17P+1,0X1.921FB54442D1aP+1]_trv; sinRevBin [0.0,1.0]_def [-0.1,3.15]_def = [0.0,0X1.921FB54442D19P+1]_trv; sinRevBin [0.0,1.0]_dac [-0.1,3.15]_com = [-0.0,0X1.921FB54442D19P+1]_trv; sinRevBin [-0X1.72CECE675D1FDP-52,1.0]_def [-0.1,3.15]_def = [-0x1.72cece675d1fep-52,0X1.921FB54442D1aP+1]_trv; sinRevBin [-0X1.72CECE675D1FDP-52,1.0]_com [0.0,3.15]_dac = [0.0,0X1.921FB54442D1aP+1]_trv; sinRevBin [0X1.1A62633145C06P-53,0X1P+0]_def [3.14,3.15]_com = [3.14,0X1.921FB54442D19P+1]_trv; sinRevBin [-0X1.72CECE675D1FDP-52,0X1P+0]_dac [1.57,3.15]_com = [1.57,0X1.921FB54442D1AP+1]_trv; sinRevBin [0X1.1A62633145C06P-53,0X1.1A62633145C07P-53]_com [-infinity,3.15]_dac = [-infinity,0X1.921FB54442D19P+1]_trv; sinRevBin [-0X1.72CECE675D1FDP-52,-0X1.72CECE675D1FCP-52]_com [3.14,infinity]_dac = [0X1.921FB54442D18P+1,infinity]_trv; } testcase minimal_cosRev_test { cosRev [empty] = [empty]; cosRev [-2.0,-1.1] = [empty]; cosRev [1.1, 2.0] = [empty]; cosRev [-1.0,1.0] = [entire]; cosRev [0.0,0.0] = [entire]; cosRev [0X1.1A62633145C06P-53,0X1.1A62633145C07P-53] = [entire]; } testcase minimal_cosRevBin_test { cosRevBin [empty] [-1.2,12.1] = [empty]; cosRevBin [-2.0,-1.1] [-5.0, 5.0] = [empty]; cosRevBin [1.1, 2.0] [-5.0, 5.0] = [empty]; cosRevBin [-1.0,1.0] [-1.2,12.1] = [-1.2,12.1]; cosRevBin [1.0,1.0] [-0.1,0.1] = [0.0,0.0]; cosRevBin [-1.0,-1.0] [3.14,3.15] = [0x1.921fb54442d18p+1,0x1.921fb54442d1ap+1]; cosRevBin [0X1.1A62633145C06P-54,0X1.1A62633145C07P-54] [1.57,1.58] = [0X1.921FB54442D17P+0,0X1.921FB54442D19P+0]; cosRevBin [-0X1.72CECE675D1FDP-53,-0X1.72CECE675D1FCP-53] [1.57,1.58] = [0X1.921FB54442D18P+0,0X1.921FB54442D1AP+0]; cosRevBin [-0X1.72CECE675D1FDP-53,0X1.1A62633145C07P-54] [1.57,1.58] = [0X1.921FB54442D17P+0,0X1.921FB54442D1aP+0]; cosRevBin [0X1.1A62633145C06P-54,1.0] [-2.0,2.0] = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]; cosRevBin [0X1.1A62633145C06P-54,1.0] [0.0,2.0] = [0.0,0X1.921FB54442D19P+0]; cosRevBin [-0X1.72CECE675D1FDP-53,1.0] [-0.1,1.5708] = [-0.1,0X1.921FB54442D1aP+0]; cosRevBin [-0X1P+0,-0X1.FFFFFFFFFFFFFP-1] [3.14,3.15] = [0x1.921fb52442d18p+1,0x1.921fb56442d1ap+1]; cosRevBin [-0X1P+0,-0X1.FFFFFFFFFFFFFP-1] [-3.15,-3.14] = [-0x1.921fb56442d1ap+1,-0x1.921fb52442d18p+1]; cosRevBin [-0X1P+0,-0X1.FFFFFFFFFFFFFP-1] [9.42,9.45] = [0x1.2d97c7eb321d2p+3,0x1.2d97c7fb321d3p+3]; cosRevBin [0X1.87996529F9D92P-1,1.0] [-1.0,0.1] = [-0x1.6666666666667p-1,0.1]; cosRevBin [-0X1.AA22657537205P-2,0X1.14A280FB5068CP-1] [0.0,2.1] = [0x1.fffffffffffffp-1,0x1.0000000000001p+1]; cosRevBin [0X1.1A62633145C06P-53,0X1.1A62633145C07P-53] [-infinity,1.58] = [-infinity,0X1.921FB54442D18P+0]; cosRevBin [0X1.1A62633145C06P-53,0X1.1A62633145C07P-53] [-infinity,1.5] = [-infinity,-0X1.921FB54442D17P+0]; cosRevBin [-0X1.72CECE675D1FDP-52,-0X1.72CECE675D1FCP-52] [-1.58,infinity] = [-0x1.921fb54442d1ap+0,infinity]; cosRevBin [-0X1.72CECE675D1FDP-52,-0X1.72CECE675D1FCP-52] [-1.5,infinity] = [0x1.921fb54442d19p+0,infinity]; } testcase minimal_cosRev_dec_test { cosRev [empty]_trv = [empty]_trv; cosRev [-2.0,-1.1]_def = [empty]_trv; cosRev [1.1, 2.0]_dac = [empty]_trv; cosRev [-1.0,1.0]_com = [entire]_trv; cosRev [0.0,0.0]_def = [entire]_trv; cosRev [0X1.1A62633145C06P-53,0X1.1A62633145C07P-53]_dac = [entire]_trv; } testcase minimal_cosRev_dec_bin_test { cosRevBin [empty]_trv [-1.2,12.1]_def = [empty]_trv; cosRevBin [-2.0,-1.1]_dac [-5.0, 5.0]_com = [empty]_trv; cosRevBin [1.1, 2.0]_dac [-5.0, 5.0]_com = [empty]_trv; cosRevBin [-1.0,1.0]_dac [-1.2,12.1]_def = [-1.2,12.1]_trv; cosRevBin [1.0,1.0]_def [-0.1,0.1]_dac = [0.0,0.0]_trv; cosRevBin [-1.0,-1.0]_com [3.14,3.15]_dac = [0x1.921fb54442d18p+1,0x1.921fb54442d1ap+1]_trv; cosRevBin [0X1.1A62633145C06P-54,0X1.1A62633145C07P-54]_def [1.57,1.58]_def = [0X1.921FB54442D17P+0,0X1.921FB54442D19P+0]_trv; cosRevBin [-0X1.72CECE675D1FDP-53,-0X1.72CECE675D1FCP-53]_dac [1.57,1.58]_dac = [0X1.921FB54442D18P+0,0X1.921FB54442D1AP+0]_trv; cosRevBin [-0X1.72CECE675D1FDP-53,0X1.1A62633145C07P-54]_com [1.57,1.58]_dac = [0X1.921FB54442D17P+0,0X1.921FB54442D1aP+0]_trv; cosRevBin [0X1.1A62633145C06P-54,1.0]_def [-2.0,2.0]_com = [-0X1.921FB54442D19P+0, 0X1.921FB54442D19P+0]_trv; cosRevBin [0X1.1A62633145C06P-54,1.0]_dac [0.0,2.0]_def = [0.0,0X1.921FB54442D19P+0]_trv; cosRevBin [-0X1.72CECE675D1FDP-53,1.0]_def [-0.1,1.5708]_dac = [-0.1,0X1.921FB54442D1aP+0]_trv; cosRevBin [-0X1P+0,-0X1.FFFFFFFFFFFFFP-1]_dac [3.14,3.15]_def = [0x1.921fb52442d18p+1,0x1.921fb56442d1ap+1]_trv; cosRevBin [-0X1P+0,-0X1.FFFFFFFFFFFFFP-1]_def [-3.15,-3.14]_com = [-0x1.921fb56442d1ap+1,-0x1.921fb52442d18p+1]_trv; cosRevBin [-0X1P+0,-0X1.FFFFFFFFFFFFFP-1]_def [9.42,9.45]_dac = [0x1.2d97c7eb321d2p+3,0x1.2d97c7fb321d3p+3]_trv; cosRevBin [0X1.87996529F9D92P-1,1.0]_dac [-1.0,0.1]_def = [-0x1.6666666666667p-1,0.1]_trv; cosRevBin [-0X1.AA22657537205P-2,0X1.14A280FB5068CP-1]_com [0.0,2.1]_dac = [0x1.fffffffffffffp-1,0x1.0000000000001p+1]_trv; cosRevBin [0X1.1A62633145C06P-53,0X1.1A62633145C07P-53]_com [-infinity,1.58]_dac = [-infinity,0X1.921FB54442D18P+0]_trv; cosRevBin [0X1.1A62633145C06P-53,0X1.1A62633145C07P-53]_def [-infinity,1.5]_dac = [-infinity,-0X1.921FB54442D17P+0]_trv; cosRevBin [-0X1.72CECE675D1FDP-52,-0X1.72CECE675D1FCP-52]_dac [-1.58,infinity]_dac = [-0x1.921fb54442d1ap+0,infinity]_trv; cosRevBin [-0X1.72CECE675D1FDP-52,-0X1.72CECE675D1FCP-52]_def [-1.5,infinity]_dac = [0x1.921fb54442d19p+0,infinity]_trv; } testcase minimal_tanRev_test { tanRev [empty] = [empty]; tanRev [-1.0,1.0] = [entire]; tanRev [-156.0,-12.0] = [entire]; tanRev [0.0,0.0] = [entire]; tanRev [0X1.1A62633145C06P-53,0X1.1A62633145C07P-53] = [entire]; } testcase minimal_tanRevBin_test { tanRevBin [empty] [-1.5708,1.5708] = [empty]; tanRevBin [entire] [-1.5708,1.5708] = [-1.5708,1.5708]; tanRevBin [0.0,0.0] [-1.5708,1.5708] = [0.0,0.0]; tanRevBin [0X1.D02967C31CDB4P+53,0X1.D02967C31CDB5P+53] [-1.5708,1.5708] = [-0x1.921fb54442d1bp+0,0x1.921fb54442d19p+0]; tanRevBin [-0X1.1A62633145C07P-53,-0X1.1A62633145C06P-53] [3.14,3.15] = [0X1.921FB54442D17P+1,0X1.921FB54442D19P+1]; tanRevBin [0X1.72CECE675D1FCP-52,0X1.72CECE675D1FDP-52] [-3.15,3.15] = [-0X1.921FB54442D19P+1,0X1.921FB54442D1aP+1]; tanRevBin [-0X1.D02967C31p+53,0X1.D02967C31p+53] [-infinity,1.5707965] = [-infinity, +0x1.921FB82C2BD7Fp0]; tanRevBin [-0X1.D02967C31p+53,0X1.D02967C31p+53] [-1.5707965,infinity] = [-0x1.921FB82C2BD7Fp0, +infinity]; tanRevBin [-0X1.D02967C31p+53,0X1.D02967C31p+53] [-1.5707965,1.5707965] = [-0x1.921FB82C2BD7Fp0, +0x1.921FB82C2BD7Fp0]; tanRevBin [-0X1.D02967C31CDB5P+53,0X1.D02967C31CDB5P+53] [-1.5707965,1.5707965] = [-1.5707965,1.5707965]; } testcase minimal_tanRev_dec_test { tanRev [empty]_trv = [empty]_trv; tanRev [-1.0,1.0]_com = [entire]_trv; tanRev [-156.0,-12.0]_dac = [entire]_trv; tanRev [0.0,0.0]_def = [entire]_trv; tanRev [0X1.1A62633145C06P-53,0X1.1A62633145C07P-53]_com = [entire]_trv; } testcase minimal_tanRev_dec_bin_test { tanRevBin [empty]_trv [-1.5708,1.5708]_def = [empty]_trv; tanRevBin [entire]_def [-1.5708,1.5708]_dac = [-1.5708,1.5708]_trv; tanRevBin [0.0,0.0]_com [-1.5708,1.5708]_def = [0.0,0.0]_trv; tanRevBin [0X1.D02967C31CDB4P+53,0X1.D02967C31CDB5P+53]_dac [-1.5708,1.5708]_def = [-0x1.921fb54442d1bp+0,0x1.921fb54442d19p+0]_trv; tanRevBin [-0X1.1A62633145C07P-53,-0X1.1A62633145C06P-53]_def [3.14,3.15]_dac = [0X1.921FB54442D17P+1,0X1.921FB54442D19P+1]_trv; tanRevBin [0X1.72CECE675D1FCP-52,0X1.72CECE675D1FDP-52]_com [-3.15,3.15]_com = [-0X1.921FB54442D19P+1,0X1.921FB54442D1aP+1]_trv; tanRevBin [-0X1.D02967C31p+53,0X1.D02967C31p+53]_def [-infinity,1.5707965]_def = [-infinity,0x1.921FB82C2BD7Fp0]_trv; tanRevBin [-0X1.D02967C31p+53,0X1.D02967C31p+53]_com [-1.5707965,infinity]_dac = [-0x1.921FB82C2BD7Fp0,infinity]_trv; tanRevBin [-0X1.D02967C31p+53,0X1.D02967C31p+53]_com [-1.5707965,1.5707965]_com = [-0x1.921FB82C2BD7Fp0,0x1.921FB82C2BD7Fp0]_trv; tanRevBin [-0X1.D02967C31CDB5P+53,0X1.D02967C31CDB5P+53]_dac [-1.5707965,1.5707965]_def = [-1.5707965,1.5707965]_trv; } testcase minimal_coshRev_test { coshRev [empty] = [empty]; coshRev [1.0,infinity] = [entire]; coshRev [0.0,infinity] = [entire]; coshRev [1.0,1.0] = [0.0,0.0]; coshRev [0X1.8B07551D9F55P+0,0X1.89BCA168970C6P+432] = [-0X1.2C903022DD7ABP+8,0X1.2C903022DD7ABP+8]; } testcase minimal_coshRevBin_test { coshRevBin [empty] [0.0,infinity] = [empty]; coshRevBin [1.0,infinity] [0.0,infinity] = [0.0,infinity]; coshRevBin [0.0,infinity] [1.0,2.0] = [1.0,2.0]; coshRevBin [1.0,1.0] [1.0,infinity] = [empty]; coshRevBin [0X1.8B07551D9F55P+0,0X1.89BCA168970C6P+432] [-infinity,0.0] = [-0X1.2C903022DD7ABP+8,-0x1.fffffffffffffp-1]; } testcase minimal_coshRev_dec_test { coshRev [empty]_trv = [empty]_trv; coshRev [1.0,infinity]_dac = [entire]_trv; coshRev [0.0,infinity]_dac = [entire]_trv; coshRev [1.0,1.0]_def = [0.0,0.0]_trv; coshRev [0X1.8B07551D9F55P+0,0X1.89BCA168970C6P+432]_com = [-0X1.2C903022DD7ABP+8,0X1.2C903022DD7ABP+8]_trv; } testcase minimal_coshRev_dec_bin_test { coshRevBin [empty]_trv [0.0,infinity]_dac = [empty]_trv; coshRevBin [1.0,infinity]_def [0.0,infinity]_dac = [0.0,infinity]_trv; coshRevBin [0.0,infinity]_def [1.0,2.0]_com = [1.0,2.0]_trv; coshRevBin [1.0,1.0]_dac [1.0,infinity]_def = [empty]_trv; coshRevBin [0X1.8B07551D9F55P+0,0X1.89BCA168970C6P+432]_com [-infinity,0.0]_dac = [-0X1.2C903022DD7ABP+8,-0x1.fffffffffffffp-1]_trv; } testcase minimal_mulRev_test { mulRev [empty] [1.0, 2.0] = [empty]; mulRev [1.0, 2.0] [empty] = [empty]; mulRev [empty] [empty] = [empty]; mulRev [-2.0, -0.1] [-2.1, -0.4] = [0X1.999999999999AP-3, 0X1.5P+4]; mulRev [-2.0, 0.0] [-2.1, -0.4] = [0X1.999999999999AP-3, infinity]; mulRev [-2.0, 1.1] [-2.1, -0.4] = [entire]; mulRev [0.0, 1.1] [-2.1, -0.4] = [-infinity, -0X1.745D1745D1745P-2]; mulRev [0.01, 1.1] [-2.1, -0.4] = [-0X1.A400000000001P+7, -0X1.745D1745D1745P-2]; mulRev [0.0, 0.0] [-2.1, -0.4] = [empty]; mulRev [-infinity, -0.1] [-2.1, -0.4] = [0.0, 0X1.5P+4]; mulRev [-infinity, 0.0] [-2.1, -0.4] = [0.0, infinity]; mulRev [-infinity, 1.1] [-2.1, -0.4] = [entire]; mulRev [-2.0, infinity] [-2.1, -0.4] = [entire]; mulRev [0.0, infinity] [-2.1, -0.4] = [-infinity, 0.0]; mulRev [0.01, infinity] [-2.1, -0.4] = [-0X1.A400000000001P+7, 0.0]; mulRev [entire] [-2.1, -0.4] = [entire]; mulRev [-2.0, -0.1] [-2.1, 0.0] = [0.0, 0X1.5P+4]; mulRev [-2.0, 0.0] [-2.1, 0.0] = [entire]; mulRev [-2.0, 1.1] [-2.1, 0.0] = [entire]; mulRev [0.0, 1.1] [-2.1, 0.0] = [entire]; mulRev [0.01, 1.1] [-2.1, 0.0] = [-0X1.A400000000001P+7, 0.0]; mulRev [0.0, 0.0] [-2.1, 0.0] = [entire]; mulRev [-infinity, -0.1] [-2.1, 0.0] = [0.0, 0X1.5P+4]; mulRev [-infinity, 0.0] [-2.1, 0.0] = [entire]; mulRev [-infinity, 1.1] [-2.1, 0.0] = [entire]; mulRev [-2.0, infinity] [-2.1, 0.0] = [entire]; mulRev [0.0, infinity] [-2.1, 0.0] = [entire]; mulRev [0.01, infinity] [-2.1, 0.0] = [-0X1.A400000000001P+7, 0.0]; mulRev [entire] [-2.1, 0.0] = [entire]; mulRev [-2.0, -0.1] [-2.1, 0.12] = [-0X1.3333333333333P+0, 0X1.5P+4]; mulRev [-2.0, 0.0] [-2.1, 0.12] = [entire]; mulRev [-2.0, 1.1] [-2.1, 0.12] = [entire]; mulRev [0.0, 1.1] [-2.1, 0.12] = [entire]; mulRev [0.01, 1.1] [-2.1, 0.12] = [-0X1.A400000000001P+7 , 0X1.8P+3]; mulRev [0.0, 0.0] [-2.1, 0.12] = [entire]; mulRev [-infinity, -0.1] [-2.1, 0.12] = [-0X1.3333333333333P+0, 0X1.5P+4]; mulRev [-infinity, 0.0] [-2.1, 0.12] = [entire]; mulRev [-infinity, 1.1] [-2.1, 0.12] = [entire]; mulRev [-2.0, infinity] [-2.1, 0.12] = [entire]; mulRev [0.0, infinity] [-2.1, 0.12] = [entire]; mulRev [0.01, infinity] [-2.1, 0.12] = [-0X1.A400000000001P+7 , 0X1.8P+3]; mulRev [entire] [-2.1, 0.12] = [entire]; mulRev [-2.0, -0.1] [0.0, 0.12] = [-0X1.3333333333333P+0, 0.0]; mulRev [-2.0, 0.0] [0.0, 0.12] = [entire]; mulRev [-2.0, 1.1] [0.0, 0.12] = [entire]; mulRev [0.0, 1.1] [0.0, 0.12] = [entire]; mulRev [0.01, 1.1] [0.0, 0.12] = [0.0, 0X1.8P+3]; mulRev [0.0, 0.0] [0.0, 0.12] = [entire]; mulRev [-infinity, -0.1] [0.0, 0.12] = [-0X1.3333333333333P+0, 0.0]; mulRev [-infinity, 0.0] [0.0, 0.12] = [entire]; mulRev [-infinity, 1.1] [0.0, 0.12] = [entire]; mulRev [-2.0, infinity] [0.0, 0.12] = [entire]; mulRev [0.0, infinity] [0.0, 0.12] = [entire]; mulRev [0.01, infinity] [0.0, 0.12] = [0.0, 0X1.8P+3]; mulRev [entire] [0.0, 0.12] = [entire]; mulRev [-2.0, -0.1] [0.01, 0.12] = [-0X1.3333333333333P+0, -0X1.47AE147AE147BP-8]; mulRev [-2.0, 0.0] [0.01, 0.12] = [-infinity, -0X1.47AE147AE147BP-8]; mulRev [-2.0, 1.1] [0.01, 0.12] = [entire]; mulRev [0.0, 1.1] [0.01, 0.12] = [0X1.29E4129E4129DP-7, infinity]; mulRev [0.01, 1.1] [0.01, 0.12] = [0X1.29E4129E4129DP-7, 0X1.8P+3]; mulRev [0.0, 0.0] [0.01, 0.12] = [empty]; mulRev [-infinity, -0.1] [0.01, 0.12] = [-0X1.3333333333333P+0, 0.0]; mulRev [-infinity, 0.0] [0.01, 0.12] = [-infinity, 0.0]; mulRev [-infinity, 1.1] [0.01, 0.12] = [entire]; mulRev [-2.0, infinity] [0.01, 0.12] = [entire]; mulRev [0.0, infinity] [0.01, 0.12] = [0.0, infinity]; mulRev [0.01, infinity] [0.01, 0.12] = [0.0, 0X1.8P+3]; mulRev [entire] [0.01, 0.12] = [entire]; mulRev [-2.0, -0.1] [0.0, 0.0] = [0.0, 0.0]; mulRev [-2.0, 0.0] [0.0, 0.0] = [entire]; mulRev [-2.0, 1.1] [0.0, 0.0] = [entire]; mulRev [0.0, 1.1] [0.0, 0.0] = [entire]; mulRev [0.01, 1.1] [0.0, 0.0] = [0.0, 0.0]; mulRev [0.0, 0.0] [0.0, 0.0] = [entire]; mulRev [-infinity, -0.1] [0.0, 0.0] = [0.0, 0.0]; mulRev [-infinity, 0.0] [0.0, 0.0] = [entire]; mulRev [-infinity, 1.1] [0.0, 0.0] = [entire]; mulRev [-2.0, infinity] [0.0, 0.0] = [entire]; mulRev [0.0, infinity] [0.0, 0.0] = [entire]; mulRev [0.01, infinity] [0.0, 0.0] = [0.0, 0.0]; mulRev [entire] [0.0, 0.0] = [entire]; mulRev [-2.0, -0.1] [-infinity, -0.1] = [0X1.999999999999AP-5, infinity]; mulRev [-2.0, 0.0] [-infinity, -0.1] = [0X1.999999999999AP-5 , infinity]; mulRev [-2.0, 1.1] [-infinity, -0.1] = [entire]; mulRev [0.0, 1.1] [-infinity, -0.1] = [-infinity, -0X1.745D1745D1745P-4]; mulRev [0.01, 1.1] [-infinity, -0.1] = [-infinity, -0X1.745D1745D1745P-4]; mulRev [0.0, 0.0] [-infinity, -0.1] = [empty]; mulRev [-infinity, -0.1] [-infinity, -0.1] = [0.0, infinity]; mulRev [-infinity, 0.0] [-infinity, -0.1] = [0.0, infinity]; mulRev [-infinity, 1.1] [-infinity, -0.1] = [entire]; mulRev [-2.0, infinity] [-infinity, -0.1] = [entire]; mulRev [0.0, infinity] [-infinity, -0.1] = [-infinity, 0.0]; mulRev [0.01, infinity] [-infinity, -0.1] = [-infinity, 0.0]; mulRev [entire] [-infinity, -0.1] = [entire]; mulRev [-2.0, -0.1] [-infinity, 0.0] = [0.0, infinity]; mulRev [-2.0, 0.0] [-infinity, 0.0] = [entire]; mulRev [-2.0, 1.1] [-infinity, 0.0] = [entire]; mulRev [0.0, 1.1] [-infinity, 0.0] = [entire]; mulRev [0.01, 1.1] [-infinity, 0.0] = [-infinity, 0.0]; mulRev [0.0, 0.0] [-infinity, 0.0] = [entire]; mulRev [-infinity, -0.1] [-infinity, 0.0] = [0.0, infinity]; mulRev [-infinity, 0.0] [-infinity, 0.0] = [entire]; mulRev [-infinity, 1.1] [-infinity, 0.0] = [entire]; mulRev [-2.0, infinity] [-infinity, 0.0] = [entire]; mulRev [0.0, infinity] [-infinity, 0.0] = [entire]; mulRev [0.01, infinity] [-infinity, 0.0] = [-infinity, 0.0]; mulRev [entire] [-infinity, 0.0] = [entire]; mulRev [-2.0, -0.1] [-infinity, 0.3] = [-0X1.8P+1, infinity]; mulRev [-2.0, 0.0] [-infinity, 0.3] = [entire]; mulRev [-2.0, 1.1] [-infinity, 0.3] = [entire]; mulRev [0.0, 1.1] [-infinity, 0.3] = [entire]; mulRev [0.01, 1.1] [-infinity, 0.3] = [-infinity, 0X1.EP+4]; mulRev [0.0, 0.0] [-infinity, 0.3] = [entire]; mulRev [-infinity, -0.1] [-infinity, 0.3] = [-0X1.8P+1, infinity]; mulRev [-infinity, 0.0] [-infinity, 0.3] = [entire]; mulRev [-infinity, 1.1] [-infinity, 0.3] = [entire]; mulRev [-2.0, infinity] [-infinity, 0.3] = [entire]; mulRev [0.0, infinity] [-infinity, 0.3] = [entire]; mulRev [0.01, infinity] [-infinity, 0.3] = [-infinity, 0X1.EP+4]; mulRev [entire] [-infinity, 0.3] = [entire]; mulRev [-2.0, -0.1] [-0.21, infinity] = [-infinity , 0X1.0CCCCCCCCCCCDP+1]; mulRev [-2.0, 0.0] [-0.21, infinity] = [entire]; mulRev [-2.0, 1.1] [-0.21, infinity] = [entire]; mulRev [0.0, 1.1] [-0.21, infinity] = [entire]; mulRev [0.01, 1.1] [-0.21, infinity] = [-0X1.5P+4, infinity]; mulRev [0.0, 0.0] [-0.21, infinity] = [entire]; mulRev [-infinity, -0.1] [-0.21, infinity] = [-infinity, 0X1.0CCCCCCCCCCCDP+1]; mulRev [-infinity, 0.0] [-0.21, infinity] = [entire]; mulRev [-infinity, 1.1] [-0.21, infinity] = [entire]; mulRev [-2.0, infinity] [-0.21, infinity] = [entire]; mulRev [0.0, infinity] [-0.21, infinity] = [entire]; mulRev [0.01, infinity] [-0.21, infinity] = [-0X1.5P+4, infinity]; mulRev [entire] [-0.21, infinity] = [entire]; mulRev [-2.0, -0.1] [0.0, infinity] = [-infinity, 0.0]; mulRev [-2.0, 0.0] [0.0, infinity] = [entire]; mulRev [-2.0, 1.1] [0.0, infinity] = [entire]; mulRev [0.0, 1.1] [0.0, infinity] = [entire]; mulRev [0.01, 1.1] [0.0, infinity] = [0.0, infinity]; mulRev [0.0, 0.0] [0.0, infinity] = [entire]; mulRev [-infinity, -0.1] [0.0, infinity] = [-infinity, 0.0]; mulRev [-infinity, 0.0] [0.0, infinity] = [entire]; mulRev [-infinity, 1.1] [0.0, infinity] = [entire]; mulRev [-2.0, infinity] [0.0, infinity] = [entire]; mulRev [0.0, infinity] [0.0, infinity] = [entire]; mulRev [0.01, infinity] [0.0, infinity] = [0.0, infinity]; mulRev [entire] [0.0, infinity] = [entire]; mulRev [-2.0, -0.1] [0.04, infinity] = [-infinity, -0X1.47AE147AE147BP-6]; mulRev [-2.0, 0.0] [0.04, infinity] = [-infinity, -0X1.47AE147AE147BP-6]; mulRev [-2.0, 1.1] [0.04, infinity] = [entire]; mulRev [0.0, 1.1] [0.04, infinity] = [0X1.29E4129E4129DP-5, infinity]; mulRev [0.01, 1.1] [0.04, infinity] = [0X1.29E4129E4129DP-5, infinity]; mulRev [0.0, 0.0] [0.04, infinity] = [empty]; mulRev [-infinity, -0.1] [0.04, infinity] = [-infinity, 0.0]; mulRev [-infinity, 0.0] [0.04, infinity] = [-infinity, 0.0]; mulRev [-infinity, 1.1] [0.04, infinity] = [entire]; mulRev [-2.0, infinity] [0.04, infinity] = [entire]; mulRev [0.0, infinity] [0.04, infinity] = [0.0, infinity]; mulRev [0.01, infinity] [0.04, infinity] = [0.0, infinity]; mulRev [entire] [0.04, infinity] = [entire]; mulRev [-2.0, -0.1] [entire] = [entire]; mulRev [-2.0, 0.0] [entire] = [entire]; mulRev [-2.0, 1.1] [entire] = [entire]; mulRev [0.0, 1.1] [entire] = [entire]; mulRev [0.01, 1.1] [entire] = [entire]; mulRev [0.0, 0.0] [entire] = [entire]; mulRev [-infinity, -0.1] [entire] = [entire]; mulRev [-infinity, 0.0] [entire] = [entire]; mulRev [-infinity, 1.1] [entire] = [entire]; mulRev [-2.0, infinity] [entire] = [entire]; mulRev [0.0, infinity] [entire] = [entire]; mulRev [0.01, infinity] [entire] = [entire]; mulRev [entire] [entire] = [entire]; } testcase minimal_mulRevTen_test { mulRevTen [-2.0, -0.1] [-2.1, -0.4] [-2.1, -0.4] = [empty]; mulRevTen [-2.0, 1.1] [-2.1, -0.4] [-2.1, -0.4] = [-2.1, -0.4]; mulRevTen [0.01, 1.1] [-2.1, 0.0] [-2.1, 0.0] = [-2.1,0.0]; mulRevTen [-infinity, -0.1] [0.0, 0.12] [0.0, 0.12] = [0.0, 0.0]; mulRevTen [-2.0, 1.1] [0.04, infinity] [0.04, infinity] = [0.04, infinity]; } testcase minimal_mulRev_dec_test { mulRev [-2.0, -0.1]_dac [-2.1, -0.4]_dac = [0X1.999999999999AP-3, 0X1.5P+4]_trv; mulRev [-2.0, -0.1]_def [-2.1, 0.0]_def = [0.0, 0X1.5P+4]_trv; mulRev [-2.0, -0.1]_com [-2.1, 0.12]_dac = [-0X1.3333333333333P+0, 0X1.5P+4]_trv; mulRev [-infinity, -0.1]_dac [0.0, 0.12]_com = [-0X1.3333333333333P+0, 0.0]_trv; mulRev [0.01, 1.1]_def [0.01, 0.12]_dac = [0X1.29E4129E4129DP-7, 0X1.8P+3]_trv; mulRev [0.01, 1.1]_dac [-infinity, 0.3]_def = [-infinity, 0X1.EP+4]_trv; mulRev [-infinity, -0.1]_trv [-0.21, infinity]_dac = [-infinity, 0X1.0CCCCCCCCCCCDP+1]_trv; } testcase minimal_mulRev_dec_ten_test { mulRevTen [-2.0, -0.1]_dac [-2.1, -0.4]_dac [-2.1, -0.4]_dac = [empty]_trv; mulRevTen [-2.0, 1.1]_def [-2.1, -0.4]_com [-2.1, -0.4]_com = [-2.1, -0.4]_trv; mulRevTen [0.01, 1.1]_com [-2.1, 0.0]_dac [-2.1, 0.0]_dac = [-2.1,0.0]_trv; mulRevTen [-infinity, -0.1]_dac [0.0, 0.12]_com [0.0, 0.12]_com = [0.0, 0.0]_trv; mulRevTen [-2.0, 1.1]_def [0.04, infinity]_dac [0.04, infinity]_dac = [0.04, infinity]_trv; } interval-1.4.1/test/libieeep1788_tests_set.itl0000644000000000000000000000414312657475772017413 0ustar 00000000000000/* Copyright 2013-2015 Marco Nehmeier (nehmeier@informatik.uni-wuerzburg.de) Copyright 2015-2016 Oliver Heimlich Original author: Marco Nehmeier (unit tests in libieeep1788, original license: Apache License 2.0) Converted into portable ITL format by Oliver Heimlich with minor corrections. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ testcase minimal_intersection_test { intersection [1.0,3.0] [2.1,4.0] = [2.1,3.0]; intersection [1.0,3.0] [3.0,4.0] = [3.0,3.0]; intersection [1.0,3.0] [empty] = [empty]; intersection [entire] [empty] = [empty]; intersection [1.0,3.0] [entire] = [1.0,3.0]; } testcase minimal_intersection_dec_test { intersection [1.0,3.0]_com [2.1,4.0]_com = [2.1,3.0]_trv; intersection [1.0,3.0]_dac [3.0,4.0]_def = [3.0,3.0]_trv; intersection [1.0,3.0]_def [empty]_trv = [empty]_trv; intersection [entire]_def [empty]_trv = [empty]_trv; intersection [1.0,3.0]_dac [entire]_def = [1.0,3.0]_trv; } testcase minimal_convexHull_test { convexHull [1.0,3.0] [2.1,4.0] = [1.0,4.0]; convexHull [1.0,1.0] [2.1,4.0] = [1.0,4.0]; convexHull [1.0,3.0] [empty] = [1.0,3.0]; convexHull [empty] [empty] = [empty]; convexHull [1.0,3.0] [entire] = [entire]; } testcase minimal_convexHull_dec_test { convexHull [1.0,3.0]_trv [2.1,4.0]_trv = [1.0,4.0]_trv; convexHull [1.0,1.0]_trv [2.1,4.0]_trv = [1.0,4.0]_trv; convexHull [1.0,3.0]_trv [empty]_trv = [1.0,3.0]_trv; convexHull [empty]_trv [empty]_trv = [empty]_trv; convexHull [1.0,3.0]_trv [entire]_def = [entire]_trv; } interval-1.4.1/test/mpfi.itl0000644000000000000000000024756412657475772014163 0ustar 00000000000000/* Copyright 2009–2012 Spaces project, Inria Lorraine and Salsa project, INRIA Rocquencourt, and Arenaire project, Inria Rhone-Alpes, France and Lab. ANO, USTL (Univ. of Lille), France Copyright 2015-2016 Oliver Heimlich Original authors: Philippe Theveny (Philippe.Theveny@ens-lyon.fr) and Nathalie Revol (Nathalie.Revol@ens-lyon.fr) (unit tests in GNU MPFI, original license: LGPLv2.1+) Converted into portable ITL format by Oliver Heimlich. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ testcase mpfi_abs { // special values abs [-infinity, -7.0] = [+7.0, +infinity]; abs [-infinity, 0.0] = [0.0, +infinity]; abs [-infinity, 0.0] = [0.0, +infinity]; abs [-infinity, +8.0] = [0.0, +infinity]; abs [entire] = [0.0, +infinity]; abs [0.0, 0.0] = [0.0, 0.0]; abs [0.0, +8.0] = [0.0, +8.0]; abs [0.0, +infinity] = [0.0, +infinity]; abs [0.0, +8.0] = [0.0, +8.0]; abs [0.0, +infinity] = [0.0, +infinity]; // regular values abs [0x123456789p-16, 0x123456799p-16] = [0x123456789p-16, 0x123456799p-16]; abs [-0x123456789p-16, 0x123456799p-16] = [0.0, 0x123456799p-16]; } testcase mpfi_acos { // special values acos [-1.0, 0.0] = [0x3243f6a8885a3p-49, 0x1921fb54442d19p-51]; acos [0.0, 0.0] = [0x3243f6a8885a3p-49, 0x1921fb54442d19p-52]; acos [0.0, +1.0] = [0.0, 0x1921fb54442d19p-52]; // regular values acos [-1.0, -0.5] = [0x10c152382d7365p-51, 0x1921fb54442d19p-51]; acos [-0.75, -0.25] = [0x1d2cf5c7c70f0bp-52, 0x4d6749be4edb1p-49]; acos [-0.5, 0.5] = [0x10c152382d7365p-52, 0x860a91c16b9b3p-50]; acos [0.25, 0.625] = [0x1ca94936b98a21p-53, 0x151700e0c14b25p-52]; acos [-1.0, 1.0] = [0.0, 0x1921fb54442d19p-51]; } testcase mpfi_acosh { // special values acosh [+1.0, +infinity] = [0.0, +infinity]; acosh [+1.5, +infinity] = [0x1ecc2caec51609p-53, +infinity]; // regular values acosh [1.0, 1.5] = [0.0, 0xf661657628b05p-52]; acosh [1.5, 1.5] = [0x1ecc2caec51609p-53, 0xf661657628b05p-52]; acosh [2.0, 1000.0] = [0x544909c66010dp-50, 0x799d4ba2a13b5p-48]; } testcase mpfi_add { // special values add [-infinity, -7.0] [-1.0, +8.0] = [-infinity, +1.0]; add [-infinity, 0.0] [+8.0, +infinity] = [entire]; add [-infinity, +8.0] [0.0, +8.0] = [-infinity, +16.0]; add [entire] [0.0, +8.0] = [entire]; add [0.0, 0.0] [-infinity, -7.0] = [-infinity, -7.0]; add [0.0, +8.0] [-7.0, 0.0] = [-7.0, +8.0]; add [0.0, 0.0] [0.0, +8.0] = [0.0, +8.0]; add [0.0, +infinity] [0.0, +8.0] = [0.0, +infinity]; add [0.0, 0.0] [+8.0, +infinity] = [+8.0, +infinity]; add [0.0, 0.0] [entire] = [entire]; add [0.0, +8.0] [0.0, +8.0] = [0.0, +16.0]; add [0.0, 0.0] [0.0, 0.0] = [0.0, 0.0]; add [0.0, +infinity] [-7.0, +8.0] = [-7.0, +infinity]; // regular values add [-0.375, -0x10187p-256] [-0.125, 0x1p-240] = [-0x1p-1, -0x187p-256]; add [-0x1p-300, 0x123456p+28] [-0x10000000000000p-93, 0x789abcdp0] = [-0x10000000000001p-93, 0x123456789abcdp0]; add [-4.0, +7.0] [-0x123456789abcdp-17, 3e300] = [-0x123456791abcdp-17, 0x8f596b3002c1bp+947]; add [0x1000100010001p+8, 0x1p+60] [0x1000100010001p0, 3.0e300] = [+0x1010101010101p+8, 0x8f596b3002c1bp+947]; // signed zeros add [+4.0, +8.0] [-4.0, -2.0] = [0.0, +6.0]; add [+4.0, +8.0] [-9.0, -8.0] = [-5.0, 0.0]; } testcase mpfi_add_d { // special values add [-infinity, -7.0] [-0x170ef54646d497p-107, -0x170ef54646d497p-107] = [-infinity, -7.0]; add [-infinity, -7.0] [0.0, 0.0] = [-infinity, -7.0]; add [-infinity, -7.0] [0x170ef54646d497p-107, 0x170ef54646d497p-107] = [-infinity, -0x1bffffffffffffp-50]; add [-infinity, 0.0] [-0x170ef54646d497p-106, -0x170ef54646d497p-106] = [-infinity, -8.0e-17]; add [-infinity, 0.0] [0.0, 0.0] = [-infinity, 0.0]; add [-infinity, 0.0] [0x170ef54646d497p-106, 0x170ef54646d497p-106] = [-infinity, 0x170ef54646d497p-106]; add [-infinity, 8.0] [-0x16345785d8a00000p0, -0x16345785d8a00000p0] = [-infinity, -0x16345785d89fff00p0]; add [-infinity, 8.0] [0.0, 0.0] = [-infinity, 8.0]; add [-infinity, 8.0] [0x16345785d8a00000p0, 0x16345785d8a00000p0] = [-infinity, 0x16345785d8a00100p0]; add [entire] [-0x170ef54646d497p-105, -0x170ef54646d497p-105] = [entire]; add [entire] [0.0e-17, 0.0e-17] = [entire]; add [entire] [+0x170ef54646d497p-105, +0x170ef54646d497p-105] = [entire]; add [0.0, 0.0] [-0x170ef54646d497p-109, -0x170ef54646d497p-109] = [-0x170ef54646d497p-109, -0x170ef54646d497p-109]; add [0.0, 0.0] [0.0, 0.0] = [0.0, 0.0]; add [0.0, 0.0] [0x170ef54646d497p-109, 0x170ef54646d497p-109] = [0x170ef54646d497p-109, 0x170ef54646d497p-109]; add [0.0, 8.0] [-0x114b37f4b51f71p-107, -0x114b37f4b51f71p-107] = [-0x114b37f4b51f71p-107, 8.0]; add [0.0, 8.0] [0.0, 0.0] = [0.0, 8.0]; add [0.0, 8.0] [0x114b37f4b51f7p-103, 0x114b37f4b51f7p-103] = [0x114b37f4b51f7p-103, 0x10000000000001p-49]; add [0.0, +infinity] [-0x50b45a75f7e81p-104, -0x50b45a75f7e81p-104] = [-0x50b45a75f7e81p-104, +infinity]; add [0.0, +infinity] [0.0, 0.0] = [0.0, +infinity]; add [0.0, +infinity] [0x142d169d7dfa03p-106, 0x142d169d7dfa03p-106] = [0x142d169d7dfa03p-106, +infinity]; // regular values add [-32.0, -17.0] [-0xfb53d14aa9c2fp-47, -0xfb53d14aa9c2fp-47] = [-0x1fb53d14aa9c2fp-47, -0x18353d14aa9c2fp-47]; add [-0xfb53d14aa9c2fp-47, -17.0] [0xfb53d14aa9c2fp-47, 0xfb53d14aa9c2fp-47] = [0.0, 0x7353d14aa9c2fp-47]; add [-32.0, -0xfb53d14aa9c2fp-48] [0xfb53d14aa9c2fp-48, 0xfb53d14aa9c2fp-48] = [-0x104ac2eb5563d1p-48, 0.0]; add [0x123456789abcdfp-48, 0x123456789abcdfp-4] [3.5, 3.5] = [0x15b456789abcdfp-48, 0x123456789abd17p-4]; add [0x123456789abcdfp-56, 0x123456789abcdfp-4] [3.5, 3.5] = [0x3923456789abcdp-52, 0x123456789abd17p-4]; add [-0xffp0, 0x123456789abcdfp-52] [256.5, 256.5] = [0x18p-4, 0x101a3456789abdp-44]; add [-0x1fffffffffffffp-52, -0x1p-550] [4097.5, 4097.5] = [0xfff8p-4, 0x10018p-4]; add [0x123456789abcdfp-48, 0x123456789abcdfp-4] [-3.5, -3.5] = [0xeb456789abcdfp-48, 0x123456789abca7p-4]; add [0x123456789abcdfp-56, 0x123456789abcdfp-4] [-3.5, -3.5] = [-0x36dcba98765434p-52, 0x123456789abca7p-4]; add [-0xffp0, 0x123456789abcdfp-52] [-256.5, -256.5] = [-0x1ff8p-4, -0xff5cba9876543p-44]; add [-0x1fffffffffffffp-52, -0x1p-550] [-4097.5, -4097.5] = [-0x10038p-4, -0x10018p-4]; } testcase mpfi_asin { // special values asin [-1.0, 0.0] = [-0x1921fb54442d19p-52, 0.0]; asin [0.0, 0.0] = [0.0, 0.0]; asin [0.0, +1.0] = [0.0, 0x1921fb54442d19p-52]; // regular values asin [-1.0, -0.5] = [-0x1921fb54442d19p-52, -0x10c152382d7365p-53]; asin [-0.75, -0.25] = [-0x1b235315c680ddp-53, -0x102be9ce0b87cdp-54]; asin [-0.5, 0.5] = [-0x860a91c16b9b3p-52, 0x860a91c16b9b3p-52]; asin [0.25, 0.625] = [0x102be9ce0b87cdp-54, 0x159aad71ced00fp-53]; asin [-1.0, 1.0] = [-0x1921fb54442d19p-52, 0x1921fb54442d19p-52]; } testcase mpfi_asinh { // special values asinh [-infinity, -7.0] = [-infinity, -0x152728c91b5f1dp-51]; asinh [-infinity, 0.0] = [-infinity, 0.0]; asinh [-infinity, +8.0] = [-infinity, 0x58d8dc657eaf5p-49]; asinh [entire] = [entire]; asinh [-1.0, 0.0] = [-0x1c34366179d427p-53, 0.0]; asinh [0.0, 0.0] = [0.0, 0.0]; asinh [0.0, +1.0] = [0.0, 0x1c34366179d427p-53]; asinh [0.0, +8.0] = [0.0, 0x58d8dc657eaf5p-49]; asinh [0.0, +infinity] = [0.0, +infinity]; // regular values asinh [-6.0, -4.0] = [-0x4fbca919fe219p-49, -0x10c1f8a6e80eebp-51]; asinh [-2.0, -0.5] = [-0x2e32430627a11p-49, -0x1ecc2caec51609p-54]; asinh [-1.0, -0.5] = [-0x1c34366179d427p-53, -0x1ecc2caec51609p-54]; asinh [-0.75, -0.25] = [-0x162e42fefa39fp-49, -0xfd67d91ccf31bp-54]; asinh [-0.5, 0.5] = [-0xf661657628b05p-53, 0xf661657628b05p-53]; asinh [0.25, 0.625] = [0xfd67d91ccf31bp-54, 0x4b89d40b2fecdp-51]; asinh [-1.0, 1.0] = [-0x1c34366179d427p-53, 0x1c34366179d427p-53]; asinh [0.125, 17.0] = [0xff5685b4cb4b9p-55, 0xe1be0ba541ef7p-50]; asinh [17.0, 42.0] = [0x1c37c174a83dedp-51, 0x8dca6976ad6bdp-49]; asinh [-42.0, 17.0] = [-0x8dca6976ad6bdp-49, 0xe1be0ba541ef7p-50]; } testcase mpfi_atan { // special values atan [-infinity, -7.0] = [-0x1921fb54442d19p-52, -0x5b7315eed597fp-50]; atan [-infinity, 0.0] = [-0x1921fb54442d19p-52, 0.0]; atan [-infinity, +8.0] = [-0x1921fb54442d19p-52, 0xb924fd54cb511p-51]; atan [entire] = [-0x1921fb54442d19p-52, 0x1921fb54442d19p-52]; atan [-1.0, 0.0] = [-0x1921fb54442d19p-53, 0.0]; atan [0.0, 0.0] = [0.0, 0.0]; atan [0.0, +1.0] = [0.0, 0x1921fb54442d19p-53]; atan [0.0, +8.0] = [0.0, 0xb924fd54cb511p-51]; atan [0.0, +infinity] = [0.0, 0x1921fb54442d19p-52]; // regular values atan [-6.0, -4.0] = [-0x167d8863bc99bdp-52, -0x54da32547a73fp-50]; atan [-2.0, -0.5] = [-0x11b6e192ebbe45p-52, -0x1dac670561bb4fp-54]; atan [-1.0, -0.5] = [-0x1921fb54442d19p-53, -0x1dac670561bb4fp-54]; atan [-0.75, -0.25] = [-0xa4bc7d1934f71p-52, -0x1f5b75f92c80ddp-55]; atan [-0.5, 0.5] = [-0x1dac670561bb5p-50, 0x1dac670561bb5p-50]; atan [0.25, 0.625] = [0x1f5b75f92c80ddp-55, 0x47802eaf7bfadp-51]; atan [-1.0, 1.0] = [-0x1921fb54442d19p-53, 0x1921fb54442d19p-53]; atan [0.125, 17.0] = [0x1fd5ba9aac2f6dp-56, 0x1831516233f561p-52]; atan [17.0, 42.0] = [0xc18a8b119fabp-47, 0x18c079f3350d27p-52]; atan [-42.0, 17.0] = [-0x18c079f3350d27p-52, 0x1831516233f561p-52]; } testcase mpfi_atan2 { // special values atan2 [-infinity, -7.0] [-1.0, +8.0] = [-0x6d9cc4b34bd0dp-50, -0x1700a7c5784633p-53]; atan2 [-infinity, 0.0] [+8.0, +infinity] = [-0x1921fb54442d19p-52, 0.0]; atan2 [-infinity, +8.0] [0.0, +8.0] = [-0x1921fb54442d19p-52, 0x1921fb54442d19p-52]; atan2 [entire] [0.0, +8.0] = [-0x1921fb54442d19p-52, 0x1921fb54442d19p-52]; atan2 [0.0, 0.0] [-infinity, -7.0] = [0x1921fb54442d18p-51, 0x1921fb54442d19p-51]; atan2 [0.0, +8.0] [-7.0, 0.0] = [0x3243f6a8885a3p-49, 0x1921fb54442d19p-51]; atan2 [0.0, 0.0] [0.0, +8.0] = [0.0, 0.0]; atan2 [0.0, +infinity] [0.0, +8.0] = [0.0, 0x1921fb54442d19p-52]; atan2 [0.0, 0.0] [+8.0, +infinity] = [0.0, 0.0]; atan2 [0.0, 0.0] [entire] = [0.0, 0x1921fb54442d19p-51]; atan2 [0.0, +8.0] [-7.0, +8.0] = [0.0, 0x1921fb54442d19p-51]; atan2 [0.0, 0.0] [0.0, 0.0] = [empty]; atan2 [0.0, +infinity] [0.0, +8.0] = [0.0, 0x1921fb54442d19p-52]; // regular values atan2 [-17.0, -5.0] [-4002.0, -1.0] = [-0x191f6c4c09a81bp-51, -0x1a12a5465464cfp-52]; atan2 [-17.0, -5.0] [1.0, 4002.0] = [-0x1831516233f561p-52, -0xa3c20ea13f5e5p-61]; atan2 [5.0, 17.0] [1.0, 4002.0] = [0xa3c20ea13f5e5p-61, 0x1831516233f561p-52]; atan2 [5.0, 17.0] [-4002.0, -1.0] = [0x1a12a5465464cfp-52, 0x191f6c4c09a81bp-51]; atan2 [-17.0, 5.0] [-4002.0, 1.0] = [-0x1921fb54442d19p-51, 0x1921fb54442d19p-51]; } testcase mpfi_atanh { // special values atanh [-1.0, 0.0] = [-infinity, 0.0]; atanh [0.0, 0.0] = [0.0, 0.0]; atanh [0.0, +1.0] = [0.0, +infinity]; // regular values atanh [-1.0, -0.5] = [-infinity, -0x8c9f53d568185p-52]; atanh [-0.75, -0.25] = [-0x3e44e55c64b4bp-50, -0x1058aefa811451p-54]; atanh [-0.5, 0.5] = [-0x1193ea7aad030bp-53, 0x1193ea7aad030bp-53]; atanh [0.25, 0.625] = [0x1058aefa811451p-54, 0x2eec3bb76c2b3p-50]; atanh [-1.0, 1.0] = [entire]; atanh [0.125, 1.0] = [0x1015891c9eaef7p-55, +infinity]; } testcase mpfi_bounded_p { // special values isCommonInterval [-infinity, -8.0] = false; isCommonInterval [-infinity, 0.0] = false; isCommonInterval [-infinity, 5.0] = false; isCommonInterval [entire] = false; isCommonInterval [-8.0, 0.0] = true; isCommonInterval [0.0, 0.0] = true; isCommonInterval [0.0, 5.0] = true; isCommonInterval [0.0, +infinity] = false; isCommonInterval [5.0, +infinity] = false; // regular values isCommonInterval [-34.0, -17.0] = true; isCommonInterval [-8.0, -1.0] = true; isCommonInterval [-34.0, 17.0] = true; isCommonInterval [-0x1921fb54442d18p-51, 0x1921fb54442d19p-51] = true; isCommonInterval [0x1921fb54442d18p-51, 0x1921fb54442d19p-51] = true; isCommonInterval [+8.0, +0x7fffffffffffbp+51] = true; isCommonInterval [+0x1fffffffffffffp-53, 2.0] = true; } testcase mpfi_cbrt { // special values cbrt [-infinity, -125.0] = [-infinity, -5.0]; cbrt [-infinity, 0.0] = [-infinity, 0.0]; cbrt [-infinity, +64.0] = [-infinity, +4.0]; cbrt [entire] = [entire]; cbrt [0.0, 0.0] = [0.0, 0.0]; cbrt [0.0, +27.0] = [0.0, +3.0]; cbrt [0.0, +infinity] = [0.0, +infinity]; // regular values cbrt [0x40p0, 0x7dp0] = [4.0, 5.0]; cbrt [-0x1856e4be527197p-354, 0xd8p0] = [-0x2e5e58c0083b7bp-154, 6.0]; cbrt [0x141a9019a2184dp-1047, 0xc29c78c66ac0fp-678] = [0x2b8172e535d44dp-385, 0x24cbd1c55aaa1p-258]; } testcase mpfi_cos { // special values cos [-infinity, -7.0] = [-1.0, 1.0]; cos [-infinity, 0.0] = [-1.0, 1.0]; cos [-infinity, +8.0] = [-1.0, 1.0]; cos [entire] = [-1.0, 1.0]; cos [-1.0, 0.0] = [0x114a280fb5068bp-53, 1.0]; cos [0.0, 0.0] = [1.0, 1.0]; cos [0.0, +1.0] = [0x114a280fb5068bp-53, 1.0]; cos [0.0, +8.0] = [-1.0, 1.0]; cos [0.0, +infinity] = [-1.0, 1.0]; // regular values cos [-2.0, -0.5] = [-0x1aa22657537205p-54, 0x1c1528065b7d5p-49]; cos [-1.0, -0.25] = [0x114a280fb5068bp-53, 0xf80aa4fbef751p-52]; cos [-0.5, 0.5] = [0x1c1528065b7d4fp-53, 1.0]; cos [-4.5, 0.625] = [-1.0, 1.0]; cos [1.0, 0x3243f6a8885a3p-48] = [-1.0, 0x4528a03ed41a3p-51]; cos [0.125, 17.0] = [-1.0, 1.0]; cos [17.0, 42.0] = [-1.0, 1.0]; cos [-7.0, 1.0] = [-1.0, 1.0]; cos [-7.0, 0.0] = [-1.0, 1.0]; cos [-7.0, -1.0] = [-1.0, 1.0]; cos [-7.0, -2.0] = [-1.0, 1.0]; cos [-7.0, -3.0] = [-1.0, 1.0]; cos [-7.0, -4.0] = [-0x14eaa606db24c1p-53, 1.0]; cos [-7.0, -5.0] = [0x122785706b4ad9p-54, 1.0]; cos [-7.0, -6.0] = [0x181ff79ed92017p-53, 1.0]; cos [-7.0, -7.0] = [0x181ff79ed92017p-53, 0x181ff79ed92018p-53]; cos [-6.0, 1.0] = [-1.0, 1.0]; cos [-6.0, 0.0] = [-1.0, 1.0]; cos [-6.0, -1.0] = [-1.0, 0x1eb9b7097822f6p-53]; cos [-6.0, -2.0] = [-1.0, 0x1eb9b7097822f6p-53]; cos [-6.0, -3.0] = [-1.0, 0x1eb9b7097822f6p-53]; cos [-6.0, -4.0] = [-0x14eaa606db24c1p-53, 0x1eb9b7097822f6p-53]; cos [-6.0, -5.0] = [0x122785706b4ad9p-54, 0x1eb9b7097822f6p-53]; cos [-6.0, -6.0] = [0x1eb9b7097822f5p-53, 0x1eb9b7097822f6p-53]; cos [-5.0, 1.0] = [-1.0, 1.0]; cos [-5.0, 0.0] = [-1.0, 1.0]; cos [-5.0, -1.0] = [-1.0, 0x114a280fb5068cp-53]; cos [-5.0, -2.0] = [-1.0, 0x122785706b4adap-54]; cos [-5.0, -3.0] = [-1.0, 0x122785706b4adap-54]; cos [-5.0, -4.0] = [-0x14eaa606db24c1p-53, 0x122785706b4adap-54]; cos [-5.0, -5.0] = [0x122785706b4ad9p-54, 0x122785706b4adap-54]; cos [-4.0, 1.0] = [-1.0, 1.0]; cos [-4.0, 0.0] = [-1.0, 1.0]; cos [-4.0, -1.0] = [-1.0, 0x114a280fb5068cp-53]; cos [-4.0, -2.0] = [-1.0, -0x1aa22657537204p-54]; cos [-4.0, -3.0] = [-1.0, -0x14eaa606db24c0p-53]; cos [-4.0, -4.0] = [-0x14eaa606db24c1p-53, -0x14eaa606db24c0p-53]; } testcase mpfi_cosh { // special values cosh [-infinity, -7.0] = [0x11228949ba3a8bp-43, +infinity]; cosh [-infinity, 0.0] = [1.0, +infinity]; cosh [-infinity, +8.0] = [1.0, +infinity]; cosh [entire] = [1.0, +infinity]; cosh [-1.0, 0.0] = [1.0, 0x18b07551d9f551p-52]; cosh [0.0, 0.0] = [1.0, 1.0]; cosh [0.0, +1.0] = [1.0, 0x18b07551d9f551p-52]; cosh [0.0, +8.0] = [1.0, 0x1749eaa93f4e77p-42]; cosh [0.0, +infinity] = [1.0, +infinity]; // regular values cosh [-0.125, 0.0] = [1.0, 0x10200aac16db6fp-52]; cosh [0.0, 0x10000000000001p-53] = [1.0, 0x120ac1862ae8d1p-52]; cosh [-4.5, -0.625] = [0x99d310a496b6dp-51, 0x1681ceb0641359p-47]; cosh [1.0, 3.0] = [0x18b07551d9f55p-48, 0x1422a497d6185fp-49]; cosh [17.0, 0xb145bb71d3dbp-38] = [0x1709348c0ea503p-29, 0x3ffffffffffa34p+968]; } testcase mpfi_cot { // special values cot [-infinity, -7.0] = [entire]; cot [-infinity, 0.0] = [entire]; cot [-infinity, +8.0] = [entire]; cot [entire] = [entire]; cot [-8.0, 0.0] = [entire]; cot [-3.0, 0.0] = [-infinity, 0xe07cf2eb32f0bp-49]; cot [-1.0, 0.0] = [-infinity, -0x148c05d04e1cfdp-53]; cot [0.0, +1.0] = [0x148c05d04e1cfdp-53, +infinity]; cot [0.0, +3.0] = [-0xe07cf2eb32f0bp-49, +infinity]; cot [0.0, +8.0] = [entire]; cot [0.0, +infinity] = [entire]; // regular values cot [-3.0, -2.0] = [0x1d4a42e92faa4dp-54, 0xe07cf2eb32f0bp-49]; cot [-3.0, -0x1921fb54442d19p-52] = [0x5cb3b399d747fp-103, 0xe07cf2eb32f0bp-49]; cot [-2.0, 0x1921fb54442d19p-52] = [entire]; cot [0.125, 0.5] = [0xea4d6bf23e051p-51, 0x1fd549f047f2bbp-50]; cot [0.125, 0x1921fb54442d19p-52] = [-0x172cece675d1fdp-105, 0x1fd549f047f2bbp-50]; cot [0x1921fb54442d19p-52, 4.0] = [entire]; cot [4.0, 0x3243f6a8885a3p-47] = [-0x1d02967c31cdb5p-1, 0x1ba35ba1c6b75dp-53]; cot [0x13a28c59d5433bp-44, 0x9d9462ceaa19dp-43] = [0x148c05d04e1fb7p-53, 0x1cefdde7c84c27p-4]; } testcase mpfi_coth { // special values coth [-infinity, -7.0] = [-0x100001be6c882fp-52, -1.0]; coth [-infinity, 0.0] = [-infinity, -1.0]; coth [-infinity, +8.0] = [entire]; coth [entire] = [entire]; coth [-8.0, 0.0] = [-infinity, -0x1000003c6ab7e7p-52]; coth [-3.0, 0.0] = [-infinity, -0x10145b3cc9964bp-52]; coth [-1.0, 0.0] = [-infinity, -0x150231499b6b1dp-52]; coth [0.0, 0.0] = [empty]; coth [0.0, +1.0] = [0x150231499b6b1dp-52, +infinity]; coth [0.0, +3.0] = [0x10145b3cc9964bp-52, +infinity]; coth [0.0, +8.0] = [0x1000003c6ab7e7p-52, +infinity]; coth [0.0, +infinity] = [1.0, +infinity]; // regular values coth [-3.0, 2.0] = [entire]; coth [-10.0, -8.0] = [-0x1000003c6ab7e8p-52, -0x100000011b4865p-52]; coth [7.0, 17.0] = [0x1000000000000fp-52, 0x100001be6c882fp-52]; coth [0x10000000000001p-58, 0x10000000000001p-53] = [0x114fc6ceb099bdp-51, 0x10005554fa502fp-46]; } testcase mpfi_csc { // special values csc [-infinity, -7.0] = [entire]; csc [-infinity, 0.0] = [entire]; csc [-infinity, 8.0] = [entire]; csc [entire] = [entire]; csc [-8.0, 0.0] = [entire]; csc [-3.0, 0.0] = [-infinity, -1.0]; csc [-1.0, 0.0] = [-infinity, -0x1303aa9620b223p-52]; csc [0.0, 0.0] = [empty]; csc [0.0, +1.0] = [0x1303aa9620b223p-52, +infinity]; csc [0.0, 3.0] = [1.0, +infinity]; csc [0.0, 8.0] = [entire]; csc [0.0, +infinity] = [entire]; // regular values csc [-6.0, 7.0] = [entire]; csc [-6.0, 6.0] = [entire]; csc [-6.0, 5.0] = [entire]; csc [-6.0, 4.0] = [entire]; csc [-6.0, 3.0] = [entire]; csc [-6.0, 2.0] = [entire]; csc [-6.0, 1.0] = [entire]; csc [-6.0, 0.0] = [entire]; csc [-6.0, -1.0] = [entire]; csc [-6.0, -2.0] = [entire]; csc [-6.0, -3.0] = [entire]; csc [-6.0, -4.0] = [1.0, 0x1ca19615f903dap-51]; csc [-6.0, -5.0] = [0x10af73f9df86b7p-52, 0x1ca19615f903dap-51]; csc [-6.0, -6.0] = [0x1ca19615f903d9p-51, 0x1ca19615f903dap-51]; csc [-5.0, 7.0] = [entire]; csc [-5.0, 6.0] = [entire]; csc [-5.0, 5.0] = [entire]; csc [-5.0, 4.0] = [entire]; csc [-5.0, 3.0] = [entire]; csc [-5.0, 2.0] = [entire]; csc [-5.0, 1.0] = [entire]; csc [-5.0, 0.0] = [entire]; csc [-5.0, -1.0] = [entire]; csc [-5.0, -2.0] = [entire]; csc [-5.0, -3.0] = [entire]; csc [-5.0, -4.0] = [1.0, 0x15243e8b2f4642p-52]; csc [-5.0, -5.0] = [0x10af73f9df86b7p-52, 0x10af73f9df86b8p-52]; csc [-4.0, 7.0] = [entire]; csc [-4.0, 6.0] = [entire]; csc [-4.0, 5.0] = [entire]; csc [-4.0, 4.0] = [entire]; csc [-4.0, 3.0] = [entire]; csc [-4.0, 2.0] = [entire]; csc [-4.0, 1.0] = [entire]; csc [-4.0, 0.0] = [entire]; csc [-4.0, -1.0] = [entire]; csc [-4.0, -2.0] = [entire]; csc [-4.0, -3.0] = [entire]; csc [-4.0, -4.0] = [0x15243e8b2f4641p-52, 0x15243e8b2f4642p-52]; csc [-3.0, 7.0] = [entire]; csc [-3.0, 6.0] = [entire]; csc [-3.0, 5.0] = [entire]; csc [-3.0, 4.0] = [entire]; csc [-3.0, 3.0] = [entire]; csc [-3.0, 2.0] = [entire]; csc [-3.0, 1.0] = [entire]; csc [-3.0, 0.0] = [-infinity, -1.0]; csc [-3.0, -1.0] = [-0x1c583c440ab0dap-50, -1.0]; csc [-3.0, -2.0] = [-0x1c583c440ab0dap-50, -0x119893a272f912p-52]; csc [-3.0, -3.0] = [-0x1c583c440ab0dap-50, -0x1c583c440ab0d9p-50]; csc [-2.0, 7.0] = [entire]; csc [-2.0, 6.0] = [entire]; csc [-2.0, 5.0] = [entire]; csc [-2.0, 4.0] = [entire]; csc [-2.0, 3.0] = [entire]; csc [-2.0, 2.0] = [entire]; csc [-2.0, 1.0] = [entire]; csc [-2.0, 0.0] = [-infinity, -1.0]; csc [-2.0, -1.0] = [-0x1303aa9620b224p-52, -1.0]; csc [-2.0, -2.0] = [-0x119893a272f913p-52, -0x119893a272f912p-52]; csc [-1.0, 7.0] = [entire]; csc [-1.0, 6.0] = [entire]; csc [-1.0, 5.0] = [entire]; csc [-1.0, 4.0] = [entire]; csc [-1.0, 3.0] = [entire]; csc [-1.0, 2.0] = [entire]; csc [-1.0, 1.0] = [entire]; csc [-1.0, 0.0] = [-infinity, -0x1303aa9620b223p-52]; csc [-1.0, -1.0] = [-0x1303aa9620b224p-52, -0x1303aa9620b223p-52]; csc [1.0, 7.0] = [entire]; csc [1.0, 6.0] = [entire]; csc [1.0, 5.0] = [entire]; csc [1.0, 4.0] = [entire]; csc [1.0, 3.0] = [1.0, 0x1c583c440ab0dap-50]; csc [1.0, 2.0] = [1.0, 0x1303aa9620b224p-52]; csc [1.0, 1.0] = [0x1303aa9620b223p-52, 0x1303aa9620b224p-52]; csc [2.0, 7.0] = [entire]; csc [2.0, 6.0] = [entire]; csc [2.0, 5.0] = [entire]; csc [2.0, 4.0] = [entire]; csc [2.0, 3.0] = [0x119893a272f912p-52, 0x1c583c440ab0dap-50]; csc [2.0, 2.0] = [0x119893a272f912p-52, 0x119893a272f913p-52]; csc [3.0, 7.0] = [entire]; csc [3.0, 6.0] = [entire]; csc [3.0, 5.0] = [entire]; csc [3.0, 4.0] = [entire]; csc [3.0, 3.0] = [0x1c583c440ab0d9p-50, 0x1c583c440ab0dap-50]; csc [4.0, 7.0] = [entire]; csc [4.0, 6.0] = [-0x1ca19615f903dap-51, -1.0]; csc [4.0, 5.0] = [-0x15243e8b2f4642p-52, -1.0]; csc [4.0, 4.0] = [-0x15243e8b2f4642p-52, -0x15243e8b2f4641p-52]; csc [5.0, 7.0] = [entire]; csc [5.0, 6.0] = [-0x1ca19615f903dap-51, -0x10af73f9df86b7p-52]; csc [5.0, 5.0] = [-0x10af73f9df86b8p-52, -0x10af73f9df86b7p-52]; csc [6.0, 7.0] = [entire]; csc [6.0, 6.0] = [-0x1ca19615f903dap-51, -0x1ca19615f903d9p-51]; csc [7.0, 7.0] = [+0x185a86a4ceb06cp-52, +0x185a86a4ceb06dp-52]; } testcase mpfi_csch { // special values csch [-infinity, -7.0] = [-0x1de16d3cffcd54p-62, 0.0]; csch [-infinity, 0.0] = [-infinity, 0.0]; csch [-infinity, +8.0] = [entire]; csch [entire] = [entire]; csch [-8.0, 0.0] = [-infinity, -0x15fc212d92371ap-63]; csch [-3.0, 0.0] = [-infinity, -0x198de80929b901p-56]; csch [-1.0, 0.0] = [-infinity, -0x1b3ab8a78b90c0p-53]; csch [0.0, 0.0] = [empty]; csch [0.0, +1.0] = [0x1b3ab8a78b90c0p-53, +infinity]; csch [0.0, +3.0] = [0x198de80929b901p-56, +infinity]; csch [0.0, +8.0] = [0x15fc212d92371ap-63, +infinity]; csch [0.0, +infinity] = [0.0, +infinity]; // regular values csch [-3.0, 2.0] = [entire]; csch [-10.0, -8.0] = [-0x15fc212d92371bp-63, -0x17cd79b63733a0p-66]; csch [7.0, 17.0] = [0x1639e3175a68a7p-76, 0x1de16d3cffcd54p-62]; csch [0x10000000000001p-58, 0x10000000000001p-53] = [0x1eb45dc88defeap-52, 0x3fff555693e722p-48]; } testcase mpfi_d_div { // special values div [-0x170ef54646d496p-107, -0x170ef54646d496p-107] [-infinity, -7.0] = [0.0, 0x1a5a3ce29a1787p-110]; div [0.0, 0.0] [-infinity, -7.0] = [0.0, 0.0]; div [0x170ef54646d496p-107, 0x170ef54646d496p-107] [-infinity, -7.0] = [-0x1a5a3ce29a1787p-110, 0.0]; div [-0x170ef54646d497p-106, -0x170ef54646d497p-106] [-infinity, 0.0] = [0.0, +infinity]; div [0.0, 0.0] [-infinity, 0.0] = [0.0, 0.0]; div [0x170ef54646d497p-106, 0x170ef54646d497p-106] [-infinity, 0.0] = [-infinity, 0.0]; div [-0x16345785d8a00000p0, -0x16345785d8a00000p0] [-infinity, 8.0] = [entire]; div [0.0, 0.0] [-infinity, 8.0] = [0.0, 0.0]; div [0x16345785d8a00000p0, 0x16345785d8a00000p0] [-infinity, 8.0] = [entire]; div [-0x170ef54646d497p-105, -0x170ef54646d497p-105] [entire] = [entire]; div [0.0e-17, 0.0e-17] [entire] = [0.0, 0.0]; div [+0x170ef54646d497p-105, +0x170ef54646d497p-105] [entire] = [entire]; div [-0x170ef54646d497p-109, -0x170ef54646d497p-109] [0.0, 0.0] = [empty]; div [0.0, 0.0] [0.0, 0.0] = [empty]; div [0x170ef54646d497p-109, 0x170ef54646d497p-109] [0.0, 0.0] = [empty]; div [-0x114b37f4b51f71p-107, -0x114b37f4b51f71p-107] [0.0, 7.0] = [-infinity, -0x13c3ada9f391a5p-110]; div [0.0, 0.0] [0.0, 7.0] = [0.0, 0.0]; div [0x114b37f4b51f71p-107, 0x114b37f4b51f71p-107] [0.0, 7.0] = [0x13c3ada9f391a5p-110, +infinity]; div [-0x50b45a75f7e81p-104, -0x50b45a75f7e81p-104] [0.0, +infinity] = [-infinity, 0.0]; div [0.0, 0.0] [0.0, +infinity] = [0.0, 0.0]; div [0x142d169d7dfa03p-106, 0x142d169d7dfa03p-106] [0.0, +infinity] = [0.0, +infinity]; // regular values div [-2.5, -2.5] [-8.0, 8.0] = [entire]; div [-2.5, -2.5] [-8.0, -5.0] = [0x5p-4, 0.5]; div [-2.5, -2.5] [25.0, 40.0] = [-0x1999999999999ap-56, -0x1p-4]; div [-2.5, -2.5] [-16.0, -7.0] = [0x5p-5, 0x16db6db6db6db7p-54]; div [-2.5, -2.5] [11.0, 143.0] = [-0x1d1745d1745d18p-55, -0x11e6efe35b4cfap-58]; div [33.125, 33.125] [8.28125, 530.0] = [0x1p-4, 4.0]; div [33.125, 33.125] [-530.0, -496.875] = [-0x11111111111112p-56, -0x1p-4]; div [33.125, 33.125] [54.0, 265.0] = [0.125, 0x13a12f684bda13p-53]; div [33.125, 33.125] [52.0, 54.0] = [0x13a12f684bda12p-53, 0x14627627627628p-53]; } testcase mpfi_diam_abs { // special values wid [-infinity, -8.0] = +infinity; wid [-infinity, 0.0] = +infinity; wid [-infinity, 5.0] = +infinity; wid [entire] = +infinity; wid [-infinity, 0.0] = +infinity; wid [-8.0, 0.0] = +8; wid [0.0, 0.0] = -0; wid [0.0, 5.0] = +5; wid [0.0, +infinity] = +infinity; // regular values wid [-34.0, -17.0] = 17; } testcase mpfi_div { // special values div [-infinity, -7.0] [-1.0, +8.0] = [entire]; div [-infinity, 0.0] [+8.0, +infinity] = [-infinity, 0.0]; div [-infinity, +8.0] [0.0, +8.0] = [entire]; div [entire] [0.0, +8.0] = [entire]; div [0.0, 0.0] [-infinity, -7.0] = [0.0, 0.0]; div [0.0, +8.0] [-7.0, 0.0] = [-infinity, 0.0]; div [0.0, 0.0] [0.0, +8.0] = [0.0, 0.0]; div [0.0, +infinity] [0.0, +8.0] = [0.0, +infinity]; div [0.0, 0.0] [+8.0, +infinity] = [0.0, 0.0]; div [0.0, 0.0] [entire] = [0.0, 0.0]; div [0.0, +8.0] [-7.0, +8.0] = [entire]; div [0.0, +infinity] [0.0, +8.0] = [0.0, +infinity]; // regular value div [-0x75bcd15p0, -0x754ep0] [-0x11ep0, -0x9p0] = [0x69p0, 0xd14fadp0]; div [-0x75bcd15p0, -0x1.489c07caba163p-4] [-0x2.e8e36e560704ap+4, -0x9p0] = [0x7.0ef61537b1704p-12, 0xd14fadp0]; div [-0x1.02f0415f9f596p+0, -0x754ep-16] [-0x11ep0, -0x7.62ce64fbacd2cp-8] = [0x69p-16, 0x2.30ee5eef9c36cp+4]; div [-0x1.02f0415f9f596p+0, -0x1.489c07caba163p-4] [-0x2.e8e36e560704ap+0, -0x7.62ce64fbacd2cp-8] = [0x7.0ef61537b1704p-8, 0x2.30ee5eef9c36cp+4]; div [-0xacbp+256, -0x6f9p0] [-0x7p0, 0.0] = [0xffp0, +infinity]; div [-0x100p0, -0xe.bb80d0a0824ep-4] [-0x1.7c6d760a831fap+0, 0.0] = [0x9.e9f24790445fp-4, +infinity]; div [-0x1.25f2d73472753p+0, -0x9.9a19fd3c1fc18p-4] [-0x9.3b0c8074ccc18p-4, +0x4.788df5d72af78p-4] = [entire]; div [-100.0, -15.0] [0.0, +3.0] = [-infinity, -5.0]; div [-2.0, -0x1.25f2d73472753p+0] [0.0, +0x9.3b0c8074ccc18p-4] = [-infinity, -0x1.fd8457415f917p+0]; div [-0x123456789p0, -0x754ep+4] [0x40bp0, 0x11ep+4] = [-0x480b3bp0, -0x69p0]; div [-0xd.67775e4b8588p-4, -0x754ep-53] [0x4.887091874ffc8p+0, 0x11ep+201] = [-0x2.f5008d2df94ccp-4, -0x69p-254]; div [-0x123456789p0, -0x1.b0a62934c76e9p+0] [0x40bp-17, 0x2.761ec797697a4p-4] = [-0x480b3bp+17, -0xa.fc5e7338f3e4p+0]; div [-0xd.67775e4b8588p+0, -0x1.b0a62934c76e9p+0] [0x4.887091874ffc8p-4, 0x2.761ec797697a4p+4] = [-0x2.f5008d2df94ccp+4, -0xa.fc5e7338f3e4p-8]; div [-0x75bcd15p0, 0.0] [-0x90p0, -0x9p0] = [0.0, 0xd14fadp0]; div [-0x1.4298b2138f2a7p-4, 0.0] [-0x1p-8, -0xf.5e4900c9c19fp-12] = [0.0, 0x1.4fdb41a33d6cep+4]; div [-0xeeeeeeeeep0, 0.0] [-0xaaaaaaaaap0, 0.0] = [0.0, +infinity]; div [-0x1.25f2d73472753p+0, 0.0] [-0x9.3b0c8074ccc18p-4, +0x4.788df5d72af78p-4] = [entire]; div [-0xeeeeeeeeep0, 0.0] [0.0, +0x3p0] = [-infinity, 0.0]; div [-0x75bcd15p0, 0.0] [0x9p0, 0x90p0] = [-0xd14fadp0, 0.0]; div [-0x1.4298b2138f2a7p-4, 0.0] [0xf.5e4900c9c19fp-12, 0x9p0] = [-0x1.4fdb41a33d6cep+4, 0.0]; div [-0x75bcd15p0, 0xa680p0] [-0xaf6p0, -0x9p0] = [-0x1280p0, 0xd14fadp0]; div [-0x12p0, 0x10p0] [-0xbbbbbbbbbbp0, -0x9p0] = [-0x1.c71c71c71c71dp0, 2.0]; div [-0x1p0, 0x754ep-16] [-0xccccccccccp0, -0x11ep0] = [-0x69p-16, 0xe.525982af70c9p-12]; div [-0xb.5b90b4d32136p-4, 0x6.e694ac6767394p+0] [-0xdddddddddddp0, -0xc.f459be9e80108p-4] = [-0x8.85e40b3c3f63p+0, 0xe.071cbfa1de788p-4]; div [-0xacbp+256, 0x6f9p0] [-0x7p0, 0.0] = [entire]; div [-0x1.25f2d73472753p+0, +0x9.9a19fd3c1fc18p-4] [-0x9.3b0c8074ccc18p-4, +0x4.788df5d72af78p-4] = [entire]; div [0.0, +15.0] [-3.0, +3.0] = [entire]; div [-0x754ep0, 0xd0e9dc4p+12] [0x11ep0, 0xbbbp0] = [-0x69p0, 0xbaffep+12]; div [-0x10p0, 0xd0e9dc4p+12] [0x11ep0, 0xbbbp0] = [-0xe.525982af70c9p-8, 0xbaffep+12]; div [-0x754ep0, 0x1p+10] [0x11ep0, 0xbbbp0] = [-0x69p0, 0xe.525982af70c9p-2]; div [-0x1.18333622af827p+0, 0x2.14b836907297p+0] [0x1.263147d1f4bcbp+0, 0x111p0] = [-0xf.3d2f5db8ec728p-4, 0x1.cf8fa732de129p+0]; div [0.0, 0x75bcd15p0] [-0xap0, -0x9p0] = [-0xd14fadp0, 0.0]; div [0.0, 0x1.acbf1702af6edp+0] [-0x0.fp0, -0xe.3d7a59e2bdacp-4] = [-0x1.e1bb896bfda07p+0, 0.0]; div [0.0, 0xap0] [-0x9p0, 0.0] = [-infinity, 0.0]; div [0.0, 0xap0] [-1.0, +1.0] = [entire]; div [0.0, 0x75bcd15p0] [+0x9p0, +0xap0] = [0.0, 0xd14fadp0]; div [0.0, 0x1.5f6b03dc8c66fp+0] [+0x2.39ad24e812dcep+0, 0xap0] = [0.0, 0x9.deb65b02baep-4]; div [0x754ep0, 0x75bcd15p0] [-0x11ep0, -0x9p0] = [-0xd14fadp0, -0x69p0]; div [0x754ep-16, 0x1.008a3accc766dp+4] [-0x11ep0, -0x2.497403b31d32ap+0] = [-0x7.02d3edfbc8b6p+0, -0x69p-16]; div [0x9.ac412ff1f1478p-4, 0x75bcd15p0] [-0x1.5232c83a0e726p+4, -0x9p0] = [-0xd14fadp0, -0x7.52680a49e5d68p-8]; div [0xe.1552a314d629p-4, 0x1.064c5adfd0042p+0] [-0x5.0d4d319a50b04p-4, -0x2.d8f51df1e322ep-4] = [-0x5.c1d97d57d81ccp+0, -0x2.c9a600c455f5ap+0]; div [0x754ep0, 0xeeeep0] [-0x11ep0, 0.0] = [-infinity, -0x69p0]; div [0x1.a9016514490e6p-4, 0xeeeep0] [-0xe.316e87be0b24p-4, 0.0] = [-infinity, -0x1.df1cc82e6a583p-4]; div [5.0, 6.0] [-0x5.0d4d319a50b04p-4, 0x2.d8f51df1e322ep-4] = [entire]; div [0x754ep0, +0xeeeeep0] [0.0, +0x11ep0] = [0x69p0, +infinity]; div [0x1.7f03f2a978865p+0, 0xeeeeep0] [0.0, 0x1.48b08624606b9p+0] = [0x1.2a4fcda56843p+0, +infinity]; div [0x5efc1492p0, 0x1ba2dc763p0] [0x2fdd1fp0, 0x889b71p0] = [0xb2p0, 0x93dp0]; div [0x1.d7c06f9ff0706p-8, 0x1ba2dc763p0] [0x2fdd1fp-20, 0xe.3d7a59e2bdacp+0] = [0x2.120d75be74b54p-12, 0x93dp+20]; div [0x5.efc1492p-4, 0x1.008a3accc766dp+0] [0x2.497403b31d32ap+0, 0x8.89b71p+0] = [0xb.2p-8, 0x7.02d3edfbc8b6p-4]; div [0x8.440e7d65be6bp-8, 0x3.99982e9eae09ep+0] [0x8.29fa8d0659e48p-4, 0xc.13d2fd762e4a8p-4] = [0xa.f3518768b206p-8, 0x7.0e2acad54859cp+0]; } testcase mpfi_div_d { // special values div [-infinity, -7.0] [-7.0, -7.0] = [1.0, +infinity]; div [-infinity, -7.0] [0.0, 0.0] = [empty]; div [-infinity, -7.0] [7.0, 7.0] = [-infinity, -1.0]; div [-infinity, 0.0] [-0x170ef54646d497p-106, -0x170ef54646d497p-106] = [0.0, +infinity]; div [-infinity, 0.0] [0x170ef54646d497p-106, 0x170ef54646d497p-106] = [-infinity, 0.0]; div [-infinity, 8.0] [-3.0, -3.0] = [-0x15555555555556p-51, +infinity]; div [-infinity, 8.0] [0.0, 0.0] = [empty]; div [-infinity, 8.0] [3.0, 3.0] = [-infinity, 0x15555555555556p-51]; div [entire] [-0x170ef54646d497p-105, -0x170ef54646d497p-105] = [entire]; div [entire] [0.0e-17, 0.0e-17] = [empty]; div [entire] [+0x170ef54646d497p-105, +0x170ef54646d497p-105] = [entire]; div [0.0, 0.0] [-0x170ef54646d497p-109, -0x170ef54646d497p-109] = [0.0, 0.0]; div [0.0, 0.0] [0x170ef54646d497p-109, 0x170ef54646d497p-109] = [0.0, 0.0]; div [0.0, 8.0] [-0x114b37f4b51f71p-107, -0x114b37f4b51f71p-107] = [-0x1d9b1f5d20d556p+5, 0.0]; div [0.0, 8.0] [0x114b37f4b51f71p-107, 0x114b37f4b51f71p-107] = [0.0, 0x1d9b1f5d20d556p+5]; div [0.0, +infinity] [-0x50b45a75f7e81p-104, -0x50b45a75f7e81p-104] = [-infinity, 0.0]; div [0.0, +infinity] [0x142d169d7dfa03p-106, 0x142d169d7dfa03p-106] = [0.0, +infinity]; // regular values div [-0x10000000000001p-20, -0x10000000000001p-53] [-1.0, -1.0] = [0x10000000000001p-53, 0x10000000000001p-20]; div [-0x10000000000002p-20, -0x10000000000001p-53] [0x10000000000001p-53, 0x10000000000001p-53] = [-0x10000000000001p-19, -1.0]; div [-0x10000000000001p-20, -0x10000020000001p-53] [0x10000000000001p-53, 0x10000000000001p-53] = [-0x1p+33, -0x1000001fffffffp-52]; div [-0x10000000000002p-20, -0x10000020000001p-53] [0x10000000000001p-53, 0x10000000000001p-53] = [-0x10000000000001p-19, -0x1000001fffffffp-52]; div [-0x123456789abcdfp-53, 0x123456789abcdfp-7] [-0x123456789abcdfp0, -0x123456789abcdfp0] = [-0x1p-7, 0x1p-53]; div [-0x123456789abcdfp-53, 0x10000000000001p-53] [-0x123456789abcdfp0, -0x123456789abcdfp0] = [-0x1c200000000002p-106, 0x1p-53]; div [-1.0, 0x123456789abcdfp-7] [-0x123456789abcdfp0, -0x123456789abcdfp0] = [-0x1p-7, 0x1c200000000001p-105]; div [-1.0, 0x10000000000001p-53] [-0x123456789abcdfp0, -0x123456789abcdfp0] = [-0x1c200000000002p-106, 0x1c200000000001p-105]; } testcase mpfi_d_sub { // special values sub [-0x170ef54646d497p-107, -0x170ef54646d497p-107] [-infinity, -7.0] = [0x1bffffffffffffp-50, +infinity]; sub [0.0, 0.0] [-infinity, -7.0] = [7.0, +infinity]; sub [0x170ef54646d497p-107, 0x170ef54646d497p-107] [-infinity, -7.0] = [7.0, +infinity]; sub [-0x170ef54646d497p-96, -0x170ef54646d497p-96] [-infinity, 0.0] = [-0x170ef54646d497p-96, +infinity]; sub [0.0, 0.0] [-infinity, 0.0] = [0.0, +infinity]; sub [0x170ef54646d497p-96, 0x170ef54646d497p-96] [-infinity, 0.0] = [0x170ef54646d497p-96, +infinity]; sub [-0x16345785d8a00000p0, -0x16345785d8a00000p0] [-infinity, 8.0] = [-0x16345785d8a00100p0, +infinity]; sub [0.0, 0.0] [-infinity, 8.0] = [-8.0, +infinity]; sub [0x16345785d8a00000p0, 0x16345785d8a00000p0] [-infinity, 8.0] = [0x16345785d89fff00p0, +infinity]; sub [-0x170ef54646d497p-105, -0x170ef54646d497p-105] [entire] = [entire]; sub [0.0e-17, 0.0e-17] [entire] = [entire]; sub [0x170ef54646d497p-105, 0x170ef54646d497p-105] [entire] = [entire]; sub [-0x170ef54646d497p-109, -0x170ef54646d497p-109] [0.0, 0.0] = [-0x170ef54646d497p-109, -0x170ef54646d497p-109]; sub [0.0, 0.0] [0.0, 0.0] = [0.0, 0.0]; sub [0x170ef54646d497p-109, 0x170ef54646d497p-109] [0.0, 0.0] = [0x170ef54646d497p-109, 0x170ef54646d497p-109]; sub [-0x114b37f4b51f71p-107, -0x114b37f4b51f71p-107] [0.0, 8.0] = [-0x10000000000001p-49, -0x114b37f4b51f71p-107]; sub [0.0, 0.0] [0.0, 8.0] = [-8.0, 0.0]; sub [0x114b37f4b51f71p-107, 0x114b37f4b51f71p-107] [0.0, 8.0] = [-8.0, 0x114b37f4b51f71p-107]; sub [-0x50b45a75f7e81p-104, -0x50b45a75f7e81p-104] [0.0, +infinity] = [-infinity, -0x50b45a75f7e81p-104]; sub [0.0, 0.0] [0.0, +infinity] = [-infinity, 0.0]; sub [-0x142d169d7dfa03p-106, -0x142d169d7dfa03p-106] [0.0, +infinity] = [-infinity, -0x142d169d7dfa03p-106]; // regular values sub [-0xfb53d14aa9c2fp-47, -0xfb53d14aa9c2fp-47] [17.0, 32.0] = [-0x1fb53d14aa9c2fp-47, -0x18353d14aa9c2fp-47]; sub [0xfb53d14aa9c2fp-47, 0xfb53d14aa9c2fp-47] [17.0, 0xfb53d14aa9c2fp-47] = [0.0, 0x7353d14aa9c2fp-47]; sub [0xfb53d14aa9c2fp-48, 0xfb53d14aa9c2fp-48] [0xfb53d14aa9c2fp-48, 32.0] = [-0x104ac2eb5563d1p-48, 0.0]; sub [3.5, 3.5] [-0x123456789abcdfp-4, -0x123456789abcdfp-48] = [0x15b456789abcdfp-48, 0x123456789abd17p-4]; sub [3.5, 3.5] [-0x123456789abcdfp-4, -0x123456789abcdfp-56] = [0x3923456789abcdp-52, 0x123456789abd17p-4]; sub [256.5, 256.5] [-0x123456789abcdfp-52, 0xffp0] = [0x18p-4, 0x101a3456789abdp-44]; sub [4097.5, 4097.5] [0x1p-550, 0x1fffffffffffffp-52] = [0xfff8p-4, 0x10018p-4]; sub [-3.5, -3.5] [-0x123456789abcdfp-4, -0x123456789abcdfp-48] = [0xeb456789abcdfp-48, 0x123456789abca7p-4]; sub [-3.5, -3.5] [-0x123456789abcdfp-4, -0x123456789abcdfp-56] = [-0x36dcba98765434p-52, 0x123456789abca7p-4]; sub [-256.5, -256.5] [-0x123456789abcdfp-52, 0xffp0] = [-0x1ff8p-4, -0xff5cba9876543p-44]; sub [-4097.5, -4097.5] [0x1p-550, 0x1fffffffffffffp-52] = [-0x10038p-4, -0x10018p-4]; } testcase mpfi_exp { // special values exp [-infinity, -7.0] = [0.0, 0x1de16b9c24a98fp-63]; exp [-infinity, 0.0] = [0.0, 1.0]; exp [-infinity, +1.0] = [0.0, 0x15bf0a8b14576ap-51]; exp [entire] = [0.0, +infinity]; exp [0.0, 0.0] = [1.0, 1.0]; exp [0.0, +1.0] = [1.0, 0x15bf0a8b14576ap-51]; exp [0.0, +infinity] = [1.0, +infinity]; // regular values exp [-123.0, -17.0] = [0x1766b45dd84f17p-230, 0x1639e3175a689dp-77]; exp [-0.125, 0.25] = [0x1c3d6a24ed8221p-53, 0x148b5e3c3e8187p-52]; exp [-0.125, 0.0] = [0x1c3d6a24ed8221p-53, 1.0]; exp [0.0, 0.25] = [1.0, 0x148b5e3c3e8187p-52]; exp [0xap-47, 0xbp-47] = [0x10000000000140p-52, 0x10000000000161p-52]; } testcase mpfi_exp2 { // special values exp2 [-infinity, -1.0] = [0.0, 0.5]; exp2 [-infinity, 0.0] = [0.0, 1.0]; exp2 [-infinity, 1.0] = [0.0, 2.0]; exp2 [entire] = [0.0, +infinity]; exp2 [0.0, 0.0] = [1.0, 1.0]; exp2 [0.0, +1.0] = [1.0, 2.0]; exp2 [0.0, +infinity] = [1.0, +infinity]; // regular values exp2 [-123.0, -17.0] = [0x1p-123, 0x1p-17]; exp2 [-7.0, 7.0] = [0x1p-7, 0x1p+7]; exp2 [-0.125, 0.25] = [0x1d5818dcfba487p-53, 0x1306fe0a31b716p-52]; exp2 [-0.125, 0.0] = [0x1d5818dcfba487p-53, 1.0]; exp2 [0.0, 0.25] = [1.0, 0x1306fe0a31b716p-52]; exp2 [0xap-47, 0xbp-47] = [0x100000000000ddp-52, 0x100000000000f4p-52]; } testcase mpfi_expm1 { // special values expm1 [-infinity, -7.0] = [-1.0, -0x1ff887a518f6d5p-53]; expm1 [-infinity, 0.0] = [-1.0, 0.0]; expm1 [-infinity, 1.0] = [-1.0, 0x1b7e151628aed3p-52]; expm1 [entire] = [-1.0, +infinity]; expm1 [0.0, 0.0] = [0.0, 0.0]; expm1 [0.0, 1.0] = [0.0, 0x1b7e151628aed3p-52]; expm1 [0.0, +infinity] = [0.0, +infinity]; // regular values expm1 [-36.0, -36.0] = [-0x1ffffffffffffep-53, -0x1ffffffffffffdp-53]; expm1 [-0.125, 0.25] = [-0x1e14aed893eef4p-56, 0x122d78f0fa061ap-54]; expm1 [-0.125, 0.0] = [-0x1e14aed893eef4p-56, 0.0]; expm1 [0.0, 0.25] = [0.0, 0x122d78f0fa061ap-54]; expm1 [0xap-47, 0xbp-47] = [0x140000000000c8p-96, 0x160000000000f3p-96]; } testcase mpfi_hypot { // special values hypot [-infinity, -7.0] [-1.0, 8.0] = [7.0, +infinity]; hypot [-infinity, 0.0] [8.0, +infinity] = [8.0, +infinity]; hypot [-infinity, 8.0] [0.0, 8.0] = [0.0, +infinity]; hypot [entire] [0.0, 8.0] = [0.0, +infinity]; hypot [0.0, 0.0] [-infinity, -7.0] = [7.0, +infinity]; hypot [0.0, 3.0] [-4.0, 0.0] = [0.0, 5.0]; hypot [0.0, 0.0] [0.0, 8.0] = [0.0, 8.0]; hypot [0.0, +infinity] [0.0, 8.0] = [0.0, +infinity]; hypot [0.0, 0.0] [8.0, +infinity] = [8.0, +infinity]; hypot [0.0, 0.0] [entire] = [0.0, +infinity]; hypot [0.0, 5.0] [0.0, 12.0] = [0.0, 13.0]; hypot [0.0, 0.0] [0.0, 0.0] = [0.0, 0.0]; hypot [0.0, +infinity] [-7.0, 8.0] = [0.0, +infinity]; // regular values hypot [-12.0, -5.0] [-35.0, -12.0] = [13.0, 37.0]; hypot [6.0, 7.0] [1.0, 24.0] = [0x1854bfb363dc39p-50, 25.0]; hypot [-4.0, +7.0] [-25.0, 3.0] = [0.0, 0x19f625847a5899p-48]; hypot [0x1854bfb363dc39p-50, 0x19f625847a5899p-48] [0x1854bfb363dc39p-50, 0x19f625847a5899p-48] = [0x113463fa37014dp-49, 0x125b89092b8fc0p-47]; } testcase mpfi_intersect { // special values intersection [-infinity, -7.0] [-1.0, +8.0] = [empty]; intersection [-infinity, 0.0] [+8.0, +infinity] = [empty]; intersection [-infinity, +8.0] [0.0, +8.0] = [0.0, +8.0]; intersection [entire] [0.0, +8.0] = [0.0, +8.0]; intersection [0.0, 0.0] [-infinity, -7.0] = [empty]; intersection [0.0, +8.0] [-7.0, 0.0] = [0.0, 0.0]; intersection [0.0, 0.0] [0.0, +8.0] = [0.0, 0.0]; intersection [0.0, +infinity] [0.0, +8.0] = [0.0, +8.0]; intersection [0.0, 0.0] [+8.0, +infinity] = [empty]; intersection [0.0, 0.0] [entire] = [0.0, 0.0]; intersection [0.0, +8.0] [-7.0, +8.0] = [0.0, +8.0]; intersection [0.0, 0.0] [0.0, 0.0] = [0.0, 0.0]; intersection [0.0, +infinity] [0.0, +8.0] = [0.0, +8.0]; // regular values intersection [0x12p0, 0x90p0] [-0x0dp0, 0x34p0] = [0x12p0, 0x34p0]; } testcase mpfi_inv { // special values recip [-infinity, -.25] = [-4.0, 0.0]; recip [-infinity, 0.0] = [-infinity, 0.0]; recip [-infinity, +4.0] = [entire]; recip [entire] = [entire]; recip [0.0, 0.0] = [empty]; recip [0.0, +2.0] = [+.5, +infinity]; recip [0.0, +infinity] = [0.0, +infinity]; // regular values recip [-8.0, -2.0] = [-.5, -0.125]; recip [0x1p-4, 0x1440c131282cd9p-53] = [0x1947bfce1bc417p-52, 0x10p0]; recip [0x19f1a539c91fddp-55, +64.0] = [0.015625, 0x13bc205a76b3fdp-50]; recip [-0xae83b95effd69p-52, -0x63e3cb4ed72a3p-53] = [-0x1480a9b5772a23p-50, -0x177887d65484c9p-52]; } testcase mpfi_is_neg { // special values precedes [-infinity, -8.0] [0.0, 0.0] = true; precedes [-infinity, 0.0] [0.0, 0.0] = true; precedes [-infinity, 5.0] [0.0, 0.0] = false; precedes [entire] [0.0, 0.0] = false; precedes [-8.0, 0.0] [0.0, 0.0] = true; precedes [0.0, 0.0] [0.0, 0.0] = true; precedes [0.0, 5.0] [0.0, 0.0] = false; precedes [0.0, +infinity] [0.0, 0.0] = false; precedes [5.0, +infinity] [0.0, 0.0] = false; // regular values precedes [-34.0, -17.0] [0.0, 0.0] = true; precedes [-8.0, -1.0] [0.0, 0.0] = true; precedes [-34.0, 17.0] [0.0, 0.0] = false; precedes [-0x1921fb54442d18p-51, 0x1921fb54442d19p-51] [0.0, 0.0] = false; precedes [0x1921fb54442d18p-51, 0x1921fb54442d19p-51] [0.0, 0.0] = false; precedes [+8.0, +0x7fffffffffffbp+51] [0.0, 0.0] = false; precedes [+0x1fffffffffffffp-53, 2.0] [0.0, 0.0] = false; } testcase mpfi_is_nonneg { // special values less [0.0, 0.0] [-infinity, -8.0] = false; less [0.0, 0.0] [-infinity, 0.0] = false; less [0.0, 0.0] [-infinity, 5.0] = false; less [0.0, 0.0] [entire] = false; less [0.0, 0.0] [-8.0, 0.0] = false; less [0.0, 0.0] [0.0, 0.0] = true; less [0.0, 0.0] [0.0, 5.0] = true; less [0.0, 0.0] [0.0, +infinity] = true; less [0.0, 0.0] [5.0, +infinity] = true; // regular values less [0.0, 0.0] [-34.0, -17.0] = false; less [0.0, 0.0] [-8.0, -1.0] = false; less [0.0, 0.0] [-34.0, 17.0] = false; less [0.0, 0.0] [-0x1921fb54442d18p-51, 0x1921fb54442d19p-51] = false; less [0.0, 0.0] [0x1921fb54442d18p-51, 0x1921fb54442d19p-51] = true; less [0.0, 0.0] [+8.0, +0x7fffffffffffbp+51] = true; less [0.0, 0.0] [+0x1fffffffffffffp-53, 2.0] = true; } testcase mpfi_is_nonpos { // special values less [-infinity, -8.0] [0.0, 0.0] = true; less [-infinity, 0.0] [0.0, 0.0] = true; less [-infinity, 5.0] [0.0, 0.0] = false; less [entire] [0.0, 0.0] = false; less [-8.0, 0.0] [0.0, 0.0] = true; less [0.0, 0.0] [0.0, 0.0] = true; less [0.0, 5.0] [0.0, 0.0] = false; less [0.0, +infinity] [0.0, 0.0] = false; less [5.0, +infinity] [0.0, 0.0] = false; // regular values less [-34.0, -17.0] [0.0, 0.0] = true; less [-8.0, -1.0] [0.0, 0.0] = true; less [-34.0, 17.0] [0.0, 0.0] = false; less [-0x1921fb54442d18p-51, 0x1921fb54442d19p-51] [0.0, 0.0] = false; less [0x1921fb54442d18p-51, 0x1921fb54442d19p-51] [0.0, 0.0] = false; less [8.0, 0x7fffffffffffbp+51] [0.0, 0.0] = false; less [0x1fffffffffffffp-53, 2.0] [0.0, 0.0] = false; } testcase mpfi_is_pos { // special values precedes [0.0, 0.0] [-infinity, -8.0] = false; precedes [0.0, 0.0] [-infinity, 0.0] = false; precedes [0.0, 0.0] [-infinity, 5.0] = false; precedes [0.0, 0.0] [entire] = false; precedes [0.0, 0.0] [-8.0, 0.0] = false; precedes [0.0, 0.0] [0.0, 0.0] = true; precedes [0.0, 0.0] [0.0, 5.0] = true; precedes [0.0, 0.0] [0.0, +infinity] = true; precedes [0.0, 0.0] [5.0, +infinity] = true; // regular values precedes [0.0, 0.0] [-34.0, -17.0] = false; precedes [0.0, 0.0] [-8.0, -1.0] = false; precedes [0.0, 0.0] [-34.0, 17.0] = false; precedes [0.0, 0.0] [-0x1921fb54442d18p-51, 0x1921fb54442d19p-51] = false; precedes [0.0, 0.0] [0x1921fb54442d18p-51, 0x1921fb54442d19p-51] = true; precedes [0.0, 0.0] [+8.0, +0x7fffffffffffbp+51] = true; precedes [0.0, 0.0] [+0x1fffffffffffffp-53, 2.0] = true; } testcase mpfi_is_strictly_neg { // special values strictPrecedes [-infinity, -8.0] [0.0, 0.0] = true; strictPrecedes [-infinity, 0.0] [0.0, 0.0] = false; strictPrecedes [-infinity, 5.0] [0.0, 0.0] = false; strictPrecedes [entire] [0.0, 0.0] = false; strictPrecedes [-8.0, 0.0] [0.0, 0.0] = false; strictPrecedes [0.0, 0.0] [0.0, 0.0] = false; strictPrecedes [0.0, 5.0] [0.0, 0.0] = false; strictPrecedes [0.0, +infinity] [0.0, 0.0] = false; strictPrecedes [5.0, +infinity] [0.0, 0.0] = false; // regular values strictPrecedes [-34.0, -17.0] [0.0, 0.0] = true; strictPrecedes [-8.0, -1.0] [0.0, 0.0] = true; strictPrecedes [-34.0, 17.0] [0.0, 0.0] = false; strictPrecedes [-0x1921fb54442d18p-51, 0x1921fb54442d19p-51] [0.0, 0.0] = false; strictPrecedes [0x1921fb54442d18p-51, 0x1921fb54442d19p-51] [0.0, 0.0] = false; strictPrecedes [+8.0, +0x7fffffffffffbp+51] [0.0, 0.0] = false; strictPrecedes [+0x1fffffffffffffp-53, 2.0] [0.0, 0.0] = false; } testcase mpfi_is_strictly_pos { // special values strictPrecedes [0.0, 0.0] [-infinity, -8.0] = false; strictPrecedes [0.0, 0.0] [-infinity, 0.0] = false; strictPrecedes [0.0, 0.0] [-infinity, 5.0] = false; strictPrecedes [0.0, 0.0] [entire] = false; strictPrecedes [0.0, 0.0] [-8.0, 0.0] = false; strictPrecedes [0.0, 0.0] [0.0, 0.0] = false; strictPrecedes [0.0, 0.0] [0.0, 5.0] = false; strictPrecedes [0.0, 0.0] [0.0, +infinity] = false; strictPrecedes [0.0, 0.0] [5.0, +infinity] = true; // regular values strictPrecedes [0.0, 0.0] [-34.0, -17.0] = false; strictPrecedes [0.0, 0.0] [-8.0, -1.0] = false; strictPrecedes [0.0, 0.0] [-34.0, 17.0] = false; strictPrecedes [0.0, 0.0] [-0x1921fb54442d18p-51, 0x1921fb54442d19p-51] = false; strictPrecedes [0.0, 0.0] [0x1921fb54442d18p-51, 0x1921fb54442d19p-51] = true; strictPrecedes [0.0, 0.0] [+8.0, +0x7fffffffffffbp+51] = true; strictPrecedes [0.0, 0.0] [+0x1fffffffffffffp-53, 2.0] = true; } testcase mpfi_log { // special values log [0.0, +1.0] = [-infinity, 0.0]; log [0.0, +infinity] = [entire]; // regular values log [+1.0, +1.0] = [0.0, 0.0]; log [0x3a2a08c23afe3p-14, 0x1463ceb440d6bdp-14] = [0xc6dc8a2928579p-47, 0x1a9500bc7ffcc5p-48]; log [0xb616ab8b683b5p-52, +1.0] = [-0x2b9b8b1fb2fb9p-51, 0.0]; log [+1.0, 0x8ac74d932fae3p-21] = [0.0, 0x5380455576989p-46]; log [0x4c322657ec89bp-16, 0x4d68ba5f26bf1p-11] = [0xbdee7228cfedfp-47, 0x1b3913fc99f555p-48]; } testcase mpfi_log1p { // special values logp1 [-1.0, 0.0] = [-infinity, 0.0]; logp1 [0.0, 0.0] = [0.0, 0.0]; logp1 [0.0, 1.0] = [0.0, 0x162e42fefa39f0p-53]; logp1 [0.0, +infinity] = [0.0, +infinity]; // regular values logp1 [-0xb616ab8b683b5p-52, 0.0] = [-0x13e080325bab7bp-52, 0.0]; logp1 [0.0, 0x8ac74d932fae3p-21] = [0.0, 0x14e0115561569cp-48]; logp1 [0x4c322657ec89bp-16, 0x4d68ba5f26bf1p-11] = [0x17bdce451a337fp-48, 0x1b3913fc99f6fcp-48]; } testcase mpfi_log2 { // special values log2 [0.0, +1.0] = [-infinity, 0.0]; log2 [0.0, +infinity] = [entire]; // regular values log2 [1.0, 1.0] = [0.0, 0.0]; log2 [0xb616ab8b683b5p-52, 1.0] = [-0x1f74cb5d105b3ap-54, 0.0]; log2 [1.0, 0x8ac74d932fae3p-21] = [0.0, 0x1e1ddc27c2c70fp-48]; log2 [0x4c322657ec89bp-16, 0x4d68ba5f26bf1p-11] = [0x112035c9390c07p-47, 0x13a3208f61f10cp-47]; } testcase mpfi_log10 { // special values log10 [0.0, 1.0] = [-infinity, 0.0]; log10 [0.0, +infinity] = [entire]; // regular values log10 [1.0, 1.0] = [0.0, 0.0]; log10 [0x3a2a08c23afe3p-14, 0x1463ceb440d6bdp-14] = [0x159753104a9401p-49, 0x1716c01a04b570p-49]; log10 [0xb616ab8b683b5p-52, 1.0] = [-0x12f043ec00f8d6p-55, 0.0]; log10 [100.0, 0x8ac74d932fae3p-21] = [2.0, 0x1221cc590b9946p-49]; log10 [0x4c322657ec89bp-16, 0x4d68ba5f26bf1p-11] = [0x149f1d70168f49p-49, 0x17a543a94fb65ep-49]; } testcase mpfi_mag { // special values mag [-infinity, -8.0] = +infinity; mag [-infinity, 0.0] = +infinity; mag [-infinity, 5.0] = +infinity; mag [entire] = +infinity; mag [-infinity, 0.0] = +infinity; mag [-8.0, 0.0] = +8; mag [0.0, 0.0] = +0; mag [0.0, 5.0] = +5; mag [0.0, +infinity] = +infinity; // regular values mag [-34.0, -17.0] = 34; } testcase mpfi_mid { // special values mid [-8.0, 0.0] = -4; mid [0.0, 0.0] = +0; mid [0.0, 5.0] = +2.5; // regular values mid [-34.0, -17.0] = -0x33p-1; mid [-34.0, 17.0] = -8.5; mid [0.0, +0x123456789abcdp-2] = +0x123456789abcdp-3; mid [0x1921fb54442d18p-51, 0x1921fb54442d19p-51] = 0x1921fb54442d18p-51; mid [-0x1921fb54442d19p-51, -0x1921fb54442d18p-51] = -0x1921fb54442d18p-51; mid [-4.0, -0x7fffffffffffdp-51] = -0x27fffffffffffbp-52; mid [-8.0, -0x7fffffffffffbp-51] = -0x47fffffffffffbp-52; mid [-0x1fffffffffffffp-53, 2.0] = 0.5; } testcase mpfi_mig { // special values mig [-infinity, -8.0] = 8; mig [-infinity, 0.0] = +0; mig [-infinity, 5.0] = +0; mig [entire] = +0; mig [-infinity, 0.0] = +0; mig [-8.0, 0.0] = +0; mig [0.0, 0.0] = +0; mig [0.0, 5.0] = +0; mig [0.0, +infinity] = +0; // regular values mig [-34.0, -17.0] = 17; } testcase mpfi_mul { // special values mul [-infinity, -7.0] [-1.0, +8.0] = [entire]; mul [-infinity, 0.0] [+8.0, +infinity] = [-infinity, 0.0]; mul [-infinity, +8.0] [0.0, +8.0] = [-infinity, +64.0]; mul [entire] [0.0, 0.0] = [0.0, 0.0]; mul [entire] [0.0, +8.0] = [entire]; mul [0.0, 0.0] [-infinity, -7.0] = [0.0, 0.0]; mul [0.0, +8.0] [-7.0, 0.0] = [-56.0, 0.0]; mul [0.0, 0.0] [0.0, +8.0] = [0.0, 0.0]; mul [0.0, +infinity] [0.0, +8.0] = [0.0, +infinity]; mul [0.0, 0.0] [+8.0, +infinity] = [0.0, 0.0]; mul [0.0, 0.0] [entire] = [0.0, 0.0]; mul [0.0, +8.0] [-7.0, +8.0] = [-56.0, +64.0]; mul [0.0, 0.0] [0.0, 0.0] = [0.0, 0.0]; mul [0.0, +infinity] [0.0, +8.0] = [0.0, +infinity]; mul [-3.0, +7.0] [0.0, 0.0] = [0.0, 0.0]; // regular values mul [-0x0dp0, -0x09p0] [-0x04p0, -0x02p0] = [0x12p0, 0x34p0]; mul [-0x0dp0, -0xd.f0e7927d247cp-4] [-0x04p0, -0xa.41084aff48f8p-8] = [0x8.ef3aa21dba748p-8, 0x34p0]; mul [-0xe.26c9e9eb67b48p-4, -0x8.237d2eb8b1178p-4] [-0x5.8c899a0706d5p-4, -0x3.344e57a37b5e8p-4] = [0x1.a142a930de328p-4, 0x4.e86c3434cd924p-4]; mul [-0x37p0, -0x07p0] [-0x01p0, 0x22p0] = [-0x74ep0, 0x37p0]; mul [-0xe.063f267ed51ap-4, -0x0.33p0] [-0x01p0, 0x1.777ab178b4a1ep+0] = [-0x1.491df346a9f15p+0, 0xe.063f267ed51ap-4]; mul [-0x1.cb540b71699a8p+4, -0x0.33p0] [-0x1.64dcaaa101f18p+0, 0x01p0] = [-0x1.cb540b71699a8p+4, 0x2.804cce4a3f42ep+4]; mul [-0x1.cb540b71699a8p+4, -0x0.33p0] [-0x1.64dcaaa101f18p+0, 0x1.eb67a1a6ef725p+4] = [-0x3.71b422ce817f4p+8, 0x2.804cce4a3f42ep+4]; mul [-0x123456789ap0, -0x01p0] [0x01p0, 0x10p0] = [-0x123456789a0p0, -0x01p0]; mul [-0xb.6c67d3a37d54p-4, -0x0.8p0] [0x02p0, 0x2.0bee4e8bb3dfp+0] = [-0x1.7611a672948a5p+0, -0x01p0]; mul [-0x04p0, -0xa.497d533c3b2ep-8] [0xb.d248df3373e68p-4, 0x04p0] = [-0x10p0, -0x7.99b990532d434p-8]; mul [-0xb.6c67d3a37d54p-4, -0xa.497d533c3b2ep-8] [0xb.d248df3373e68p-4, 0x2.0bee4e8bb3dfp+0] = [-0x1.7611a672948a5p+0, -0x7.99b990532d434p-8]; mul [-0x01p0, 0x11p0] [-0x07p0, -0x04p0] = [-0x77p0, 0x07p0]; mul [-0x01p0, 0xe.ca7ddfdb8572p-4] [-0x2.3b46226145234p+0, -0x0.1p0] = [-0x2.101b41d3d48b8p+0, 0x2.3b46226145234p+0]; mul [-0x1.1d069e75e8741p+8, 0x01p0] [-0x2.3b46226145234p+0, -0x0.1p0] = [-0x2.3b46226145234p+0, 0x2.7c0bd9877f404p+8]; mul [-0xe.ca7ddfdb8572p-4, 0x1.1d069e75e8741p+8] [-0x2.3b46226145234p+0, -0x0.1p0] = [-0x2.7c0bd9877f404p+8, 0x2.101b41d3d48b8p+0]; mul [-0x01p0, 0x10p0] [-0x02p0, 0x03p0] = [-0x20p0, 0x30p0]; mul [-0x01p0, 0x2.db091cea593fap-4] [-0x2.6bff2625fb71cp-4, 0x1p-8] = [-0x6.ea77a3ee43de8p-8, 0x2.6bff2625fb71cp-4]; mul [-0x01p0, 0x6.e211fefc216ap-4] [-0x1p-4, 0x1.8e3fe93a4ea52p+0] = [-0x1.8e3fe93a4ea52p+0, 0xa.b52fe22d72788p-4]; mul [-0x1.15e079e49a0ddp+0, 0x1p-8] [-0x2.77fc84629a602p+0, 0x8.3885932f13fp-4] = [-0x8.ec5de73125be8p-4, 0x2.adfe651d3b19ap+0]; mul [-0x07p0, 0x07p0] [0x13p0, 0x24p0] = [-0xfcp0, 0xfcp0]; mul [-0xa.8071f870126cp-4, 0x10p0] [0x02p0, 0x2.3381083e7d3b4p+0] = [-0x1.71dc5b5607781p+0, 0x2.3381083e7d3b4p+4]; mul [-0x01p0, 0x1.90aa487ecf153p+0] [0x01p-53, 0x1.442e2695ac81ap+0] = [-0x1.442e2695ac81ap+0, 0x1.fb5fbebd0cbc6p+0]; mul [-0x1.c40db77f2f6fcp+0, 0x1.8eb70bbd94478p+0] [0x02p0, 0x3.45118635235c6p+0] = [-0x5.c61fcad908df4p+0, 0x5.17b7c49130824p+0]; mul [0xcp0, 0x2dp0] [-0x679p0, -0xe5p0] = [-0x12345p0, -0xabcp0]; mul [0xcp0, 0x1.1833fdcab4c4ap+10] [-0x2.4c0afc50522ccp+40, -0xe5p0] = [-0x2.83a3712099234p+50, -0xabcp0]; mul [0xb.38f1fb0ef4308p+0, 0x2dp0] [-0x679p0, -0xa.4771d7d0c604p+0] = [-0x12345p0, -0x7.35b3c8400ade4p+4]; mul [0xf.08367984ca1cp-4, 0xa.bcf6c6cbe341p+0] [-0x5.cbc445e9952c4p+0, -0x2.8ad05a7b988fep-8] = [-0x3.e3ce52d4a139cp+4, -0x2.637164cf2f346p-8]; mul [0x01p0, 0xcp0] [-0xe5p0, 0x01p0] = [-0xabcp0, 0xcp0]; mul [0x123p-52, 0x1.ec24910ac6aecp+0] [-0xa.a97267f56a9b8p-4, 0x1p+32] = [-0x1.47f2dbe4ef916p+0, 0x1.ec24910ac6aecp+32]; mul [0x03p0, 0x7.2bea531ef4098p+0] [-0x01p0, 0xa.a97267f56a9b8p-4] = [-0x7.2bea531ef4098p+0, 0x4.c765967f9468p+0]; mul [0x0.3p0, 0xa.a97267f56a9b8p-4] [-0x1.ec24910ac6aecp+0, 0x7.2bea531ef4098p+0] = [-0x1.47f2dbe4ef916p+0, 0x4.c765967f9468p+0]; mul [0x3p0, 0x7p0] [0x5p0, 0xbp0] = [0xfp0, 0x4dp0]; mul [0x2.48380232f6c16p+0, 0x7p0] [0x3.71cb6c53e68eep+0, 0xbp0] = [0x7.dc58fb323ad78p+0, 0x4dp0]; mul [0x3p0, 0x3.71cb6c53e68eep+0] [0x5p-25, 0x2.48380232f6c16p+0] = [0xfp-25, 0x7.dc58fb323ad7cp+0]; mul [0x3.10e8a605572p-4, 0x2.48380232f6c16p+0] [0xc.3d8e305214ecp-4, 0x2.9e7db05203c88p+0] = [0x2.587a32d02bc04p-4, 0x5.fa216b7c20c6cp+0]; } testcase mpfi_mul_d { // special values mul [-infinity, -7.0] [-0x17p0, -0x17p0] = [+0xa1p0, +infinity]; mul [-infinity, -7.0] [0.0, 0.0] = [0.0, 0.0]; mul [-infinity, -7.0] [0x170ef54646d497p-107, 0x170ef54646d497p-107] = [-infinity, -0xa168b4ebefd020p-107]; mul [-infinity, 0.0] [-0x170ef54646d497p-106, -0x170ef54646d497p-106] = [0.0, +infinity]; mul [-infinity, 0.0] [0.0, 0.0] = [0.0, 0.0]; mul [-infinity, 0.0] [0x170ef54646d497p-106, 0x170ef54646d497p-106] = [-infinity, 0.0]; mul [-infinity, 8.0] [-0x16345785d8a00000p0, -0x16345785d8a00000p0] = [-0xb1a2bc2ec5000000p0, +infinity]; mul [-infinity, 8.0] [0.0, 0.0] = [0.0, 0.0]; mul [-infinity, 8.0] [0x16345785d8a00000p0, 0x16345785d8a00000p0] = [-infinity, 0xb1a2bc2ec5000000p0]; mul [entire] [-0x170ef54646d497p-105, -0x170ef54646d497p-105] = [entire]; mul [entire] [0.0e-17, 0.0e-17] = [0.0, 0.0]; mul [entire] [+0x170ef54646d497p-105, +0x170ef54646d497p-105] = [entire]; mul [0.0, 0.0] [-0x170ef54646d497p-109, -0x170ef54646d497p-109] = [0.0, 0.0]; mul [0.0, 0.0] [0.0, 0.0] = [0.0, 0.0]; mul [0.0, 0.0] [0x170ef54646d497p-109, 0x170ef54646d497p-109] = [0.0, 0.0]; mul [0.0, 7.0] [-0x114b37f4b51f71p-107, -0x114b37f4b51f71p-107] = [-0x790e87b0f3dc18p-107, 0.0]; mul [0.0, 8.0] [0.0, 0.0] = [0.0, 0.0]; mul [0.0, 9.0] [0x114b37f4b51f71p-103, 0x114b37f4b51f71p-103] = [0.0, 0x9ba4f79a5e1b00p-103]; mul [0.0, +infinity] [-0x50b45a75f7e81p-104, -0x50b45a75f7e81p-104] = [-infinity, 0.0]; mul [0.0, +infinity] [0.0, 0.0] = [0.0, 0.0]; mul [0.0, +infinity] [0x142d169d7dfa03p-106, 0x142d169d7dfa03p-106] = [0.0, +infinity]; // regular values mul [-0x1717170p0, -0xaaaaaaaaaaaaap-123] [-1.5, -1.5] = [0xfffffffffffffp-123, 0x22a2a28p0]; mul [-0xaaaaaaaaaaaaap0, 0x1717170p+401] [-1.5, -1.5] = [-0x22a2a28p+401, 0xfffffffffffffp0]; mul [0x10000000000010p0, 0x888888888888p+654] [-2.125, -2.125] = [-0x1222222222221p+654, -0x22000000000022p0]; mul [-0x1717170p0, -0xaaaaaaaaaaaaap-123] [1.5, 1.5] = [-0x22a2a28p0, -0xfffffffffffffp-123]; mul [-0xaaaaaaaaaaaaap0, 0x1717170p+401] [1.5, 1.5] = [-0xfffffffffffffp0, 0x22a2a28p+401]; mul [0x10000000000010p0, 0x888888888888p+654] [2.125, 2.125] = [0x22000000000022p0, 0x1222222222221p+654]; mul [-0x1717170p+36, -0x10000000000001p0] [-1.5, -1.5] = [0x18000000000001p0, 0x22a2a28p+36]; mul [-0xaaaaaaaaaaaaap0, 0x10000000000001p0] [-1.5, -1.5] = [-0x18000000000002p0, 0xfffffffffffffp0]; mul [0x10000000000010p0, 0x11111111111111p0] [-2.125, -2.125] = [-0x12222222222223p+1, -0x22000000000022p0]; mul [-0x10000000000001p0, -0xaaaaaaaaaaaaap-123] [1.5, 1.5] = [-0x18000000000002p0, -0xfffffffffffffp-123]; mul [-0xaaaaaaaaaaaabp0, 0x1717170p+401] [1.5, 1.5] = [-0x10000000000001p0, 0x22a2a28p+401]; mul [0x10000000000001p0, 0x888888888888p+654] [2.125, 2.125] = [0x22000000000002p0, 0x1222222222221p+654]; mul [-0x11717171717171p0, -0xaaaaaaaaaaaaap-123] [-1.5, -1.5] = [0xfffffffffffffp-123, 0x1a2a2a2a2a2a2ap0]; mul [-0x10000000000001p0, 0x1717170p+401] [-1.5, -1.5] = [-0x22a2a28p+401, 0x18000000000002p0]; mul [0x10000000000001p0, 0x888888888888p+654] [-2.125, -2.125] = [-0x1222222222221p+654, -0x22000000000002p0]; mul [-0x1717170p0, -0x1aaaaaaaaaaaaap-123] [1.5, 1.5] = [-0x22a2a28p0, -0x27fffffffffffep-123]; mul [-0xaaaaaaaaaaaaap0, 0x11717171717171p0] [1.5, 1.5] = [-0xfffffffffffffp0, 0x1a2a2a2a2a2a2ap0]; mul [0x10000000000010p0, 0x18888888888889p0] [2.125, 2.125] = [0x22000000000022p0, 0x34222222222224p0]; mul [-0x11717171717171p0, -0x10000000000001p0] [-1.5, -1.5] = [0x18000000000001p0, 0x1a2a2a2a2a2a2ap0]; mul [-0x10000000000001p0, 0x10000000000001p0] [-1.5, -1.5] = [-0x18000000000002p0, 0x18000000000002p0]; mul [0x10000000000001p0, 0x11111111111111p0] [-2.125, -2.125] = [-0x12222222222223p+1, -0x22000000000002p0]; mul [-0x10000000000001p0, -0x1aaaaaaaaaaaaap-123] [1.5, 1.5] = [-0x18000000000002p0, -0x27fffffffffffep-123]; mul [-0xaaaaaaaaaaaabp0, 0x11717171717171p0] [1.5, 1.5] = [-0x10000000000001p0, 0x1a2a2a2a2a2a2ap0]; mul [0x10000000000001p0, 0x18888888888889p0] [2.125, 2.125] = [0x22000000000002p0, 0x34222222222224p0]; } testcase mpfi_neg { // special values neg [-infinity, -7.0] = [+7.0, +infinity]; neg [-infinity, 0.0] = [0.0, +infinity]; neg [-infinity, +8.0] = [-8.0, +infinity]; neg [entire] = [entire]; neg [0.0, 0.0] = [0.0, 0.0]; neg [0.0, +8.0] = [-8.0, 0.0]; neg [0.0, +infinity] = [-infinity, 0.0]; // regular values neg [0x123456789p-16, 0x123456799p-16] = [-0x123456799p-16, -0x123456789p-16]; } testcase mpfi_put_d { // special values convexHull [0.0, 0.0] [-8.0, -8.0] = [-8.0, 0.0]; convexHull [0.0, 0.0] [0.0, 0.0] = [0.0, 0.0]; convexHull [+5.0, +5.0] [0.0, 0.0] = [0.0, +5.0]; } testcase mpfi_sec { // special values sec [-infinity, -7.0] = [entire]; sec [-infinity, 0.0] = [entire]; sec [-infinity, 8.0] = [entire]; sec [entire] = [entire]; sec [-8.0, 0.0] = [entire]; sec [-3.0, 0.0] = [entire]; sec [-1.0, 0.0] = [1.0, 0x1d9cf0f125cc2ap-52]; sec [0.0, 0.0] = [1.0, 1.0]; sec [0.0, +1.0] = [1.0, 0x1d9cf0f125cc2ap-52]; sec [0.0, 3.0] = [entire]; sec [0.0, 8.0] = [entire]; sec [0.0, +infinity] = [entire]; // regular values sec [-6.0, 7.0] = [entire]; sec [-6.0, 6.0] = [entire]; sec [-6.0, 5.0] = [entire]; sec [-6.0, 4.0] = [entire]; sec [-6.0, 3.0] = [entire]; sec [-6.0, 2.0] = [entire]; sec [-6.0, 1.0] = [entire]; sec [-6.0, 0.0] = [entire]; sec [-6.0, -1.0] = [entire]; sec [-6.0, -2.0] = [entire]; sec [-6.0, -3.0] = [entire]; sec [-6.0, -4.0] = [entire]; sec [-6.0, -5.0] = [0x10a9e8f3e19df1p-52, 0x1c33db0464189bp-51]; sec [-6.0, -6.0] = [0x10a9e8f3e19df1p-52, 0x10a9e8f3e19df2p-52]; sec [-5.0, 7.0] = [entire]; sec [-5.0, 6.0] = [entire]; sec [-5.0, 5.0] = [entire]; sec [-5.0, 4.0] = [entire]; sec [-5.0, 3.0] = [entire]; sec [-5.0, 2.0] = [entire]; sec [-5.0, 1.0] = [entire]; sec [-5.0, 0.0] = [entire]; sec [-5.0, -1.0] = [entire]; sec [-5.0, -2.0] = [entire]; sec [-5.0, -3.0] = [entire]; sec [-5.0, -4.0] = [entire]; sec [-5.0, -5.0] = [0x1c33db0464189ap-51, 0x1c33db0464189bp-51]; sec [-4.0, 7.0] = [entire]; sec [-4.0, 6.0] = [entire]; sec [-4.0, 5.0] = [entire]; sec [-4.0, 4.0] = [entire]; sec [-4.0, 3.0] = [entire]; sec [-4.0, 2.0] = [entire]; sec [-4.0, 1.0] = [entire]; sec [-4.0, 0.0] = [entire]; sec [-4.0, -1.0] = [entire]; sec [-4.0, -2.0] = [-0x133956fecf9e49p-51, -1.0]; sec [-4.0, -3.0] = [-0x187a6961d2485fp-52, -1.0]; sec [-4.0, -4.0] = [-0x187a6961d2485fp-52, -0x187a6961d2485ep-52]; sec [-3.0, 7.0] = [entire]; sec [-3.0, 6.0] = [entire]; sec [-3.0, 5.0] = [entire]; sec [-3.0, 4.0] = [entire]; sec [-3.0, 3.0] = [entire]; sec [-3.0, 2.0] = [entire]; sec [-3.0, 1.0] = [entire]; sec [-3.0, 0.0] = [entire]; sec [-3.0, -1.0] = [entire]; sec [-3.0, -2.0] = [-0x133956fecf9e49p-51, -0x102967b457b245p-52]; sec [-3.0, -3.0] = [-0x102967b457b246p-52, -0x102967b457b245p-52]; sec [-2.0, 7.0] = [entire]; sec [-2.0, 6.0] = [entire]; sec [-2.0, 5.0] = [entire]; sec [-2.0, 4.0] = [entire]; sec [-2.0, 3.0] = [entire]; sec [-2.0, 2.0] = [entire]; sec [-2.0, 1.0] = [entire]; sec [-2.0, 0.0] = [entire]; sec [-2.0, -1.0] = [entire]; sec [-2.0, -2.0] = [-0x133956fecf9e49p-51, -0x133956fecf9e48p-51]; sec [-1.0, 7.0] = [entire]; sec [-1.0, 6.0] = [entire]; sec [-1.0, 5.0] = [entire]; sec [-1.0, 4.0] = [entire]; sec [-1.0, 3.0] = [entire]; sec [-1.0, 2.0] = [entire]; sec [-1.0, 1.0] = [1.0, 0x1d9cf0f125cc2ap-52]; sec [-1.0, 0.0] = [1.0, 0x1d9cf0f125cc2ap-52]; sec [-1.0, -1.0] = [0x1d9cf0f125cc29p-52, 0x1d9cf0f125cc2ap-52]; sec [1.0, 7.0] = [entire]; sec [1.0, 6.0] = [entire]; sec [1.0, 5.0] = [entire]; sec [1.0, 4.0] = [entire]; sec [1.0, 3.0] = [entire]; sec [1.0, 2.0] = [entire]; sec [1.0, 1.0] = [0x1d9cf0f125cc29p-52, 0x1d9cf0f125cc2ap-52]; sec [2.0, 7.0] = [entire]; sec [2.0, 6.0] = [entire]; sec [2.0, 5.0] = [entire]; sec [2.0, 4.0] = [-0x133956fecf9e49p-51, -1.0]; sec [2.0, 3.0] = [-0x133956fecf9e49p-51, -0x102967b457b245p-52]; sec [2.0, 2.0] = [-0x133956fecf9e49p-51, -0x133956fecf9e48p-51]; sec [3.0, 7.0] = [entire]; sec [3.0, 6.0] = [entire]; sec [3.0, 5.0] = [entire]; sec [3.0, 4.0] = [-0x187a6961d2485fp-52, -1.0]; sec [3.0, 3.0] = [-0x102967b457b246p-52, -0x102967b457b245p-52]; sec [4.0, 7.0] = [entire]; sec [4.0, 6.0] = [entire]; sec [4.0, 5.0] = [entire]; sec [4.0, 4.0] = [-0x187a6961d2485fp-52, -0x187a6961d2485ep-52]; sec [5.0, 7.0] = [1.0, 0x1c33db0464189bp-51]; sec [5.0, 6.0] = [0x10a9e8f3e19df1p-52, 0x1c33db0464189bp-51]; sec [5.0, 5.0] = [0x1c33db0464189ap-51, 0x1c33db0464189bp-51]; sec [6.0, 7.0] = [1.0, 0x153910a80e7db5p-52]; sec [6.0, 6.0] = [0x10a9e8f3e19df1p-52, 0x10a9e8f3e19df2p-52]; sec [7.0, 7.0] = [0x153910a80e7db4p-52, 0x153910a80e7db5p-52]; } testcase mpfi_sech { // special values sech [-infinity, -7.0] = [0.0, 0x1de169fb49b339p-62]; sech [-infinity, 0.0] = [0.0, 1.0]; sech [-infinity, +8.0] = [0.0, 1.0]; sech [entire] = [0.0, 1.0]; sech [-1.0, 0.0] = [0x14bcdc50ed6be7p-53, 1.0]; sech [0.0, 0.0] = [1.0, 1.0]; sech [0.0, +1.0] = [0x14bcdc50ed6be7p-53, 1.0]; sech [0.0, +8.0] = [0x15fc20da8e18dbp-63, 1.0]; sech [0.0, +infinity] = [0.0, 1.0]; // regular values sech [-0.125, 0.0] = [0x1fc069fe3f72bep-53, 1.0]; sech [0.0, 0x10000000000001p-53] = [0x1c60d1ff040dcfp-53, 1.0]; sech [-4.5, -0.625] = [0x16bf984a9a2355p-58, 0x1aa0b464a5e24ap-53]; sech [1.0, 3.0] = [0x196d8e17d88eb1p-56, 0x14bcdc50ed6be8p-53]; sech [17.0, 0xb145bb71d3dbp-38] = [0x10000000000173p-1074, 0x1639e3175a6893p-76]; } testcase mpfi_sin { // special values sin [-infinity, -7.0] = [-1.0, 1.0]; sin [-infinity, 0.0] = [-1.0, 1.0]; sin [-infinity, +8.0] = [-1.0, 1.0]; sin [entire] = [-1.0, 1.0]; sin [-1.0, 0.0] = [-0x1aed548f090cefp-53, 0.0]; sin [0.0, 0.0] = [0.0, 0.0]; sin [0.0, +1.0] = [0.0, 0x1aed548f090cefp-53]; sin [0.0, +8.0] = [-1.0, 1.0]; sin [0.0, +infinity] = [-1.0, 1.0]; // regular values sin [0.125, 17.0] = [-1.0, 1.0]; sin [0x1921fb54442d18p-52, 0x1921fb54442d19p-52] = [0x1fffffffffffffp-53, 1.0]; sin [-2.0, -0.5] = [-1.0, -0x1eaee8744b05efp-54]; sin [-4.5, 0.625] = [-1.0, 0x1f47ed3dc74081p-53]; sin [-1.0, -0.25] = [-0x1aed548f090cefp-53, -0x1faaeed4f31576p-55]; sin [-0.5, 0.5] = [-0x1eaee8744b05f0p-54, 0x1eaee8744b05f0p-54]; sin [0x71p+76, 0x71p+76] = [0x1bde6c11cbfc46p-55, 0x1bde6c11cbfc47p-55]; sin [-7.0, 7.0] = [-1.0, 1.0]; sin [-7.0, 6.0] = [-1.0, 1.0]; sin [-7.0, 5.0] = [-1.0, 1.0]; sin [-7.0, 4.0] = [-1.0, 1.0]; sin [-7.0, 3.0] = [-1.0, 1.0]; sin [-7.0, 2.0] = [-1.0, 1.0]; sin [-7.0, 1.0] = [-1.0, 1.0]; sin [-7.0, 0.0] = [-1.0, 1.0]; sin [-7.0, -1.0] = [-1.0, 1.0]; sin [-7.0, -2.0] = [-0x1d18f6ead1b446p-53, 1.0]; sin [-7.0, -3.0] = [-0x150608c26d0a09p-53, 1.0]; sin [-7.0, -4.0] = [-0x150608c26d0a09p-53, 1.0]; sin [-7.0, -5.0] = [-0x150608c26d0a09p-53, 0x1eaf81f5e09934p-53]; sin [-7.0, -6.0] = [-0x150608c26d0a09p-53, 0x11e1f18ab0a2c1p-54]; sin [-7.0, -7.0] = [-0x150608c26d0a09p-53, -0x150608c26d0a08p-53]; sin [-6.0, 7.0] = [-1.0, 1.0]; sin [-6.0, 6.0] = [-1.0, 1.0]; sin [-6.0, 5.0] = [-1.0, 1.0]; sin [-6.0, 4.0] = [-1.0, 1.0]; sin [-6.0, 3.0] = [-1.0, 1.0]; sin [-6.0, 2.0] = [-1.0, 1.0]; sin [-6.0, 1.0] = [-1.0, 1.0]; sin [-6.0, 0.0] = [-1.0, 1.0]; sin [-6.0, -1.0] = [-1.0, 1.0]; sin [-6.0, -2.0] = [-0x1d18f6ead1b446p-53, 1.0]; sin [-6.0, -3.0] = [-0x1210386db6d55cp-55, 1.0]; sin [-6.0, -4.0] = [0x11e1f18ab0a2c0p-54, 1.0]; sin [-6.0, -5.0] = [0x11e1f18ab0a2c0p-54, 0x1eaf81f5e09934p-53]; sin [-6.0, -6.0] = [0x11e1f18ab0a2c0p-54, 0x11e1f18ab0a2c1p-54]; sin [-5.0, 7.0] = [-1.0, 1.0]; sin [-5.0, 6.0] = [-1.0, 1.0]; sin [-5.0, 5.0] = [-1.0, 1.0]; sin [-5.0, 4.0] = [-1.0, 1.0]; sin [-5.0, 3.0] = [-1.0, 1.0]; sin [-5.0, 2.0] = [-1.0, 1.0]; sin [-5.0, 1.0] = [-1.0, 1.0]; sin [-5.0, 0.0] = [-1.0, 1.0]; sin [-5.0, -1.0] = [-1.0, 1.0]; sin [-5.0, -2.0] = [-0x1d18f6ead1b446p-53, 1.0]; sin [-5.0, -3.0] = [-0x1210386db6d55cp-55, 1.0]; sin [-5.0, -4.0] = [0x1837b9dddc1eaep-53, 1.0]; sin [-5.0, -5.0] = [0x1eaf81f5e09933p-53, 0x1eaf81f5e09934p-53]; sin [-4.0, 7.0] = [-1.0, 1.0]; sin [-4.0, 6.0] = [-1.0, 1.0]; sin [-4.0, 5.0] = [-1.0, 1.0]; sin [-4.0, 4.0] = [-1.0, 1.0]; sin [-4.0, 3.0] = [-1.0, 1.0]; sin [-4.0, 2.0] = [-1.0, 1.0]; sin [-4.0, 1.0] = [-1.0, 0x1aed548f090cefp-53]; sin [-4.0, 0.0] = [-1.0, 0x1837b9dddc1eafp-53]; sin [-4.0, -1.0] = [-1.0, 0x1837b9dddc1eafp-53]; sin [-4.0, -2.0] = [-0x1d18f6ead1b446p-53, 0x1837b9dddc1eafp-53]; sin [-4.0, -3.0] = [-0x1210386db6d55cp-55, 0x1837b9dddc1eafp-53]; sin [-4.0, -4.0] = [0x1837b9dddc1eaep-53, 0x1837b9dddc1eafp-53]; sin [-3.0, 7.0] = [-1.0, 1.0]; sin [-3.0, 6.0] = [-1.0, 1.0]; sin [-3.0, 5.0] = [-1.0, 1.0]; sin [-3.0, 4.0] = [-1.0, 1.0]; sin [-3.0, 3.0] = [-1.0, 1.0]; sin [-3.0, 2.0] = [-1.0, 1.0]; sin [-3.0, 1.0] = [-1.0, 0x1aed548f090cefp-53]; sin [-3.0, 0.0] = [-1.0, 0.0]; sin [-3.0, -1.0] = [-1.0, -0x1210386db6d55bp-55]; sin [-3.0, -2.0] = [-0x1d18f6ead1b446p-53, -0x1210386db6d55bp-55]; sin [-3.0, -3.0] = [-0x1210386db6d55cp-55, -0x1210386db6d55bp-55]; sin [-2.0, 7.0] = [-1.0, 1.0]; sin [-2.0, 6.0] = [-1.0, 1.0]; sin [-2.0, 5.0] = [-1.0, 1.0]; sin [-2.0, 4.0] = [-1.0, 1.0]; sin [-2.0, 3.0] = [-1.0, 1.0]; sin [-2.0, 2.0] = [-1.0, 1.0]; sin [-2.0, 1.0] = [-1.0, 0x1aed548f090cefp-53]; sin [-2.0, 0.0] = [-1.0, 0.0]; sin [-2.0, -1.0] = [-1.0, -0x1aed548f090ceep-53]; sin [-2.0, -2.0] = [-0x1d18f6ead1b446p-53, -0x1d18f6ead1b445p-53]; sin [-1.0, 7.0] = [-1.0, 1.0]; sin [-1.0, 6.0] = [-1.0, 1.0]; sin [-1.0, 5.0] = [-1.0, 1.0]; sin [-1.0, 4.0] = [-0x1aed548f090cefp-53, 1.0]; sin [-1.0, 3.0] = [-0x1aed548f090cefp-53, 1.0]; sin [-1.0, 2.0] = [-0x1aed548f090cefp-53, 1.0]; sin [-1.0, 1.0] = [-0x1aed548f090cefp-53, 0x1aed548f090cefp-53]; sin [-1.0, 0.0] = [-0x1aed548f090cefp-53, 0.0]; sin [-1.0, -1.0] = [-0x1aed548f090cefp-53, -0x1aed548f090ceep-53]; sin [1.0, 7.0] = [-1.0, 1.0]; sin [1.0, 6.0] = [-1.0, 1.0]; sin [1.0, 5.0] = [-1.0, 1.0]; sin [1.0, 4.0] = [-0x1837b9dddc1eafp-53, 1.0]; sin [1.0, 3.0] = [0x1210386db6d55bp-55, 1.0]; sin [1.0, 2.0] = [0x1aed548f090ceep-53, 1.0]; sin [1.0, 1.0] = [0x1aed548f090ceep-53, 0x1aed548f090cefp-53]; sin [2.0, 7.0] = [-1.0, 0x1d18f6ead1b446p-53]; sin [2.0, 6.0] = [-1.0, 0x1d18f6ead1b446p-53]; sin [2.0, 5.0] = [-1.0, 0x1d18f6ead1b446p-53]; sin [2.0, 4.0] = [-0x1837b9dddc1eafp-53, 0x1d18f6ead1b446p-53]; sin [2.0, 3.0] = [0x1210386db6d55bp-55, 0x1d18f6ead1b446p-53]; sin [2.0, 2.0] = [0x1d18f6ead1b445p-53, 0x1d18f6ead1b446p-53]; sin [3.0, 7.0] = [-1.0, 0x150608c26d0a09p-53]; sin [3.0, 6.0] = [-1.0, 0x1210386db6d55cp-55]; sin [3.0, 5.0] = [-1.0, 0x1210386db6d55cp-55]; sin [3.0, 4.0] = [-0x1837b9dddc1eafp-53, 0x1210386db6d55cp-55]; sin [3.0, 3.0] = [0x1210386db6d55bp-55, 0x1210386db6d55cp-55]; sin [4.0, 7.0] = [-1.0, 0x150608c26d0a09p-53]; sin [4.0, 6.0] = [-1.0, -0x11e1f18ab0a2c0p-54]; sin [4.0, 5.0] = [-1.0, -0x1837b9dddc1eaep-53]; sin [4.0, 4.0] = [-0x1837b9dddc1eafp-53, -0x1837b9dddc1eaep-53]; sin [5.0, 7.0] = [-0x1eaf81f5e09934p-53, 0x150608c26d0a09p-53]; sin [5.0, 6.0] = [-0x1eaf81f5e09934p-53, -0x11e1f18ab0a2c0p-54]; sin [5.0, 5.0] = [-0x1eaf81f5e09934p-53, -0x1eaf81f5e09933p-53]; sin [6.0, 7.0] = [-0x11e1f18ab0a2c1p-54, 0x150608c26d0a09p-53]; sin [6.0, 6.0] = [-0x11e1f18ab0a2c1p-54, -0x11e1f18ab0a2c0p-54]; sin [7.0, 7.0] = [0x150608c26d0a08p-53, 0x150608c26d0a09p-53]; } testcase mpfi_sinh { // special values sinh [-infinity, -7.0] = [-infinity, -0x1122876ba380c9p-43]; sinh [-infinity, 0.0] = [-infinity, 0.0]; sinh [-infinity, +8.0] = [-infinity, 0x1749ea514eca66p-42]; sinh [entire] = [entire]; sinh [-1.0, 0.0] = [-0x12cd9fc44eb983p-52, 0.0]; sinh [0.0, 0.0] = [0.0, 0.0]; sinh [0.0, +1.0] = [0.0, 0x12cd9fc44eb983p-52]; sinh [0.0, +8.0] = [0.0, 0x1749ea514eca66p-42]; sinh [0.0, +infinity] = [0.0, +infinity]; // regular values sinh [-0.125, 0.0] = [-0x100aaccd00d2f1p-55, 0.0]; sinh [0.0, 0x10000000000001p-53] = [0.0, 0x10acd00fe63b98p-53]; sinh [-4.5, -0.625] = [-0x168062ab5fa9fdp-47, -0x1553e795dc19ccp-53]; sinh [1.0, 3.0] = [0x12cd9fc44eb982p-52, 0x140926e70949aep-49]; } testcase mpfi_sqr { // special values sqr [-infinity, -7.0] = [+49.0, +infinity]; sqr [-infinity, 0.0] = [0.0, +infinity]; sqr [-infinity, +8.0] = [0.0, +infinity]; sqr [entire] = [0.0, +infinity]; sqr [0.0, 0.0] = [0.0, 0.0]; sqr [0.0, +8.0] = [0.0, +64.0]; sqr [0.0, +infinity] = [0.0, +infinity]; // regular values sqr [0x8.6374d8p-4, 0x3.f1d929p+8] = [0x4.65df11464764p-4, 0xf.8f918d688891p+16]; sqr [0x6.61485c33c0b14p+4, 0x123456p0] = [0x2.8b45c3cc03ea6p+12, 0x14b66cb0ce4p0]; sqr [-0x1.64722ad2480c9p+0, 0x1p0] = [0.0, 0x1.f04dba0302d4dp+0]; sqr [0x1.6b079248747a2p+0, 0x2.b041176d263f6p+0] = [0x2.02ce7912cddf6p+0, 0x7.3a5dee779527p+0]; } testcase mpfi_sqrt { // special values sqrt [0.0, 0.0] = [0.0, 0.0]; sqrt [0.0, +9.0] = [0.0, +3.0]; sqrt [0.0, +infinity] = [0.0, +infinity]; // regular values sqrt [0xaaa1p0, 0x14b66cb0ce4p0] = [0xd1p0, 0x123456p0]; sqrt [0xe.49ae7969e41bp-4, 0xaaa1p0] = [0xf.1ea42821b27a8p-4, 0xd1p0]; sqrt [0xa.aa1p-4, 0x1.0c348f804c7a9p+0] = [0xd.1p-4, 0x1.06081714eef1dp+0]; sqrt [0xe.49ae7969e41bp-4, 0x1.0c348f804c7a9p+0] = [0xf.1ea42821b27a8p-4, 0x1.06081714eef1dp+0]; } testcase mpfi_sub { // special values sub [-infinity, -7.0] [-1.0, +8.0] = [-infinity, -6.0]; sub [-infinity, 0.0] [+8.0, +infinity] = [-infinity, -8.0]; sub [-infinity, +8.0] [0.0, +8.0] = [-infinity, +8.0]; sub [entire] [0.0, +8.0] = [entire]; sub [0.0, 0.0] [-infinity, -7.0] = [+7.0, +infinity]; sub [0.0, +8.0] [-7.0, 0.0] = [0.0, +15.0]; sub [0.0, 0.0] [0.0, +8.0] = [-8.0, 0.0]; sub [0.0, +infinity] [0.0, +8.0] = [-8.0, +infinity]; sub [0.0, 0.0] [+8.0, +infinity] = [-infinity, -8.0]; sub [0.0, 0.0] [entire] = [entire]; sub [0.0, +8.0] [-7.0, +8.0] = [-8.0, +15.0]; sub [0.0, 0.0] [0.0, 0.0] = [0.0, 0.0]; sub [0.0, +infinity] [0.0, +8.0] = [-8.0, +infinity]; // regular values sub [-5.0, 59.0] [17.0, 81.0] = [-86.0, 42.0]; sub [-0x1p-300, 0x123456p+28] [-0x789abcdp0, 0x10000000000000p-93] = [-0x10000000000001p-93, 0x123456789abcdp0]; sub [-4.0, 7.0] [-3e300, 0x123456789abcdp-17] = [-0x123456791abcdp-17, 0x8f596b3002c1bp+947]; sub [-0x1000100010001p+8, 0x1p+60] [-3e300, 0x1000100010001p0] = [-0x10101010101011p+4, 0x8f596b3002c1bp+947]; sub [-5.0, 1.0] [1.0, 0x1p+70] = [-0x10000000000001p+18, 0.0]; sub [5.0, 0x1p+70] [3.0, 5.0] = [0.0, 0x1p+70]; } testcase mpfi_sub_d { // special values sub [-infinity, -7.0] [-0x170ef54646d497p-107, -0x170ef54646d497p-107] = [-infinity, -0x1bffffffffffffp-50]; sub [-infinity, -7.0] [0.0, 0.0] = [-infinity, -7.0]; sub [-infinity, -7.0] [0x170ef54646d497p-107, 0x170ef54646d497p-107] = [-infinity, -7.0]; sub [-infinity, 0.0] [-0x170ef54646d497p-106, -0x170ef54646d497p-106] = [-infinity, 0x170ef54646d497p-106]; sub [-infinity, 0.0] [0.0, 0.0] = [-infinity, 0.0]; sub [-infinity, 0.0] [0x170ef54646d497p-106, 0x170ef54646d497p-106] = [-infinity, -8.0e-17]; sub [-infinity, 8.0] [-0x16345785d8a00000p0, -0x16345785d8a00000p0] = [-infinity, 0x16345785d8a00100p0]; sub [-infinity, 8.0] [0.0, 0.0] = [-infinity, 8.0]; sub [-infinity, 8.0] [0x16345785d8a00000p0, 0x16345785d8a00000p0] = [-infinity, -0x16345785d89fff00p0]; sub [entire] [-0x170ef54646d497p-105, -0x170ef54646d497p-105] = [entire]; sub [entire] [0.0e-17, 0.0e-17] = [entire]; sub [entire] [+0x170ef54646d497p-105, +0x170ef54646d497p-105] = [entire]; sub [0.0, 0.0] [-0x170ef54646d497p-109, -0x170ef54646d497p-109] = [+0x170ef54646d497p-109, +0x170ef54646d497p-109]; sub [0.0, 0.0] [0.0, 0.0] = [0.0, 0.0]; sub [0.0, 0.0] [0x170ef54646d497p-109, 0x170ef54646d497p-109] = [-0x170ef54646d497p-109, -0x170ef54646d497p-109]; sub [0.0, 8.0] [-0x114b37f4b51f71p-107, -0x114b37f4b51f71p-107] = [0x114b37f4b51f71p-107, 0x10000000000001p-49]; sub [0.0, 8.0] [0.0, 0.0] = [0.0, 8.0]; sub [0.0, 8.0] [0x114b37f4b51f71p-107, 0x114b37f4b51f71p-107] = [-0x114b37f4b51f71p-107, 8.0]; sub [0.0, +infinity] [-0x50b45a75f7e81p-104, -0x50b45a75f7e81p-104] = [0x50b45a75f7e81p-104, +infinity]; sub [0.0, +infinity] [0.0, 0.0] = [0.0, +infinity]; sub [0.0, +infinity] [0x142d169d7dfa03p-106, 0x142d169d7dfa03p-106] = [-0x142d169d7dfa03p-106, +infinity]; // regular values sub [-32.0, -17.0] [0xfb53d14aa9c2fp-47, 0xfb53d14aa9c2fp-47] = [-0x1fb53d14aa9c2fp-47, -0x18353d14aa9c2fp-47]; sub [-0xfb53d14aa9c2fp-47, -17.0] [-0xfb53d14aa9c2fp-47, -0xfb53d14aa9c2fp-47] = [0.0, 0x7353d14aa9c2fp-47]; sub [-32.0, -0xfb53d14aa9c2fp-48] [-0xfb53d14aa9c2fp-48, -0xfb53d14aa9c2fp-48] = [-0x104ac2eb5563d1p-48, 0.0]; sub [0x123456789abcdfp-48, 0x123456789abcdfp-4] [-3.5, -3.5] = [0x15b456789abcdfp-48, 0x123456789abd17p-4]; sub [0x123456789abcdfp-56, 0x123456789abcdfp-4] [-3.5, -3.5] = [0x3923456789abcdp-52, 0x123456789abd17p-4]; sub [-0xffp0, 0x123456789abcdfp-52] [-256.5, -256.5] = [0x18p-4, 0x101a3456789abdp-44]; sub [-0x1fffffffffffffp-52, -0x1p-550] [-4097.5, -4097.5] = [0xfff8p-4, 0x10018p-4]; sub [0x123456789abcdfp-48, 0x123456789abcdfp-4] [3.5, 3.5] = [0xeb456789abcdfp-48, 0x123456789abca7p-4]; sub [0x123456789abcdfp-56, 0x123456789abcdfp-4] [3.5, 3.5] = [-0x36dcba98765434p-52, 0x123456789abca7p-4]; sub [-0xffp0, 0x123456789abcdfp-52] [256.5, 256.5] = [-0x1ff8p-4, -0xff5cba9876543p-44]; sub [-0x1fffffffffffffp-52, -0x1p-550] [4097.5, 4097.5] = [-0x10038p-4, -0x10018p-4]; } testcase mpfi_tan { // special values tan [-infinity, -7.0] = [entire]; tan [-infinity, 0.0] = [entire]; tan [-infinity, +8.0] = [entire]; tan [entire] = [entire]; tan [-1.0, 0.0] = [-0x18eb245cbee3a6p-52, 0.0]; tan [0.0, 0.0] = [0.0, 0.0]; tan [0.0, +1.0] = [0.0, 0x18eb245cbee3a6p-52]; tan [0.0, +8.0] = [entire]; tan [0.0, +infinity] = [entire]; // regular values tan [0.125, 17.0] = [entire]; tan [0x1921fb54442d18p-52, 0x1921fb54442d19p-52] = [entire]; tan [-2.0, -0.5] = [entire]; tan [-4.5, 0.625] = [entire]; tan [-1.0, -0.25] = [-0x18eb245cbee3a6p-52, -0x105785a43c4c55p-54]; tan [-0.5, 0.5] = [-0x117b4f5bf3474bp-53, 0x117b4f5bf3474bp-53]; tan [0x71p+76, 0x71p+76] = [-0x1c8dc87ddcc134p-55, -0x1c8dc87ddcc133p-55]; tan [-7.0, 7.0] = [entire]; tan [-7.0, 6.0] = [entire]; tan [-7.0, 5.0] = [entire]; tan [-7.0, 4.0] = [entire]; tan [-7.0, 3.0] = [entire]; tan [-7.0, 2.0] = [entire]; tan [-7.0, 1.0] = [entire]; tan [-7.0, 0.0] = [entire]; tan [-7.0, -1.0] = [entire]; tan [-7.0, -2.0] = [entire]; tan [-7.0, -3.0] = [entire]; tan [-7.0, -4.0] = [entire]; tan [-7.0, -5.0] = [-0x1be2e6e13eea79p-53, 0x1b0b4b739bbb07p-51]; tan [-7.0, -6.0] = [-0x1be2e6e13eea79p-53, 0x129fd86ebb95bfp-54]; tan [-7.0, -7.0] = [-0x1be2e6e13eea79p-53, -0x1be2e6e13eea78p-53]; tan [-6.0, 7.0] = [entire]; tan [-6.0, 6.0] = [entire]; tan [-6.0, 5.0] = [entire]; tan [-6.0, 4.0] = [entire]; tan [-6.0, 3.0] = [entire]; tan [-6.0, 2.0] = [entire]; tan [-6.0, 1.0] = [entire]; tan [-6.0, 0.0] = [entire]; tan [-6.0, -1.0] = [entire]; tan [-6.0, -2.0] = [entire]; tan [-6.0, -3.0] = [entire]; tan [-6.0, -4.0] = [entire]; tan [-6.0, -5.0] = [0x129fd86ebb95bep-54, 0x1b0b4b739bbb07p-51]; tan [-6.0, -6.0] = [0x129fd86ebb95bep-54, 0x129fd86ebb95bfp-54]; tan [-5.0, 7.0] = [entire]; tan [-5.0, 6.0] = [entire]; tan [-5.0, 5.0] = [entire]; tan [-5.0, 4.0] = [entire]; tan [-5.0, 3.0] = [entire]; tan [-5.0, 2.0] = [entire]; tan [-5.0, 1.0] = [entire]; tan [-5.0, 0.0] = [entire]; tan [-5.0, -1.0] = [entire]; tan [-5.0, -2.0] = [entire]; tan [-5.0, -3.0] = [entire]; tan [-5.0, -4.0] = [entire]; tan [-5.0, -5.0] = [0x1b0b4b739bbb06p-51, 0x1b0b4b739bbb07p-51]; tan [-4.0, 7.0] = [entire]; tan [-4.0, 6.0] = [entire]; tan [-4.0, 5.0] = [entire]; tan [-4.0, 4.0] = [entire]; tan [-4.0, 3.0] = [entire]; tan [-4.0, 2.0] = [entire]; tan [-4.0, 1.0] = [entire]; tan [-4.0, 0.0] = [entire]; tan [-4.0, -1.0] = [entire]; tan [-4.0, -2.0] = [-0x12866f9be4de14p-52, 0x117af62e0950f9p-51]; tan [-4.0, -3.0] = [-0x12866f9be4de14p-52, 0x123ef71254b870p-55]; tan [-4.0, -4.0] = [-0x12866f9be4de14p-52, -0x12866f9be4de13p-52]; tan [-3.0, 7.0] = [entire]; tan [-3.0, 6.0] = [entire]; tan [-3.0, 5.0] = [entire]; tan [-3.0, 4.0] = [entire]; tan [-3.0, 3.0] = [entire]; tan [-3.0, 2.0] = [entire]; tan [-3.0, 1.0] = [entire]; tan [-3.0, 0.0] = [entire]; tan [-3.0, -1.0] = [entire]; tan [-3.0, -2.0] = [0x123ef71254b86fp-55, 0x117af62e0950f9p-51]; tan [-3.0, -3.0] = [0x123ef71254b86fp-55, 0x123ef71254b870p-55]; tan [-2.0, 7.0] = [entire]; tan [-2.0, 6.0] = [entire]; tan [-2.0, 5.0] = [entire]; tan [-2.0, 4.0] = [entire]; tan [-2.0, 3.0] = [entire]; tan [-2.0, 2.0] = [entire]; tan [-2.0, 1.0] = [entire]; tan [-2.0, 0.0] = [entire]; tan [-2.0, -1.0] = [entire]; tan [-2.0, -2.0] = [0x117af62e0950f8p-51, 0x117af62e0950f9p-51]; tan [-1.0, 7.0] = [entire]; tan [-1.0, 6.0] = [entire]; tan [-1.0, 5.0] = [entire]; tan [-1.0, 4.0] = [entire]; tan [-1.0, 3.0] = [entire]; tan [-1.0, 2.0] = [entire]; tan [-1.0, 1.0] = [-0x18eb245cbee3a6p-52, 0x18eb245cbee3a6p-52]; tan [-1.0, 0.0] = [-0x18eb245cbee3a6p-52, 0.0]; tan [-1.0, -1.0] = [-0x18eb245cbee3a6p-52, -0x18eb245cbee3a5p-52]; tan [1.0, 7.0] = [entire]; tan [1.0, 6.0] = [entire]; tan [1.0, 5.0] = [entire]; tan [1.0, 4.0] = [entire]; tan [1.0, 3.0] = [entire]; tan [1.0, 2.0] = [entire]; tan [1.0, 1.0] = [0x18eb245cbee3a5p-52, 0x18eb245cbee3a6p-52]; tan [2.0, 7.0] = [entire]; tan [2.0, 6.0] = [entire]; tan [2.0, 5.0] = [entire]; tan [2.0, 4.0] = [-0x117af62e0950f9p-51, 0x12866f9be4de14p-52]; tan [2.0, 3.0] = [-0x117af62e0950f9p-51, -0x123ef71254b86fp-55]; tan [2.0, 2.0] = [-0x117af62e0950f9p-51, -0x117af62e0950f8p-51]; tan [3.0, 7.0] = [entire]; tan [3.0, 6.0] = [entire]; tan [3.0, 5.0] = [entire]; tan [3.0, 4.0] = [-0x123ef71254b870p-55, 0x12866f9be4de14p-52]; tan [3.0, 3.0] = [-0x123ef71254b870p-55, -0x123ef71254b86fp-55]; tan [4.0, 7.0] = [entire]; tan [4.0, 6.0] = [entire]; tan [4.0, 5.0] = [entire]; tan [4.0, 4.0] = [0x12866f9be4de13p-52, 0x12866f9be4de14p-52]; tan [5.0, 7.0] = [-0x1b0b4b739bbb07p-51, 0x1be2e6e13eea79p-53]; tan [5.0, 6.0] = [-0x1b0b4b739bbb07p-51, -0x129fd86ebb95bep-54]; tan [5.0, 5.0] = [-0x1b0b4b739bbb07p-51, -0x1b0b4b739bbb06p-51]; tan [6.0, 7.0] = [-0x129fd86ebb95bfp-54, 0x1be2e6e13eea79p-53]; tan [6.0, 6.0] = [-0x129fd86ebb95bfp-54, -0x129fd86ebb95bep-54]; tan [7.0, 7.0] = [0x1be2e6e13eea78p-53, 0x1be2e6e13eea79p-53]; } testcase mpfi_tanh { // special values tanh [-infinity, -7.0] = [-1.0, -0x1ffffc832750f1p-53]; tanh [-infinity, 0.0] = [-1.0, 0.0]; tanh [-infinity, 8.0] = [-1.0, 0x1fffff872a91f9p-53]; tanh [entire] = [-1.0, +1.0]; tanh [-1.0, 0.0] = [-0x185efab514f395p-53, 0.0]; tanh [0.0, 0.0] = [0.0, 0.0]; tanh [0.0, 1.0] = [0.0, 0x185efab514f395p-53]; tanh [0.0, 8.0] = [0.0, 0x1fffff872a91f9p-53]; tanh [0.0, +infinity] = [0.0, +1.0]; // regular values tanh [-0.125, 0.0] = [-0x1fd5992bc4b835p-56, 0.0]; tanh [0.0, 0x10000000000001p-53] = [0.0, 0x1d9353d7568af5p-54]; tanh [-4.5, -0.625] = [-0x1ffdfa72153984p-53, -0x11bf47eabb8f95p-53]; tanh [1.0, 3.0] = [0x185efab514f394p-53, 0x1fd77d111a0b00p-53]; tanh [17.0, 18.0] = [0x1fffffffffffe1p-53, 0x1ffffffffffffcp-53]; } testcase mpfi_union { // special values convexHull [-infinity, -7.0] [-1.0, +8.0] = [-infinity, +8.0]; convexHull [-infinity, 0.0] [+8.0, +infinity] = [entire]; convexHull [-infinity, +8.0] [0.0, +8.0] = [-infinity, +8.0]; convexHull [entire] [0.0, +8.0] = [entire]; convexHull [0.0, 0.0] [-infinity, -7.0] = [-infinity, 0.0]; convexHull [0.0, +8.0] [-7.0, 0.0] = [-7.0, +8.0]; convexHull [0.0, 0.0] [0.0, +8.0] = [0.0, +8.0]; convexHull [0.0, +infinity] [0.0, +8.0] = [0.0, +infinity]; convexHull [0.0, 0.0] [+8.0, +infinity] = [0.0, +infinity]; convexHull [0.0, 0.0] [entire] = [entire]; convexHull [0.0, +8.0] [-7.0, +8.0] = [-7.0, +8.0]; convexHull [0.0, 0.0] [0.0, 0.0] = [0.0, 0.0]; convexHull [0.0, +infinity] [0.0, +8.0] = [0.0, +infinity]; // regular values convexHull [0x12p0, 0x90p0] [-0x0dp0, 0x34p0] = [-0x0dp0, 0x90p0]; } interval-1.4.1/test/pow_rev.itl0000644000000000000000000016204112657475772014673 0ustar 00000000000000/* Copyright 2015-2016 Oliver Heimlich This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, see . */ /* The following tests use boundaries for the first parameter whose reciprocal can be computed without round-off error in a binary floating-point context. Thus, an implementation should be able to compute tight results with the formula x = z ^ (1 / y) for the intervals used here. The test values are structured according to table B.1 in Heimlich, Oliver. 2011. “The General Interval Power Function.” Diplomarbeit, Institute for Computer Science, University of Würzburg. http://exp.ln0.de/heimlich-power-2011.htm. */ testcase minimal.powRev1_test { // Empty intervals powRev1 [empty] [empty] [empty] = [empty]; powRev1 [empty] [entire] [empty] = [empty]; powRev1 [entire] [empty] [empty] = [empty]; powRev1 [entire] [entire] [empty] = [empty]; powRev1 [empty] [empty] [entire] = [empty]; powRev1 [empty] [entire] [entire] = [empty]; powRev1 [entire] [empty] [entire] = [empty]; // Entire range powRev1 [entire] [entire] [entire] = [0.0, infinity]; // Outside of the function's domain powRev1 [entire] [entire] [-infinity,-1.0] = [empty]; powRev1 [-infinity,-1.0] [entire] [-infinity,0.0] = [empty]; powRev1 [-infinity,0.0] [entire] [-infinity,0.0] = [empty]; powRev1 [-infinity,0.0] [-infinity,0.0] [entire] = [empty]; powRev1 [-infinity,0.0] [-infinity,0.9] [0.0,1.0] = [empty]; powRev1 [-infinity,0.0] [1.1,infinity] [1.0,infinity] = [empty]; powRev1 [0.0,infinity] [1.1,infinity] [0.0,1.0] = [empty]; powRev1 [0.0,infinity] [-infinity,0.9] [1.0,infinity] = [empty]; powRev1 [0.0,0.0] [1.0,1.0] [-infinity,0.0] = [empty]; // 0^y = 0 powRev1 [entire] [0.0,0.0] [entire] = [0.0,0.0]; powRev1 [entire] [-infinity,0.0] [entire] = [0.0,0.0]; powRev1 [0.0,infinity] [-infinity,0.0] [entire] = [0.0,0.0]; powRev1 [0.0,infinity] [0.0,0.0] [entire] = [0.0,0.0]; powRev1 [1.0,2.0] [0.0,0.0] [entire] = [0.0,0.0]; powRev1 [1.0,1.0] [0.0,0.0] [0.0,0.0] = [0.0,0.0]; // 1^y = x^0 = 1 powRev1 [entire] [1.0,1.0] [1.0,1.0] = [1.0,1.0]; powRev1 [0.0,0.0] [1.0,1.0] [entire] = [0.0,infinity]; powRev1 [0.0,0.0] [1.0,1.0] [2.0,3.0] = [2.0,3.0]; powRev1 [entire] [1.0,1.0] [entire] = [0.0,infinity]; powRev1 [entire] [1.0,1.0] [20.0,30.0] = [20.0,30.0]; powRev1 [0.0,0.0] [1.0,1.0] [1.0,1.0] = [1.0,1.0]; // y < 0, z overlaps/starts [0,1] powRev1 [-4.0,-2.0] [0.0,0.5] [entire] = [0x1.306FE0A31B715p0, infinity]; powRev1 [-infinity,-2.0] [0.0,0.5] [entire] = [1.0, infinity]; powRev1 [-4.0,-2.0] [-infinity,0.5] [entire] = [0x1.306FE0A31B715p0, infinity]; powRev1 [-infinity,-2.0] [-infinity,0.5] [entire] = [1.0, infinity]; // y < 0, z containedBy [0, 1] powRev1 [-4.0,-2.0] [0.25,0.5] [entire] = [0x1.306FE0A31B715p0, 2.0]; powRev1 [-infinity,-2.0] [0.25,0.5] [entire] = [1.0, 2.0]; // y < 0, z finishes [0, 1] powRev1 [-4.0,-2.0] [0.25,1.0] [entire] = [1.0, 2.0]; powRev1 [-infinity,-2.0] [0.25,1.0] [entire] = [1.0, 2.0]; powRev1 [-4.0,-2.0] [1.0,1.0] [entire] = [1.0, 1.0]; powRev1 [-infinity,-2.0] [1.0,1.0] [entire] = [1.0, 1.0]; // y < 0, z equals/finishedBy [0, 1] powRev1 [-4.0,-2.0] [0.0,1.0] [entire] = [1.0, infinity]; powRev1 [-infinity,-2.0] [0.0,1.0] [entire] = [1.0, infinity]; // y < 0, z contains/startedBy [0, 1] powRev1 [-4.0,-2.0] [0.0,2.0] [entire] = [0x1.6A09E667F3BCCp-1, infinity]; powRev1 [-infinity,-2.0] [0.0,2.0] [entire] = [0x1.6A09E667F3BCCp-1, infinity]; powRev1 [-4.0,-2.0] [0.0,infinity] [entire] = [0.0, infinity]; powRev1 [-infinity,-2.0] [0.0,infinity] [entire] = [0.0, infinity]; powRev1 [-4.0,-2.0] [-infinity,2.0] [entire] = [0x1.6A09E667F3BCCp-1, infinity]; powRev1 [-infinity,-2.0] [-infinity,2.0] [entire] = [0x1.6A09E667F3BCCp-1, infinity]; powRev1 [-4.0,-2.0] [-infinity,infinity] [entire] = [0.0, infinity]; powRev1 [-infinity,-2.0] [-infinity,infinity] [entire] = [0.0, infinity]; // y < 0, z overlappedBy [0, 1] powRev1 [-4.0,-2.0] [0.5,2.0] [entire] = [0x1.6A09E667F3BCCp-1, 0x1.6A09E667F3BCDp0]; powRev1 [-infinity,-2.0] [0.5,2.0] [entire] = [0x1.6A09E667F3BCCp-1, 0x1.6A09E667F3BCDp0]; powRev1 [-4.0,-2.0] [0.5,infinity] [entire] = [0.0, 0x1.6A09E667F3BCDp0]; powRev1 [-infinity,-2.0] [0.5,infinity] [entire] = [0.0, 0x1.6A09E667F3BCDp0]; // y < 0, z metBy [0, 1] powRev1 [-4.0,-2.0] [1.0,2.0] [entire] = [0x1.6A09E667F3BCCp-1, 1.0]; powRev1 [-infinity,-2.0] [1.0,2.0] [entire] = [0x1.6A09E667F3BCCp-1, 1.0]; powRev1 [-4.0,-2.0] [1.0,infinity] [entire] = [0.0, 1.0]; powRev1 [-infinity,-2.0] [1.0,infinity] [entire] = [0.0, 1.0]; // y < 0, z after [0, 1] powRev1 [-4.0,-2.0] [2.0,4.0] [entire] = [0.5, 0x1.AE89F995AD3AEp-1]; powRev1 [-infinity,-2.0] [2.0,4.0] [entire] = [0.5, 1.0]; powRev1 [-4.0,-2.0] [2.0,infinity] [entire] = [0.0, 0x1.AE89F995AD3AEp-1]; powRev1 [-infinity,-2.0] [2.0,infinity] [entire] = [0.0, 1.0]; // y = 0, z overlaps/starts [0,1] powRev1 [0.0,0.0] [0.0,0.5] [entire] = [empty]; powRev1 [0.0,0.0] [-infinity,0.5] [entire] = [empty]; // y = 0, z containedBy [0, 1] powRev1 [0.0,0.0] [0.25,0.5] [entire] = [empty]; // y = 0, z finishes [0, 1] powRev1 [0.0,0.0] [0.25,1.0] [entire] = [0.0, infinity]; powRev1 [0.0,0.0] [1.0,1.0] [entire] = [0.0, infinity]; // y = 0, z equals/finishedBy [0, 1] powRev1 [0.0,0.0] [0.0,1.0] [entire] = [0.0, infinity]; // y = 0, z contains/startedBy [0, 1] powRev1 [0.0,0.0] [0.0,2.0] [entire] = [0.0, infinity]; powRev1 [0.0,0.0] [0.0,infinity] [entire] = [0.0, infinity]; powRev1 [0.0,0.0] [-infinity,2.0] [entire] = [0.0, infinity]; powRev1 [0.0,0.0] [-infinity,infinity] [entire] = [0.0, infinity]; // y = 0, z overlappedBy [0, 1] powRev1 [0.0,0.0] [0.5,2.0] [entire] = [0.0, infinity]; powRev1 [0.0,0.0] [0.5,infinity] [entire] = [0.0, infinity]; // y = 0, z metBy [0, 1] powRev1 [0.0,0.0] [1.0,2.0] [entire] = [0.0, infinity]; powRev1 [0.0,0.0] [1.0,infinity] [entire] = [0.0, infinity]; // y = 0, z after [0, 1] powRev1 [0.0,0.0] [2.0,4.0] [entire] = [empty]; powRev1 [0.0,0.0] [2.0,infinity] [entire] = [empty]; // y finishedBy 0, z overlaps/starts [0,1] powRev1 [-4.0,0.0] [0.0,0.5] [entire] = [0x1.306FE0A31B715p0, infinity]; powRev1 [-infinity,0.0] [0.0,0.5] [entire] = [1.0, infinity]; powRev1 [-4.0,0.0] [-infinity,0.5] [entire] = [0x1.306FE0A31B715p0, infinity]; powRev1 [-infinity,0.0] [-infinity,0.5] [entire] = [1.0, infinity]; // y finishedBy 0, z containedBy [0, 1] powRev1 [-4.0,0.0] [0.25,0.5] [entire] = [0x1.306FE0A31B715p0, infinity]; powRev1 [-infinity,0.0] [0.25,0.5] [entire] = [1.0, infinity]; // y finishedBy 0, z finishes [0, 1] powRev1 [-4.0,0.0] [0.25,1.0] [entire] = [0.0, infinity]; powRev1 [-infinity,0.0] [0.25,1.0] [entire] = [0.0, infinity]; powRev1 [-4.0,0.0] [1.0,1.0] [entire] = [0.0, infinity]; powRev1 [-infinity,0.0] [1.0,1.0] [entire] = [0.0, infinity]; // y finishedBy 0, z equals/finishedBy [0, 1] powRev1 [-4.0,0.0] [0.0,1.0] [entire] = [0.0, infinity]; powRev1 [-infinity,0.0] [0.0,1.0] [entire] = [0.0, infinity]; // y finishedBy 0, z contains/startedBy [0, 1] powRev1 [-4.0,0.0] [0.0,2.0] [entire] = [0.0, infinity]; powRev1 [-infinity,0.0] [0.0,2.0] [entire] = [0.0, infinity]; powRev1 [-4.0,0.0] [0.0,infinity] [entire] = [0.0, infinity]; powRev1 [-infinity,0.0] [0.0,infinity] [entire] = [0.0, infinity]; powRev1 [-4.0,0.0] [-infinity,2.0] [entire] = [0.0, infinity]; powRev1 [-infinity,0.0] [-infinity,2.0] [entire] = [0.0, infinity]; powRev1 [-4.0,0.0] [-infinity,infinity] [entire] = [0.0, infinity]; powRev1 [-infinity,0.0] [-infinity,infinity] [entire] = [0.0, infinity]; // y finishedBy 0, z overlappedBy [0, 1] powRev1 [-4.0,0.0] [0.5,2.0] [entire] = [0.0, infinity]; powRev1 [-infinity,0.0] [0.5,2.0] [entire] = [0.0, infinity]; powRev1 [-4.0,0.0] [0.5,infinity] [entire] = [0.0, infinity]; powRev1 [-infinity,0.0] [0.5,infinity] [entire] = [0.0, infinity]; // y finishedBy 0, z metBy [0, 1] powRev1 [-4.0,0.0] [1.0,2.0] [entire] = [0.0, infinity]; powRev1 [-infinity,0.0] [1.0,2.0] [entire] = [0.0, infinity]; powRev1 [-4.0,0.0] [1.0,infinity] [entire] = [0.0, infinity]; powRev1 [-infinity,0.0] [1.0,infinity] [entire] = [0.0, infinity]; // y finishedBy 0, z after [0, 1] powRev1 [-4.0,0.0] [2.0,4.0] [entire] = [0.0, 0x1.AE89F995AD3AEp-1]; powRev1 [-infinity,0.0] [2.0,4.0] [entire] = [0.0, 1.0]; powRev1 [-4.0,0.0] [2.0,infinity] [entire] = [0.0, 0x1.AE89F995AD3AEp-1]; powRev1 [-infinity,0.0] [2.0,infinity] [entire] = [0.0, 1.0]; // y contains 0, z overlaps/starts [0,1] powRev1 [-4.0,4.0] [0.0,0.5] [entire] = [0.0, infinity]; powRev1 [-infinity,4.0] [0.0,0.5] [entire] = [0.0, infinity]; powRev1 [-4.0,4.0] [-infinity,0.5] [entire] = [0.0, infinity]; powRev1 [-infinity,4.0] [-infinity,0.5] [entire] = [0.0, infinity]; powRev1 [-4.0,infinity] [0.0,0.5] [entire] = [0.0, infinity]; powRev1 [entire] [0.0,0.5] [entire] = [0.0, infinity]; powRev1 [-4.0,infinity] [-infinity,0.5] [entire] = [0.0, infinity]; powRev1 [entire] [-infinity,0.5] [entire] = [0.0, infinity]; powRev1 [-4.0,4.0] [0.0,0.5] [0.0, 1.0] = [0.0, 0x1.AE89F995AD3AEp-1]; powRev1 [-infinity,4.0] [0.0,0.5] [0.0, 1.0] = [0.0, 0x1.AE89F995AD3AEp-1]; powRev1 [-4.0,4.0] [-infinity,0.5] [0.0, 1.0] = [0.0, 0x1.AE89F995AD3AEp-1]; powRev1 [-infinity,4.0] [-infinity,0.5] [0.0, 1.0] = [0.0, 0x1.AE89F995AD3AEp-1]; powRev1 [-4.0,infinity] [0.0,0.5] [0.0, 1.0] = [0.0, 1.0]; powRev1 [entire] [0.0,0.5] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-4.0,infinity] [-infinity,0.5] [0.0, 1.0] = [0.0, 1.0]; powRev1 [entire] [-infinity,0.5] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-4.0,4.0] [0.0,0.5] [1.0, infinity] = [0x1.306FE0A31B715p0, infinity]; powRev1 [-infinity,4.0] [0.0,0.5] [1.0, infinity] = [1.0, infinity]; powRev1 [-4.0,4.0] [-infinity,0.5] [1.0, infinity] = [0x1.306FE0A31B715p0, infinity]; powRev1 [-infinity,4.0] [-infinity,0.5] [1.0, infinity] = [1.0, infinity]; powRev1 [-4.0,infinity] [0.0,0.5] [1.0, infinity] = [0x1.306FE0A31B715p0, infinity]; powRev1 [entire] [0.0,0.5] [1.0, infinity] = [1.0, infinity]; powRev1 [-4.0,infinity] [-infinity,0.5] [1.0, infinity] = [0x1.306FE0A31B715p0, infinity]; powRev1 [entire] [-infinity,0.5] [1.0, infinity] = [1.0, infinity]; // y contains 0, z containedBy [0, 1] powRev1 [-4.0,4.0] [0.25,0.5] [entire] = [0.0, infinity]; powRev1 [-infinity,4.0] [0.25,0.5] [entire] = [0.0, infinity]; powRev1 [-4.0,infinity] [0.25,0.5] [entire] = [0.0, infinity]; powRev1 [entire] [0.25,0.5] [entire] = [0.0, infinity]; powRev1 [-4.0,4.0] [0.25,0.5] [0.0, 1.0] = [0.0, 0x1.AE89F995AD3AEp-1]; powRev1 [-infinity,4.0] [0.25,0.5] [0.0, 1.0] = [0.0, 0x1.AE89F995AD3AEp-1]; powRev1 [-4.0,infinity] [0.25,0.5] [0.0, 1.0] = [0.0, 1.0]; powRev1 [entire] [0.25,0.5] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-4.0,4.0] [0.25,0.5] [1.0, infinity] = [0x1.306FE0A31B715p0, infinity]; powRev1 [-infinity,4.0] [0.25,0.5] [1.0, infinity] = [1.0, infinity]; powRev1 [-4.0,infinity] [0.25,0.5] [1.0, infinity] = [0x1.306FE0A31B715p0, infinity]; powRev1 [entire] [0.25,0.5] [1.0, infinity] = [1.0, infinity]; // y contains 0, z finishes [0, 1] powRev1 [-4.0,4.0] [0.25,1.0] [entire] = [0.0, infinity]; powRev1 [-infinity,4.0] [0.25,1.0] [entire] = [0.0, infinity]; powRev1 [-4.0,4.0] [1.0,1.0] [entire] = [0.0, infinity]; powRev1 [-infinity,4.0] [1.0,1.0] [entire] = [0.0, infinity]; powRev1 [-4.0,infinity] [0.25,1.0] [entire] = [0.0, infinity]; powRev1 [entire] [0.25,1.0] [entire] = [0.0, infinity]; powRev1 [-4.0,infinity] [1.0,1.0] [entire] = [0.0, infinity]; powRev1 [entire] [1.0,1.0] [entire] = [0.0, infinity]; powRev1 [-4.0,4.0] [0.25,1.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-infinity,4.0] [0.25,1.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-4.0,4.0] [1.0,1.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-infinity,4.0] [1.0,1.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-4.0,infinity] [0.25,1.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [entire] [0.25,1.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-4.0,infinity] [1.0,1.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [entire] [1.0,1.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-4.0,4.0] [0.25,1.0] [1.0, infinity] = [1.0, infinity]; powRev1 [-infinity,4.0] [0.25,1.0] [1.0, infinity] = [1.0, infinity]; powRev1 [-4.0,4.0] [1.0,1.0] [1.0, infinity] = [1.0, infinity]; powRev1 [-infinity,4.0] [1.0,1.0] [1.0, infinity] = [1.0, infinity]; powRev1 [-4.0,infinity] [0.25,1.0] [1.0, infinity] = [1.0, infinity]; powRev1 [entire] [0.25,1.0] [1.0, infinity] = [1.0, infinity]; powRev1 [-4.0,infinity] [1.0,1.0] [1.0, infinity] = [1.0, infinity]; powRev1 [entire] [1.0,1.0] [1.0, infinity] = [1.0, infinity]; // y contains 0, z equals/contains [0, 1] powRev1 [-4.0,4.0] [0.0,1.0] [entire] = [0.0, infinity]; powRev1 [-infinity,4.0] [0.0,1.0] [entire] = [0.0, infinity]; powRev1 [-4.0,infinity] [0.0,1.0] [entire] = [0.0, infinity]; powRev1 [entire] [0.0,1.0] [entire] = [0.0, infinity]; powRev1 [-4.0,4.0] [0.0,1.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-infinity,4.0] [0.0,1.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-4.0,infinity] [0.0,1.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [entire] [0.0,1.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-4.0,4.0] [0.0,1.0] [1.0, infinity] = [1.0, infinity]; powRev1 [-infinity,4.0] [0.0,1.0] [1.0, infinity] = [1.0, infinity]; powRev1 [-4.0,infinity] [0.0,1.0] [1.0, infinity] = [1.0, infinity]; powRev1 [entire] [0.0,1.0] [1.0, infinity] = [1.0, infinity]; // y contains 0, z contains/startedBy [0, 1] powRev1 [-4.0,4.0] [0.0,2.0] [entire] = [0.0, infinity]; powRev1 [-infinity,4.0] [0.0,2.0] [entire] = [0.0, infinity]; powRev1 [-4.0,4.0] [0.0,infinity] [entire] = [0.0, infinity]; powRev1 [-infinity,4.0] [0.0,infinity] [entire] = [0.0, infinity]; powRev1 [-4.0,4.0] [-infinity,2.0] [entire] = [0.0, infinity]; powRev1 [-infinity,4.0] [-infinity,2.0] [entire] = [0.0, infinity]; powRev1 [-4.0,4.0] [-infinity,infinity] [entire] = [0.0, infinity]; powRev1 [-infinity,4.0] [-infinity,infinity] [entire] = [0.0, infinity]; powRev1 [-4.0,infinity] [0.0,2.0] [entire] = [0.0, infinity]; powRev1 [entire] [0.0,2.0] [entire] = [0.0, infinity]; powRev1 [-4.0,infinity] [0.0,infinity] [entire] = [0.0, infinity]; powRev1 [entire] [0.0,infinity] [entire] = [0.0, infinity]; powRev1 [-4.0,infinity] [-infinity,2.0] [entire] = [0.0, infinity]; powRev1 [entire] [-infinity,2.0] [entire] = [0.0, infinity]; powRev1 [-4.0,infinity] [-infinity,infinity] [entire] = [0.0, infinity]; powRev1 [entire] [-infinity,infinity] [entire] = [0.0, infinity]; powRev1 [-4.0,4.0] [0.0,2.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-infinity,4.0] [0.0,2.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-4.0,4.0] [0.0,infinity] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-infinity,4.0] [0.0,infinity] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-4.0,4.0] [-infinity,2.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-infinity,4.0] [-infinity,2.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-4.0,4.0] [-infinity,infinity] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-infinity,4.0] [-infinity,infinity] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-4.0,infinity] [0.0,2.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [entire] [0.0,2.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-4.0,infinity] [0.0,infinity] [0.0, 1.0] = [0.0, 1.0]; powRev1 [entire] [0.0,infinity] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-4.0,infinity] [-infinity,2.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [entire] [-infinity,2.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-4.0,infinity] [-infinity,infinity] [0.0, 1.0] = [0.0, 1.0]; powRev1 [entire] [-infinity,infinity] [0.0, 1.0] = [0.0, 1.0]; powRev1 [-4.0,4.0] [0.0,2.0] [1.0, infinity] = [1.0, infinity]; powRev1 [-infinity,4.0] [0.0,2.0] [1.0, infinity] = [1.0, infinity]; powRev1 [-4.0,4.0] [0.0,infinity] [1.0, infinity] = [1.0, infinity]; powRev1 [-infinity,4.0] [0.0,infinity] [1.0, infinity] = [1.0, infinity]; powRev1 [-4.0,4.0] [-infinity,2.0] [1.0, infinity] = [1.0, infinity]; powRev1 [-infinity,4.0] [-infinity,2.0] [1.0, infinity] = [1.0, infinity]; powRev1 [-4.0,4.0] [-infinity,infinity] [1.0, infinity] = [1.0, infinity]; powRev1 [-infinity,4.0] [-infinity,infinity] [1.0, infinity] = [1.0, infinity]; powRev1 [-4.0,infinity] [0.0,2.0] [1.0, infinity] = [1.0, infinity]; powRev1 [entire] [0.0,2.0] [1.0, infinity] = [1.0, infinity]; powRev1 [-4.0,infinity] [0.0,infinity] [1.0, infinity] = [1.0, infinity]; powRev1 [entire] [0.0,infinity] [1.0, infinity] = [1.0, infinity]; powRev1 [-4.0,infinity] [-infinity,2.0] [1.0, infinity] = [1.0, infinity]; powRev1 [entire] [-infinity,2.0] [1.0, infinity] = [1.0, infinity]; powRev1 [-4.0,infinity] [-infinity,infinity] [1.0, infinity] = [1.0, infinity]; powRev1 [entire] [-infinity,infinity] [1.0, infinity] = [1.0, infinity]; // y contains 0, z overlappedBy [0, 1] powRev1 [-4.0,4.0] [0.5,2.0] [entire] = [0.0, infinity]; powRev1 [-infinity,4.0] [0.5,2.0] [entire] = [0.0, infinity]; powRev1 [-4.0,4.0] [0.5,infinity] [entire] = [0.0, infinity]; powRev1 [-infinity,4.0] [0.5,infinity] [entire] = [0.0, infinity]; powRev1 [-4.0,infinity] [0.5,2.0] [entire] = [0.0, infinity]; powRev1 [entire] [0.5,2.0] [entire] = [0.0, infinity]; powRev1 [-4.0,infinity] [0.5,infinity] [entire] = [0.0, infinity]; powRev1 [entire] [0.5,infinity] [entire] = [0.0, infinity]; powRev1 [-4.0,4.0] [0.5,2.0] [0.0,1.0] = [0.0, 1.0]; powRev1 [-infinity,4.0] [0.5,2.0] [0.0,1.0] = [0.0, 1.0]; powRev1 [-4.0,4.0] [0.5,infinity] [0.0,1.0] = [0.0, 1.0]; powRev1 [-infinity,4.0] [0.5,infinity] [0.0,1.0] = [0.0, 1.0]; powRev1 [-4.0,infinity] [0.5,2.0] [0.0,1.0] = [0.0, 1.0]; powRev1 [entire] [0.5,2.0] [0.0,1.0] = [0.0, 1.0]; powRev1 [-4.0,infinity] [0.5,infinity] [0.0,1.0] = [0.0, 1.0]; powRev1 [entire] [0.5,infinity] [0.0,1.0] = [0.0, 1.0]; powRev1 [-4.0,4.0] [0.5,2.0] [1.0,infinity] = [1.0, infinity]; powRev1 [-infinity,4.0] [0.5,2.0] [1.0,infinity] = [1.0, infinity]; powRev1 [-4.0,4.0] [0.5,infinity] [1.0,infinity] = [1.0, infinity]; powRev1 [-infinity,4.0] [0.5,infinity] [1.0,infinity] = [1.0, infinity]; powRev1 [-4.0,infinity] [0.5,2.0] [1.0,infinity] = [1.0, infinity]; powRev1 [entire] [0.5,2.0] [1.0,infinity] = [1.0, infinity]; powRev1 [-4.0,infinity] [0.5,infinity] [1.0,infinity] = [1.0, infinity]; powRev1 [entire] [0.5,infinity] [1.0,infinity] = [1.0, infinity]; // y contains 0, z metBy [0, 1] powRev1 [-4.0,4.0] [1.0,2.0] [entire] = [0.0, infinity]; powRev1 [-infinity,4.0] [1.0,2.0] [entire] = [0.0, infinity]; powRev1 [-4.0,4.0] [1.0,infinity] [entire] = [0.0, infinity]; powRev1 [-infinity,4.0] [1.0,infinity] [entire] = [0.0, infinity]; powRev1 [-4.0,infinity] [1.0,2.0] [entire] = [0.0, infinity]; powRev1 [entire] [1.0,2.0] [entire] = [0.0, infinity]; powRev1 [-4.0,infinity] [1.0,infinity] [entire] = [0.0, infinity]; powRev1 [entire] [1.0,infinity] [entire] = [0.0, infinity]; powRev1 [-4.0,4.0] [1.0,2.0] [0.0,1.0] = [0.0, 1.0]; powRev1 [-infinity,4.0] [1.0,2.0] [0.0,1.0] = [0.0, 1.0]; powRev1 [-4.0,4.0] [1.0,infinity] [0.0,1.0] = [0.0, 1.0]; powRev1 [-infinity,4.0] [1.0,infinity] [0.0,1.0] = [0.0, 1.0]; powRev1 [-4.0,infinity] [1.0,2.0] [0.0,1.0] = [0.0, 1.0]; powRev1 [entire] [1.0,2.0] [0.0,1.0] = [0.0, 1.0]; powRev1 [-4.0,infinity] [1.0,infinity] [0.0,1.0] = [0.0, 1.0]; powRev1 [entire] [1.0,infinity] [0.0,1.0] = [0.0, 1.0]; powRev1 [-4.0,4.0] [1.0,2.0] [1.0,infinity] = [1.0, infinity]; powRev1 [-infinity,4.0] [1.0,2.0] [1.0,infinity] = [1.0, infinity]; powRev1 [-4.0,4.0] [1.0,infinity] [1.0,infinity] = [1.0, infinity]; powRev1 [-infinity,4.0] [1.0,infinity] [1.0,infinity] = [1.0, infinity]; powRev1 [-4.0,infinity] [1.0,2.0] [1.0,infinity] = [1.0, infinity]; powRev1 [entire] [1.0,2.0] [1.0,infinity] = [1.0, infinity]; powRev1 [-4.0,infinity] [1.0,infinity] [1.0,infinity] = [1.0, infinity]; powRev1 [entire] [1.0,infinity] [1.0,infinity] = [1.0, infinity]; // y contains 0, z after [0, 1] powRev1 [-4.0,4.0] [2.0,4.0] [entire] = [0.0, infinity]; powRev1 [-infinity,4.0] [2.0,4.0] [entire] = [0.0, infinity]; powRev1 [-4.0,4.0] [2.0,infinity] [entire] = [0.0, infinity]; powRev1 [-infinity,4.0] [2.0,infinity] [entire] = [0.0, infinity]; powRev1 [-4.0,infinity] [2.0,4.0] [entire] = [0.0, infinity]; powRev1 [entire] [2.0,4.0] [entire] = [0.0, infinity]; powRev1 [-4.0,infinity] [2.0,infinity] [entire] = [0.0, infinity]; powRev1 [entire] [2.0,infinity] [entire] = [0.0, infinity]; powRev1 [-4.0,4.0] [2.0,4.0] [0.0,1.0] = [0.0, 0x1.AE89F995AD3AEp-1]; powRev1 [-infinity,4.0] [2.0,4.0] [0.0,1.0] = [0.0, 1.0]; powRev1 [-4.0,4.0] [2.0,infinity] [0.0,1.0] = [0.0, 0x1.AE89F995AD3AEp-1]; powRev1 [-infinity,4.0] [2.0,infinity] [0.0,1.0] = [0.0, 1.0]; powRev1 [-4.0,infinity] [2.0,4.0] [0.0,1.0] = [0.0, 0x1.AE89F995AD3AEp-1]; powRev1 [entire] [2.0,4.0] [0.0,1.0] = [0.0, 1.0]; powRev1 [-4.0,infinity] [2.0,infinity] [0.0,1.0] = [0.0, 0x1.AE89F995AD3AEp-1]; powRev1 [entire] [2.0,infinity] [0.0,1.0] = [0.0, 1.0]; powRev1 [-4.0,4.0] [2.0,4.0] [1.0,infinity] = [0x1.306FE0A31B715p0, infinity]; powRev1 [-infinity,4.0] [2.0,4.0] [1.0,infinity] = [0x1.306FE0A31B715p0, infinity]; powRev1 [-4.0,4.0] [2.0,infinity] [1.0,infinity] = [0x1.306FE0A31B715p0, infinity]; powRev1 [-infinity,4.0] [2.0,infinity] [1.0,infinity] = [0x1.306FE0A31B715p0, infinity]; powRev1 [-4.0,infinity] [2.0,4.0] [1.0,infinity] = [1.0, infinity]; powRev1 [entire] [2.0,4.0] [1.0,infinity] = [1.0, infinity]; powRev1 [-4.0,infinity] [2.0,infinity] [1.0,infinity] = [1.0, infinity]; powRev1 [entire] [2.0,infinity] [1.0,infinity] = [1.0, infinity]; // y startedBy 0, z overlaps/starts [0,1] powRev1 [0.0,4.0] [0.0,0.5] [entire] = [0.0, 0x1.AE89F995AD3AEp-1]; powRev1 [0.0,4.0] [-infinity,0.5] [entire] = [0.0, 0x1.AE89F995AD3AEp-1]; powRev1 [0.0,infinity] [0.0,0.5] [entire] = [0.0, 1.0]; powRev1 [0.0,infinity] [-infinity,0.5] [entire] = [0.0, 1.0]; powRev1 [0.0,4.0] [0.0,0.5] [0.0, 1.0] = [0.0, 0x1.AE89F995AD3AEp-1]; powRev1 [0.0,4.0] [-infinity,0.5] [0.0, 1.0] = [0.0, 0x1.AE89F995AD3AEp-1]; powRev1 [0.0,infinity] [0.0,0.5] [0.0, 1.0] = [0.0, 1.0]; powRev1 [0.0,infinity] [-infinity,0.5] [0.0, 1.0] = [0.0, 1.0]; powRev1 [0.0,4.0] [0.0,0.5] [1.0, infinity] = [empty]; powRev1 [0.0,4.0] [-infinity,0.5] [1.0, infinity] = [empty]; powRev1 [0.0,infinity] [0.0,0.5] [1.0, infinity] = [empty]; powRev1 [0.0,infinity] [-infinity,0.5] [1.0, infinity] = [empty]; // y startedBy 0, z containedBy [0, 1] powRev1 [0.0,4.0] [0.25,0.5] [entire] = [0.0, 0x1.AE89F995AD3AEp-1]; powRev1 [0.0,infinity] [0.25,0.5] [entire] = [0.0, 1.0]; powRev1 [0.0,4.0] [0.25,0.5] [0.0, 1.0] = [0.0, 0x1.AE89F995AD3AEp-1]; powRev1 [0.0,infinity] [0.25,0.5] [0.0, 1.0] = [0.0, 1.0]; powRev1 [0.0,4.0] [0.25,0.5] [1.0, infinity] = [empty]; powRev1 [0.0,infinity] [0.25,0.5] [1.0, infinity] = [empty]; // y startedBy 0, z finishes [0, 1] powRev1 [0.0,4.0] [0.25,1.0] [entire] = [0.0, infinity]; powRev1 [0.0,4.0] [1.0,1.0] [entire] = [0.0, infinity]; powRev1 [0.0,infinity] [0.25,1.0] [entire] = [0.0, infinity]; powRev1 [0.0,infinity] [1.0,1.0] [entire] = [0.0, infinity]; powRev1 [0.0,4.0] [0.25,1.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [0.0,4.0] [1.0,1.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [0.0,infinity] [0.25,1.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [0.0,infinity] [1.0,1.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [0.0,4.0] [0.25,1.0] [1.0, infinity] = [1.0, infinity]; powRev1 [0.0,4.0] [1.0,1.0] [1.0, infinity] = [1.0, infinity]; powRev1 [0.0,infinity] [0.25,1.0] [1.0, infinity] = [1.0, infinity]; powRev1 [0.0,infinity] [1.0,1.0] [1.0, infinity] = [1.0, infinity]; // y startedBy 0, z equals/contains [0, 1] powRev1 [0.0,4.0] [0.0,1.0] [entire] = [0.0, infinity]; powRev1 [0.0,infinity] [0.0,1.0] [entire] = [0.0, infinity]; powRev1 [0.0,4.0] [0.0,1.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [0.0,infinity] [0.0,1.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [0.0,4.0] [0.0,1.0] [1.0, infinity] = [1.0, infinity]; powRev1 [0.0,infinity] [0.0,1.0] [1.0, infinity] = [1.0, infinity]; // y startedBy 0, z contains/startedBy [0, 1] powRev1 [0.0,4.0] [0.0,2.0] [entire] = [0.0, infinity]; powRev1 [0.0,4.0] [0.0,infinity] [entire] = [0.0, infinity]; powRev1 [0.0,4.0] [-infinity,2.0] [entire] = [0.0, infinity]; powRev1 [0.0,4.0] [-infinity,infinity] [entire] = [0.0, infinity]; powRev1 [0.0,infinity] [0.0,2.0] [entire] = [0.0, infinity]; powRev1 [0.0,infinity] [0.0,infinity] [entire] = [0.0, infinity]; powRev1 [0.0,infinity] [-infinity,2.0] [entire] = [0.0, infinity]; powRev1 [0.0,infinity] [-infinity,infinity] [entire] = [0.0, infinity]; powRev1 [0.0,4.0] [0.0,2.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [0.0,4.0] [0.0,infinity] [0.0, 1.0] = [0.0, 1.0]; powRev1 [0.0,4.0] [-infinity,2.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [0.0,4.0] [-infinity,infinity] [0.0, 1.0] = [0.0, 1.0]; powRev1 [0.0,infinity] [0.0,2.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [0.0,infinity] [0.0,infinity] [0.0, 1.0] = [0.0, 1.0]; powRev1 [0.0,infinity] [-infinity,2.0] [0.0, 1.0] = [0.0, 1.0]; powRev1 [0.0,infinity] [-infinity,infinity] [0.0, 1.0] = [0.0, 1.0]; powRev1 [0.0,4.0] [0.0,2.0] [1.0, infinity] = [1.0, infinity]; powRev1 [0.0,4.0] [0.0,infinity] [1.0, infinity] = [1.0, infinity]; powRev1 [0.0,4.0] [-infinity,2.0] [1.0, infinity] = [1.0, infinity]; powRev1 [0.0,4.0] [-infinity,infinity] [1.0, infinity] = [1.0, infinity]; powRev1 [0.0,infinity] [0.0,2.0] [1.0, infinity] = [1.0, infinity]; powRev1 [0.0,infinity] [0.0,infinity] [1.0, infinity] = [1.0, infinity]; powRev1 [0.0,infinity] [-infinity,2.0] [1.0, infinity] = [1.0, infinity]; powRev1 [0.0,infinity] [-infinity,infinity] [1.0, infinity] = [1.0, infinity]; // y startedBy 0, z overlappedBy [0, 1] powRev1 [0.0,4.0] [0.5,2.0] [entire] = [0.0, infinity]; powRev1 [0.0,4.0] [0.5,infinity] [entire] = [0.0, infinity]; powRev1 [0.0,infinity] [0.5,2.0] [entire] = [0.0, infinity]; powRev1 [0.0,infinity] [0.5,infinity] [entire] = [0.0, infinity]; powRev1 [0.0,4.0] [0.5,2.0] [0.0,1.0] = [0.0, 1.0]; powRev1 [0.0,4.0] [0.5,infinity] [0.0,1.0] = [0.0, 1.0]; powRev1 [0.0,infinity] [0.5,2.0] [0.0,1.0] = [0.0, 1.0]; powRev1 [0.0,infinity] [0.5,infinity] [0.0,1.0] = [0.0, 1.0]; powRev1 [0.0,4.0] [0.5,2.0] [1.0,infinity] = [1.0, infinity]; powRev1 [0.0,4.0] [0.5,infinity] [1.0,infinity] = [1.0, infinity]; powRev1 [0.0,infinity] [0.5,2.0] [1.0,infinity] = [1.0, infinity]; powRev1 [0.0,infinity] [0.5,infinity] [1.0,infinity] = [1.0, infinity]; // y startedBy 0, z metBy [0, 1] powRev1 [0.0,4.0] [1.0,2.0] [entire] = [0.0, infinity]; powRev1 [0.0,4.0] [1.0,infinity] [entire] = [0.0, infinity]; powRev1 [0.0,infinity] [1.0,2.0] [entire] = [0.0, infinity]; powRev1 [0.0,infinity] [1.0,infinity] [entire] = [0.0, infinity]; powRev1 [0.0,4.0] [1.0,2.0] [0.0,1.0] = [0.0, 1.0]; powRev1 [0.0,4.0] [1.0,infinity] [0.0,1.0] = [0.0, 1.0]; powRev1 [0.0,infinity] [1.0,2.0] [0.0,1.0] = [0.0, 1.0]; powRev1 [0.0,infinity] [1.0,infinity] [0.0,1.0] = [0.0, 1.0]; powRev1 [0.0,4.0] [1.0,2.0] [1.0,infinity] = [1.0, infinity]; powRev1 [0.0,4.0] [1.0,infinity] [1.0,infinity] = [1.0, infinity]; powRev1 [0.0,infinity] [1.0,2.0] [1.0,infinity] = [1.0, infinity]; powRev1 [0.0,infinity] [1.0,infinity] [1.0,infinity] = [1.0, infinity]; // y startedBy 0, z after [0, 1] powRev1 [0.0,4.0] [2.0,4.0] [entire] = [0x1.306FE0A31B715p0, infinity]; powRev1 [0.0,4.0] [2.0,infinity] [entire] = [0x1.306FE0A31B715p0, infinity]; powRev1 [0.0,infinity] [2.0,4.0] [entire] = [1.0, infinity]; powRev1 [0.0,infinity] [2.0,infinity] [entire] = [1.0, infinity]; powRev1 [0.0,4.0] [2.0,4.0] [0.0,1.0] = [empty]; powRev1 [0.0,4.0] [2.0,infinity] [0.0,1.0] = [empty]; powRev1 [0.0,infinity] [2.0,4.0] [0.0,1.0] = [empty]; powRev1 [0.0,infinity] [2.0,infinity] [0.0,1.0] = [empty]; powRev1 [0.0,4.0] [2.0,4.0] [1.0,infinity] = [0x1.306FE0A31B715p0, infinity]; powRev1 [0.0,4.0] [2.0,infinity] [1.0,infinity] = [0x1.306FE0A31B715p0, infinity]; powRev1 [0.0,infinity] [2.0,4.0] [1.0,infinity] = [1.0, infinity]; powRev1 [0.0,infinity] [2.0,infinity] [1.0,infinity] = [1.0, infinity]; // y after 0, z overlaps/starts [0,1] powRev1 [2.0,4.0] [0.0,0.5] [entire] = [0.0, 0x1.AE89F995AD3AEp-1]; powRev1 [2.0,4.0] [-infinity,0.5] [entire] = [0.0, 0x1.AE89F995AD3AEp-1]; powRev1 [2.0,infinity] [0.0,0.5] [entire] = [0.0, 1.0]; powRev1 [2.0,infinity] [-infinity,0.5] [entire] = [0.0, 1.0]; // y after 0, z containedBy [0, 1] powRev1 [2.0,4.0] [0.25,0.5] [entire] = [0.5, 0x1.AE89F995AD3AEp-1]; powRev1 [2.0,infinity] [0.25,0.5] [entire] = [0.5, 1.0]; // y after 0, z finishes [0, 1] powRev1 [2.0,4.0] [0.25,1.0] [entire] = [0.5, 1.0]; powRev1 [2.0,4.0] [1.0,1.0] [entire] = [1.0, 1.0]; powRev1 [2.0,infinity] [0.25,1.0] [entire] = [0.5, 1.0]; powRev1 [2.0,infinity] [1.0,1.0] [entire] = [1.0, 1.0]; // y after 0, z equals/contains [0, 1] powRev1 [2.0,4.0] [0.0,1.0] [entire] = [0.0, 1.0]; powRev1 [2.0,infinity] [0.0,1.0] [entire] = [0.0, 1.0]; // y after 0, z contains/startedBy [0, 1] powRev1 [2.0,4.0] [0.0,2.0] [entire] = [0.0, 0x1.6A09E667F3BCDp0]; powRev1 [2.0,4.0] [0.0,infinity] [entire] = [0.0, infinity]; powRev1 [2.0,4.0] [-infinity,2.0] [entire] = [0.0, 0x1.6A09E667F3BCDp0]; powRev1 [2.0,4.0] [-infinity,infinity] [entire] = [0.0, infinity]; powRev1 [2.0,infinity] [0.0,2.0] [entire] = [0.0, 0x1.6A09E667F3BCDp0]; powRev1 [2.0,infinity] [0.0,infinity] [entire] = [0.0, infinity]; powRev1 [2.0,infinity] [-infinity,2.0] [entire] = [0.0, 0x1.6A09E667F3BCDp0]; powRev1 [2.0,infinity] [-infinity,infinity] [entire] = [0.0, infinity]; // y after 0, z overlappedBy [0, 1] powRev1 [2.0,4.0] [0.5,2.0] [entire] = [0x1.6A09E667F3BCCp-1, 0x1.6A09E667F3BCDp0]; powRev1 [2.0,4.0] [0.5,infinity] [entire] = [0x1.6A09E667F3BCCp-1, infinity]; powRev1 [2.0,infinity] [0.5,2.0] [entire] = [0x1.6A09E667F3BCCp-1, 0x1.6A09E667F3BCDp0]; powRev1 [2.0,infinity] [0.5,infinity] [entire] = [0x1.6A09E667F3BCCp-1, infinity]; // y after 0, z metBy [0, 1] powRev1 [2.0,4.0] [1.0,2.0] [entire] = [1.0, 0x1.6A09E667F3BCDp0]; powRev1 [2.0,4.0] [1.0,infinity] [entire] = [1.0, infinity]; powRev1 [2.0,infinity] [1.0,2.0] [entire] = [1.0, 0x1.6A09E667F3BCDp0]; powRev1 [2.0,infinity] [1.0,infinity] [entire] = [1.0, infinity]; // y after 0, z after [0, 1] powRev1 [2.0,4.0] [2.0,4.0] [entire] = [0x1.306FE0A31B715p0, 2.0]; powRev1 [2.0,4.0] [2.0,infinity] [entire] = [0x1.306FE0A31B715p0, infinity]; powRev1 [2.0,infinity] [2.0,4.0] [entire] = [1.0, 2.0]; powRev1 [2.0,infinity] [2.0,infinity] [entire] = [1.0, infinity]; } /* The following tests use boundaries for the first and second parameter whose binary logarithm can be computed without round-off error in a binary floating-point context. Thus, an implementation should be able to compute tight results with the formula y = log2 z / log2 x for the intervals used here. Implementations which use natural logarithm would introduce additional errors. The test values are structured according to table B.2 in Heimlich, Oliver. 2011. “The General Interval Power Function.” Diplomarbeit, Institute for Computer Science, University of Würzburg. http://exp.ln0.de/heimlich-power-2011.htm. */ testcase minimal.powRev2_test { // Empty intervals powRev2 [empty] [empty] [empty] = [empty]; powRev2 [empty] [entire] [empty] = [empty]; powRev2 [entire] [empty] [empty] = [empty]; powRev2 [entire] [entire] [empty] = [empty]; powRev2 [empty] [empty] [entire] = [empty]; powRev2 [empty] [entire] [entire] = [empty]; powRev2 [entire] [empty] [entire] = [empty]; // Entire range powRev2 [entire] [entire] [entire] = [entire]; // Outside of the function's domain powRev2 [0.0, 0.0] [-infinity, -0.1] [entire] = [empty]; powRev2 [0.0, 0.0] [0.1, infinity] [entire] = [empty]; powRev2 [0.0, 0.0] [0.0, 0.0] [-infinity, 0.0] = [empty]; powRev2 [-infinity, 0.9] [0.0, 0.9] [-infinity, 0.0] = [empty]; powRev2 [1.1, infinity] [1.1, infinity] [-infinity, 0.0] = [empty]; powRev2 [-infinity, 0.9] [1.1, infinity] [0.0, infinity] = [empty]; powRev2 [1.1, infinity] [0.0, 0.9] [0.0, infinity] = [empty]; // 0^y = 0 powRev2 [0.0, 0.0] [0.0, 0.0] [entire] = [0.0, infinity]; powRev2 [-infinity, 0.0] [-infinity, 0.0] [0.0, infinity] = [0.0, infinity]; powRev2 [-infinity, 0.0] [-infinity, 0.0] [1.0, 2.0] = [1.0, 2.0]; powRev2 [entire] [0.0, 0.0] [entire] = [0.0, infinity]; powRev2 [entire] [-infinity, 0.0] [0.0, infinity] = [0.0, infinity]; powRev2 [entire] [-infinity, 0.0] [1.0, 2.0] = [1.0, 2.0]; powRev2 [0.0, 0.0] [entire] [entire] = [0.0, infinity]; powRev2 [-infinity, 0.0] [entire] [0.0, infinity] = [0.0, infinity]; powRev2 [-infinity, 0.0] [entire] [1.0, 2.0] = [1.0, 2.0]; // 1^y = x^0 = 1 powRev2 [1.0, 1.0] [entire] [entire] = [entire]; powRev2 [1.0, 1.0] [1.0, 1.0] [entire] = [entire]; powRev2 [1.0, 1.0] [1.0, 1.0] [2.0, 3.0] = [2.0, 3.0]; powRev2 [entire] [1.0, 1.0] [entire] = [entire]; powRev2 [entire] [1.0, 1.0] [2.0, 3.0] = [2.0, 3.0]; powRev2 [2.0, 3.0] [1.0, 1.0] [entire] = [0.0, 0.0]; powRev2 [2.0, 3.0] [1.0, 1.0] [2.0, 3.0] = [empty]; // x overlaps/starts [0, 1], z overlaps/starts [0, 1] powRev2 [0.0, 0.5] [0.0, 0.5] [entire] = [0.0, infinity]; powRev2 [0.0, 0.5] [0.0, 0.5] [-infinity, 0.0] = [empty]; // x overlaps/starts [0, 1], z containedBy [0, 1] powRev2 [0.0, 0.5] [0.25, 0.5] [entire] = [0.0, 2.0]; // x overlaps/starts [0, 1], z finishes [0, 1] powRev2 [0.0, 0.25] [0.5, 1.0] [entire] = [0.0, 0.5]; powRev2 [0.0, 0.25] [1.0, 1.0] [entire] = [0.0, 0.0]; // x overlaps/starts [0, 1], z equals/finishedBy [0, 1] powRev2 [0.0, 0.25] [0.0, 1.0] [entire] = [0.0, infinity]; powRev2 [0.0, 0.25] [0.0, 1.0] [-infinity, 0.0] = [0.0, 0.0]; // x overlaps/starts [0, 1], z contains/startedBy [0, 1] powRev2 [0.0, 0.25] [0.0, 2.0] [entire] = [-0.5, infinity]; powRev2 [0.0, 0.25] [0.0, infinity] [entire] = [entire]; // x overlaps/starts [0, 1], z overlappedBy [0, 1] powRev2 [0.0, 0.25] [0.5, 2.0] [entire] = [-0.5, 0.5]; powRev2 [0.0, 0.25] [0.5, infinity] [entire] = [-infinity, 0.5]; // x overlaps/starts [0, 1], z metBy [0, 1] powRev2 [0.0, 0.25] [1.0, 2.0] [entire] = [-0.5, 0.0]; powRev2 [0.0, 0.25] [1.0, 2.0] [0.0, infinity] = [0.0, 0.0]; powRev2 [0.0, 0.25] [1.0, infinity] [entire] = [-infinity, 0.0]; powRev2 [0.0, 0.25] [1.0, infinity] [0.0, infinity] = [0.0, 0.0]; // x overlaps/starts [0, 1], z after [0, 1] powRev2 [0.0, 0.25] [2.0, 4.0] [entire] = [-1.0, 0.0]; powRev2 [0.0, 0.25] [2.0, 4.0] [0.0, infinity] = [empty]; powRev2 [0.0, 0.25] [2.0, infinity] [entire] = [-infinity, 0.0]; powRev2 [0.0, 0.25] [2.0, infinity] [0.0, infinity] = [empty]; // x containedBy [0, 1], z overlaps/starts [0, 1] powRev2 [0.25, 0.5] [0.0, 0.5] [entire] = [0.5, infinity]; // x containedBy [0, 1], z containedBy [0, 1] powRev2 [0.25, 0.5] [0.25, 0.5] [entire] = [0.5, 2.0]; // x containedBy [0, 1], z finishes [0, 1] powRev2 [0.25, 0.5] [0.5, 1.0] [entire] = [0.0, 1.0]; powRev2 [0.25, 0.5] [1.0, 1.0] [entire] = [0.0, 0.0]; // x containedBy [0, 1], z equals/finishedBy [0, 1] powRev2 [0.25, 0.5] [0.0, 1.0] [entire] = [0.0, infinity]; powRev2 [0.25, 0.5] [0.0, 1.0] [-infinity, 0.0] = [0.0, 0.0]; // x containedBy [0, 1], z contains/startedBy [0, 1] powRev2 [0.25, 0.5] [0.0, 2.0] [entire] = [-1.0, infinity]; powRev2 [0.25, 0.5] [0.0, infinity] [entire] = [entire]; // x containedBy [0, 1], z overlappedBy [0, 1] powRev2 [0.25, 0.5] [0.5, 2.0] [entire] = [-1.0, 1.0]; powRev2 [0.25, 0.5] [0.5, infinity] [entire] = [-infinity, 1.0]; // x containedBy [0, 1], z metBy [0, 1] powRev2 [0.25, 0.5] [1.0, 2.0] [entire] = [-1.0, 0.0]; powRev2 [0.25, 0.5] [1.0, infinity] [entire] = [-infinity, 0.0]; // x containedBy [0, 1], z after [0, 1] powRev2 [0.25, 0.5] [2.0, 4.0] [entire] = [-2.0, -0.5]; powRev2 [0.25, 0.5] [2.0, infinity] [entire] = [entire]; // x finishes [0, 1], z overlaps/starts [0, 1] powRev2 [0.25, 1.0] [0.0, 0.5] [entire] = [0.5, infinity]; powRev2 [1.0, 1.0] [0.0, 0.5] [entire] = [empty]; // x finishes [0, 1], z containedBy [0, 1] powRev2 [0.25, 1.0] [0.25, 0.5] [entire] = [0.5, infinity]; powRev2 [1.0, 1.0] [0.25, 0.5] [entire] = [empty]; // x finishes [0, 1], z finishes [0, 1] powRev2 [0.25, 1.0] [0.5, 1.0] [entire] = [entire]; powRev2 [0.25, 1.0] [1.0, 1.0] [entire] = [entire]; powRev2 [1.0, 1.0] [0.5, 1.0] [entire] = [entire]; powRev2 [1.0, 1.0] [1.0, 1.0] [entire] = [entire]; // x finishes [0, 1], z equals/finishedBy [0, 1] powRev2 [0.25, 1.0] [0.0, 1.0] [entire] = [entire]; powRev2 [1.0, 1.0] [0.0, 1.0] [entire] = [entire]; // x finishes [0, 1], z contains/startedBy [0, 1] powRev2 [0.25, 1.0] [0.0, 2.0] [entire] = [entire]; powRev2 [1.0, 1.0] [0.0, 2.0] [entire] = [entire]; powRev2 [0.25, 1.0] [0.0, infinity] [entire] = [entire]; powRev2 [1.0, 1.0] [0.0, infinity] [entire] = [entire]; // x finishes [0, 1], z overlappedBy [0, 1] powRev2 [0.25, 1.0] [0.5, 2.0] [entire] = [entire]; powRev2 [1.0, 1.0] [0.5, 2.0] [entire] = [entire]; powRev2 [0.25, 1.0] [0.5, infinity] [entire] = [entire]; powRev2 [1.0, 1.0] [0.5, infinity] [entire] = [entire]; // x finishes [0, 1], z metBy [0, 1] powRev2 [0.25, 1.0] [1.0, 2.0] [entire] = [entire]; powRev2 [1.0, 1.0] [1.0, 2.0] [entire] = [entire]; powRev2 [0.25, 1.0] [1.0, infinity] [entire] = [entire]; powRev2 [1.0, 1.0] [1.0, infinity] [entire] = [entire]; // x finishes [0, 1], z after [0, 1] powRev2 [0.25, 1.0] [2.0, 4.0] [entire] = [-infinity, -0.5]; powRev2 [1.0, 1.0] [2.0, 4.0] [entire] = [empty]; powRev2 [0.25, 1.0] [2.0, infinity] [entire] = [-infinity, 0.0]; powRev2 [1.0, 1.0] [2.0, infinity] [entire] = [empty]; // x equals/finishedBy [0, 1], z overlaps/starts [0, 1] powRev2 [0.0, 1.0] [0.0, 0.5] [entire] = [0.0, infinity]; powRev2 [0.0, 1.0] [0.0, 0.5] [-infinity, 0.0] = [empty]; powRev2 [0.0, 1.0] [0.0, 0.5] [0.0, infinity] = [0.0, infinity]; // x equals/finishedBy [0, 1], z containedBy [0, 1] powRev2 [0.0, 1.0] [0.25, 0.5] [entire] = [0.0, infinity]; powRev2 [0.0, 1.0] [0.25, 0.5] [-infinity, 0.0] = [empty]; powRev2 [0.0, 1.0] [0.25, 0.5] [0.0, infinity] = [0.0, infinity]; // x equals/finishedBy [0, 1], z finishes [0, 1] powRev2 [0.0, 1.0] [0.5, 1.0] [entire] = [entire]; powRev2 [0.0, 1.0] [1.0, 1.0] [entire] = [entire]; powRev2 [0.0, 1.0] [0.5, 1.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, 1.0] [1.0, 1.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, 1.0] [0.5, 1.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.0, 1.0] [1.0, 1.0] [0.0, infinity] = [0.0, infinity]; // x equals/finishedBy [0, 1], z equals/finishedBy [0, 1] powRev2 [0.0, 1.0] [0.0, 1.0] [entire] = [entire]; powRev2 [0.0, 1.0] [0.0, 1.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, 1.0] [0.0, 1.0] [0.0, infinity] = [0.0, infinity]; // x equals/finishedBy [0, 1], z contains/startedBy [0, 1] powRev2 [0.0, 1.0] [0.0, 2.0] [entire] = [entire]; powRev2 [0.0, 1.0] [0.0, 2.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, 1.0] [0.0, 2.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.0, 1.0] [0.0, infinity] [entire] = [entire]; powRev2 [0.0, 1.0] [0.0, infinity] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, 1.0] [0.0, infinity] [0.0, infinity] = [0.0, infinity]; // x equals/finishedBy [0, 1], z overlappedBy [0, 1] powRev2 [0.0, 1.0] [0.5, 2.0] [entire] = [entire]; powRev2 [0.0, 1.0] [0.5, 2.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, 1.0] [0.5, 2.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.0, 1.0] [0.5, infinity] [entire] = [entire]; powRev2 [0.0, 1.0] [0.5, infinity] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, 1.0] [0.5, infinity] [0.0, infinity] = [0.0, infinity]; // x equals/finishedBy [0, 1], z metBy [0, 1] powRev2 [0.0, 1.0] [1.0, 2.0] [entire] = [entire]; powRev2 [0.0, 1.0] [1.0, 2.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, 1.0] [1.0, 2.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.0, 1.0] [1.0, infinity] [entire] = [entire]; powRev2 [0.0, 1.0] [1.0, infinity] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, 1.0] [1.0, infinity] [0.0, infinity] = [0.0, infinity]; // x equals/finishedBy [0, 1], z after [0, 1] powRev2 [0.0, 1.0] [2.0, 4.0] [entire] = [-infinity, 0.0]; powRev2 [0.0, 1.0] [2.0, 4.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, 1.0] [2.0, 4.0] [0.0, infinity] = [empty]; powRev2 [0.0, 1.0] [2.0, infinity] [entire] = [-infinity, 0.0]; powRev2 [0.0, 1.0] [2.0, infinity] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, 1.0] [2.0, infinity] [0.0, infinity] = [empty]; // x contains/startedBy [0, 1], z overlaps/starts [0, 1] powRev2 [0.0, 2.0] [0.0, 0.5] [entire] = [entire]; powRev2 [0.0, 2.0] [0.0, 0.5] [-infinity, 0.0] = [-infinity, -1.0]; powRev2 [0.0, 2.0] [0.0, 0.5] [0.0, infinity] = [0.0, infinity]; powRev2 [0.0, infinity] [0.0, 0.5] [entire] = [entire]; powRev2 [0.0, infinity] [0.0, 0.5] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, infinity] [0.0, 0.5] [0.0, infinity] = [0.0, infinity]; // x contains/startedBy [0, 1], z containedBy [0, 1] powRev2 [0.0, 2.0] [0.25, 0.5] [entire] = [entire]; powRev2 [0.0, 2.0] [0.25, 0.5] [-infinity, 0.0] = [-infinity, -1.0]; powRev2 [0.0, 2.0] [0.25, 0.5] [0.0, infinity] = [0.0, infinity]; powRev2 [0.0, infinity] [0.25, 0.5] [entire] = [entire]; powRev2 [0.0, infinity] [0.25, 0.5] [-infinity, 0.0] = [-infinity, -0.0]; powRev2 [0.0, infinity] [0.25, 0.5] [0.0, infinity] = [0.0, infinity]; // x contains/startedBy [0, 1], z finishes [0, 1] powRev2 [0.0, 2.0] [0.5, 1.0] [entire] = [entire]; powRev2 [0.0, 2.0] [1.0, 1.0] [entire] = [entire]; powRev2 [0.0, 2.0] [0.5, 1.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, 2.0] [1.0, 1.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, 2.0] [0.5, 1.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.0, 2.0] [1.0, 1.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.0, infinity] [0.5, 1.0] [entire] = [entire]; powRev2 [0.0, infinity] [1.0, 1.0] [entire] = [entire]; powRev2 [0.0, infinity] [0.5, 1.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, infinity] [1.0, 1.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, infinity] [0.5, 1.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.0, infinity] [1.0, 1.0] [0.0, infinity] = [0.0, infinity]; // x contains/startedBy [0, 1], z equals/finishedBy [0, 1] powRev2 [0.0, 2.0] [0.0, 1.0] [entire] = [entire]; powRev2 [0.0, 2.0] [0.0, 1.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, 2.0] [0.0, 1.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.0, infinity] [0.0, 1.0] [entire] = [entire]; powRev2 [0.0, infinity] [0.0, 1.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, infinity] [0.0, 1.0] [0.0, infinity] = [0.0, infinity]; // x contains/startedBy [0, 1], z contains/startedBy [0, 1] powRev2 [0.0, 2.0] [0.0, 2.0] [entire] = [entire]; powRev2 [0.0, 2.0] [0.0, 2.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, 2.0] [0.0, 2.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.0, infinity] [0.0, 2.0] [entire] = [entire]; powRev2 [0.0, infinity] [0.0, 2.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, infinity] [0.0, 2.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.0, 2.0] [0.0, infinity] [entire] = [entire]; powRev2 [0.0, 2.0] [0.0, infinity] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, 2.0] [0.0, infinity] [0.0, infinity] = [0.0, infinity]; powRev2 [0.0, infinity] [0.0, infinity] [entire] = [entire]; powRev2 [0.0, infinity] [0.0, infinity] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, infinity] [0.0, infinity] [0.0, infinity] = [0.0, infinity]; // x contains/startedBy [0, 1], z overlappedBy [0, 1] powRev2 [0.0, 2.0] [0.5, 2.0] [entire] = [entire]; powRev2 [0.0, 2.0] [0.5, 2.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, 2.0] [0.5, 2.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.0, infinity] [0.5, 2.0] [entire] = [entire]; powRev2 [0.0, infinity] [0.5, 2.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, infinity] [0.5, 2.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.0, 2.0] [0.5, infinity] [entire] = [entire]; powRev2 [0.0, 2.0] [0.5, infinity] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, 2.0] [0.5, infinity] [0.0, infinity] = [0.0, infinity]; powRev2 [0.0, infinity] [0.5, infinity] [entire] = [entire]; powRev2 [0.0, infinity] [0.5, infinity] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, infinity] [0.5, infinity] [0.0, infinity] = [0.0, infinity]; // x contains/startedBy [0, 1], z metBy [0, 1] powRev2 [0.0, 2.0] [1.0, 2.0] [entire] = [entire]; powRev2 [0.0, 2.0] [1.0, 2.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, 2.0] [1.0, 2.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.0, infinity] [1.0, 2.0] [entire] = [entire]; powRev2 [0.0, infinity] [1.0, 2.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, infinity] [1.0, 2.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.0, 2.0] [1.0, infinity] [entire] = [entire]; powRev2 [0.0, 2.0] [1.0, infinity] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, 2.0] [1.0, infinity] [0.0, infinity] = [0.0, infinity]; powRev2 [0.0, infinity] [1.0, infinity] [entire] = [entire]; powRev2 [0.0, infinity] [1.0, infinity] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, infinity] [1.0, infinity] [0.0, infinity] = [0.0, infinity]; // x contains/startedBy [0, 1], z after [0, 1] powRev2 [0.0, 2.0] [2.0, 4.0] [entire] = [entire]; powRev2 [0.0, 2.0] [2.0, 4.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, 2.0] [2.0, 4.0] [0.0, infinity] = [1.0, infinity]; powRev2 [0.0, infinity] [2.0, 4.0] [entire] = [entire]; powRev2 [0.0, infinity] [2.0, 4.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, infinity] [2.0, 4.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.0, 2.0] [2.0, infinity] [entire] = [entire]; powRev2 [0.0, 2.0] [2.0, infinity] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, 2.0] [2.0, infinity] [0.0, infinity] = [1.0, infinity]; powRev2 [0.0, infinity] [2.0, infinity] [entire] = [entire]; powRev2 [0.0, infinity] [2.0, infinity] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.0, infinity] [2.0, infinity] [0.0, infinity] = [0.0, infinity]; // x overlappedBy [0, 1], z overlaps/starts [0, 1] powRev2 [0.5, 2.0] [0.0, 0.5] [entire] = [entire]; powRev2 [0.5, 2.0] [0.0, 0.5] [-infinity, 0.0] = [-infinity, -1.0]; powRev2 [0.5, 2.0] [0.0, 0.5] [0.0, infinity] = [1.0, infinity]; powRev2 [0.5, infinity] [0.0, 0.5] [entire] = [entire]; powRev2 [0.5, infinity] [0.0, 0.5] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.5, infinity] [0.0, 0.5] [0.0, infinity] = [1.0, infinity]; // x overlappedBy [0, 1], z containedBy [0, 1] powRev2 [0.5, 2.0] [0.25, 0.5] [entire] = [entire]; powRev2 [0.5, 2.0] [0.25, 0.5] [-infinity, 0.0] = [-infinity, -1.0]; powRev2 [0.5, 2.0] [0.25, 0.5] [0.0, infinity] = [1.0, infinity]; powRev2 [0.5, infinity] [0.25, 0.5] [entire] = [entire]; powRev2 [0.5, infinity] [0.25, 0.5] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.5, infinity] [0.25, 0.5] [0.0, infinity] = [1.0, infinity]; // x overlappedBy [0, 1], z finishes [0, 1] powRev2 [0.5, 2.0] [0.5, 1.0] [entire] = [entire]; powRev2 [0.5, 2.0] [1.0, 1.0] [entire] = [entire]; powRev2 [0.5, 2.0] [0.5, 1.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.5, 2.0] [1.0, 1.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.5, 2.0] [0.5, 1.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.5, 2.0] [1.0, 1.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.5, infinity] [0.5, 1.0] [entire] = [entire]; powRev2 [0.5, infinity] [1.0, 1.0] [entire] = [entire]; powRev2 [0.5, infinity] [0.5, 1.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.5, infinity] [1.0, 1.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.5, infinity] [0.5, 1.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.5, infinity] [1.0, 1.0] [0.0, infinity] = [0.0, infinity]; // x overlappedBy [0, 1], z equals/finishedBy [0, 1] powRev2 [0.5, 2.0] [0.0, 1.0] [entire] = [entire]; powRev2 [0.5, 2.0] [0.0, 1.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.5, 2.0] [0.0, 1.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.5, infinity] [0.0, 1.0] [entire] = [entire]; powRev2 [0.5, infinity] [0.0, 1.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.5, infinity] [0.0, 1.0] [0.0, infinity] = [0.0, infinity]; // x overlappedBy [0, 1], z contains/startedBy [0, 1] powRev2 [0.5, 2.0] [0.0, 2.0] [entire] = [entire]; powRev2 [0.5, 2.0] [0.0, 2.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.5, 2.0] [0.0, 2.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.5, infinity] [0.0, 2.0] [entire] = [entire]; powRev2 [0.5, infinity] [0.0, 2.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.5, infinity] [0.0, 2.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.5, 2.0] [0.0, infinity] [entire] = [entire]; powRev2 [0.5, 2.0] [0.0, infinity] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.5, 2.0] [0.0, infinity] [0.0, infinity] = [0.0, infinity]; powRev2 [0.5, infinity] [0.0, infinity] [entire] = [entire]; powRev2 [0.5, infinity] [0.0, infinity] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.5, infinity] [0.0, infinity] [0.0, infinity] = [0.0, infinity]; // x overlappedBy [0, 1], z overlappedBy [0, 1] powRev2 [0.5, 2.0] [0.5, 2.0] [entire] = [entire]; powRev2 [0.5, 2.0] [0.5, 2.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.5, 2.0] [0.5, 2.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.5, infinity] [0.5, 2.0] [entire] = [entire]; powRev2 [0.5, infinity] [0.5, 2.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.5, infinity] [0.5, 2.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.5, 2.0] [0.5, infinity] [entire] = [entire]; powRev2 [0.5, 2.0] [0.5, infinity] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.5, 2.0] [0.5, infinity] [0.0, infinity] = [0.0, infinity]; powRev2 [0.5, infinity] [0.5, infinity] [entire] = [entire]; powRev2 [0.5, infinity] [0.5, infinity] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.5, infinity] [0.5, infinity] [0.0, infinity] = [0.0, infinity]; // x overlappedBy [0, 1], z metBy [0, 1] powRev2 [0.5, 2.0] [1.0, 2.0] [entire] = [entire]; powRev2 [0.5, 2.0] [1.0, 2.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.5, 2.0] [1.0, 2.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.5, infinity] [1.0, 2.0] [entire] = [entire]; powRev2 [0.5, infinity] [1.0, 2.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.5, infinity] [1.0, 2.0] [0.0, infinity] = [0.0, infinity]; powRev2 [0.5, 2.0] [1.0, infinity] [entire] = [entire]; powRev2 [0.5, 2.0] [1.0, infinity] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.5, 2.0] [1.0, infinity] [0.0, infinity] = [0.0, infinity]; powRev2 [0.5, infinity] [1.0, infinity] [entire] = [entire]; powRev2 [0.5, infinity] [1.0, infinity] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [0.5, infinity] [1.0, infinity] [0.0, infinity] = [0.0, infinity]; // x overlappedBy [0, 1], z after [0, 1] powRev2 [0.5, 2.0] [2.0, 4.0] [entire] = [entire]; powRev2 [0.5, 2.0] [2.0, 4.0] [-infinity, 0.0] = [-infinity, -1.0]; powRev2 [0.5, 2.0] [2.0, 4.0] [0.0, infinity] = [1.0, infinity]; powRev2 [0.5, infinity] [2.0, 4.0] [entire] = [entire]; powRev2 [0.5, infinity] [2.0, 4.0] [-infinity, 0.0] = [-infinity, -1.0]; powRev2 [0.5, infinity] [2.0, 4.0] [0.0, infinity] = [0.0, infinity]; // x metBy [0, 1], z overlaps/starts [0, 1] powRev2 [1.0, 2.0] [0.0, 0.5] [entire] = [-infinity, -1.0]; powRev2 [1.0, 2.0] [0.0, 0.5] [-infinity, 0.0] = [-infinity, -1.0]; powRev2 [1.0, 2.0] [0.0, 0.5] [0.0, infinity] = [empty]; powRev2 [1.0, infinity] [0.0, 0.5] [entire] = [-infinity, 0.0]; powRev2 [1.0, infinity] [0.0, 0.5] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [1.0, infinity] [0.0, 0.5] [0.0, infinity] = [empty]; // x metBy [0, 1], z containedBy [0, 1] powRev2 [1.0, 2.0] [0.25, 0.5] [entire] = [-infinity, -1.0]; powRev2 [1.0, 2.0] [0.25, 0.5] [-infinity, 0.0] = [-infinity, -1.0]; powRev2 [1.0, 2.0] [0.25, 0.5] [0.0, infinity] = [empty]; powRev2 [1.0, infinity] [0.25, 0.5] [entire] = [-infinity, 0.0]; powRev2 [1.0, infinity] [0.25, 0.5] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [1.0, infinity] [0.25, 0.5] [0.0, infinity] = [empty]; // x metBy [0, 1], z finishes [0, 1] powRev2 [1.0, 2.0] [0.5, 1.0] [entire] = [entire]; powRev2 [1.0, 2.0] [1.0, 1.0] [entire] = [entire]; powRev2 [1.0, 2.0] [0.5, 1.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [1.0, 2.0] [1.0, 1.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [1.0, 2.0] [0.5, 1.0] [0.0, infinity] = [0.0, infinity]; powRev2 [1.0, 2.0] [1.0, 1.0] [0.0, infinity] = [0.0, infinity]; powRev2 [1.0, infinity] [0.5, 1.0] [entire] = [entire]; powRev2 [1.0, infinity] [1.0, 1.0] [entire] = [entire]; powRev2 [1.0, infinity] [0.5, 1.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [1.0, infinity] [1.0, 1.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [1.0, infinity] [0.5, 1.0] [0.0, infinity] = [0.0, infinity]; powRev2 [1.0, infinity] [1.0, 1.0] [0.0, infinity] = [0.0, infinity]; // x metBy [0, 1], z equals/finishedBy [0, 1] powRev2 [1.0, 2.0] [0.0, 1.0] [entire] = [entire]; powRev2 [1.0, 2.0] [0.0, 1.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [1.0, 2.0] [0.0, 1.0] [0.0, infinity] = [0.0, infinity]; powRev2 [1.0, infinity] [0.0, 1.0] [entire] = [entire]; powRev2 [1.0, infinity] [0.0, 1.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [1.0, infinity] [0.0, 1.0] [0.0, infinity] = [0.0, infinity]; // x metBy [0, 1], z contains/startedBy [0, 1] powRev2 [1.0, 2.0] [0.0, 2.0] [entire] = [entire]; powRev2 [1.0, 2.0] [0.0, 2.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [1.0, 2.0] [0.0, 2.0] [0.0, infinity] = [0.0, infinity]; powRev2 [1.0, infinity] [0.0, 2.0] [entire] = [entire]; powRev2 [1.0, infinity] [0.0, 2.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [1.0, infinity] [0.0, 2.0] [0.0, infinity] = [0.0, infinity]; powRev2 [1.0, 2.0] [0.0, infinity] [entire] = [entire]; powRev2 [1.0, 2.0] [0.0, infinity] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [1.0, 2.0] [0.0, infinity] [0.0, infinity] = [0.0, infinity]; powRev2 [1.0, infinity] [0.0, infinity] [entire] = [entire]; powRev2 [1.0, infinity] [0.0, infinity] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [1.0, infinity] [0.0, infinity] [0.0, infinity] = [0.0, infinity]; // x metBy [0, 1], z overlappedBy [0, 1] powRev2 [1.0, 2.0] [0.5, 2.0] [entire] = [entire]; powRev2 [1.0, 2.0] [0.5, 2.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [1.0, 2.0] [0.5, 2.0] [0.0, infinity] = [0.0, infinity]; powRev2 [1.0, infinity] [0.5, 2.0] [entire] = [entire]; powRev2 [1.0, infinity] [0.5, 2.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [1.0, infinity] [0.5, 2.0] [0.0, infinity] = [0.0, infinity]; powRev2 [1.0, 2.0] [0.5, infinity] [entire] = [entire]; powRev2 [1.0, 2.0] [0.5, infinity] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [1.0, 2.0] [0.5, infinity] [0.0, infinity] = [0.0, infinity]; powRev2 [1.0, infinity] [0.5, infinity] [entire] = [entire]; powRev2 [1.0, infinity] [0.5, infinity] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [1.0, infinity] [0.5, infinity] [0.0, infinity] = [0.0, infinity]; // x metBy [0, 1], z metBy [0, 1] powRev2 [1.0, 2.0] [1.0, 2.0] [entire] = [entire]; powRev2 [1.0, 2.0] [1.0, infinity] [entire] = [entire]; powRev2 [1.0, infinity] [1.0, infinity] [entire] = [entire]; powRev2 [1.0, infinity] [1.0, 2.0] [entire] = [entire]; powRev2 [1.0, 2.0] [1.0, 2.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [1.0, infinity] [1.0, 2.0] [-infinity, 0.0] = [-infinity, 0.0]; powRev2 [1.0, 2.0] [1.0, 2.0] [0.0, infinity] = [0.0, infinity]; powRev2 [1.0, infinity] [1.0, 2.0] [0.0, infinity] = [0.0, infinity]; // x metBy [0, 1], z after [0, 1] powRev2 [1.0, 2.0] [2.0, 4.0] [entire] = [1.0, infinity]; powRev2 [1.0, infinity] [2.0, 4.0] [entire] = [0.0, infinity]; powRev2 [1.0, 2.0] [2.0, 4.0] [-infinity, 0.0] = [empty]; powRev2 [1.0, infinity] [2.0, 4.0] [-infinity, 0.0] = [empty]; powRev2 [1.0, 2.0] [2.0, 4.0] [0.0, infinity] = [1.0, infinity]; powRev2 [1.0, infinity] [2.0, 4.0] [0.0, infinity] = [0.0, infinity]; // x after [0, 1], z overlaps/starts [0, 1] powRev2 [2.0, 4.0] [0.0, 0.5] [entire] = [-infinity, -0.5]; powRev2 [2.0, infinity] [0.0, 0.5] [entire] = [-infinity, 0.0]; powRev2 [2.0, infinity] [0.0, 0.5] [0.0, infinity] = [empty]; // x after [0, 1], z containedBy [0, 1] powRev2 [2.0, 4.0] [0.25, 0.5] [entire] = [-2.0, -0.5]; powRev2 [2.0, infinity] [0.25, 0.5] [entire] = [-2.0, 0.0]; powRev2 [2.0, infinity] [0.25, 0.5] [0.0, infinity] = [empty]; // x after [0, 1], z finishes [0, 1] powRev2 [2.0, 4.0] [0.5, 1.0] [entire] = [-1.0, 0.0]; powRev2 [2.0, infinity] [0.5, 1.0] [entire] = [-1.0, 0.0]; powRev2 [2.0, 4.0] [1.0, 1.0] [entire] = [0.0, 0.0]; powRev2 [2.0, infinity] [1.0, 1.0] [entire] = [0.0, 0.0]; // x after [0, 1], z equals/finishedBy [0, 1] powRev2 [2.0, 4.0] [0.0, 1.0] [entire] = [-infinity, 0.0]; powRev2 [2.0, infinity] [0.0, 1.0] [entire] = [-infinity, 0.0]; powRev2 [2.0, 4.0] [0.0, 1.0] [0.0, infinity] = [0.0, 0.0]; powRev2 [2.0, infinity] [0.0, 1.0] [0.0, infinity] = [0.0, 0.0]; // x after [0, 1], z contains/startedBy [0, 1] powRev2 [2.0, 4.0] [0.0, 2.0] [entire] = [-infinity, 1.0]; powRev2 [2.0, infinity] [0.0, 2.0] [entire] = [-infinity, 1.0]; // x after [0, 1], z overlappedBy [0, 1] powRev2 [2.0, 4.0] [0.5, 2.0] [entire] = [-1.0, 1.0]; powRev2 [2.0, infinity] [0.5, 2.0] [entire] = [-1.0, 1.0]; // x after [0, 1], z metBy [0, 1] powRev2 [2.0, 4.0] [1.0, 2.0] [entire] = [0.0, 1.0]; powRev2 [2.0, infinity] [1.0, 2.0] [entire] = [0.0, 1.0]; powRev2 [2.0, 4.0] [1.0, 2.0] [-infinity, 0.0] = [0.0, 0.0]; powRev2 [2.0, infinity] [1.0, 2.0] [-infinity, 0.0] = [0.0, 0.0]; // x after [0, 1], z after [0, 1] powRev2 [2.0, 4.0] [2.0, 4.0] [entire] = [0.5, 2.0]; powRev2 [2.0, infinity] [2.0, 4.0] [entire] = [0.0, 2.0]; powRev2 [2.0, infinity] [2.0, 4.0] [-infinity, 0.0] = [empty]; powRev2 [2.0, 4.0] [2.0, infinity] [entire] = [0.5, infinity]; powRev2 [2.0, infinity] [2.0, infinity] [entire] = [0.0, infinity]; powRev2 [2.0, infinity] [2.0, infinity] [-infinity, 0.0] = [empty]; } interval-1.4.1/CITATION0000644000175000017500000000101112657476042014066 0ustar oliveroliverThe interval package is a collection of functions for interval arithmetic. It is developed at Octave Forge, a sibling of the GNU Octave project. To cite this particular version of the interval package in publications use: @software{octave-interval, author = {Oliver Heimlich}, title = {GNU Octave Interval Package}, url = {http://octave.sourceforge.net/interval/}, version = {1.4.1}, date = {2016-02-13}, } See also ‘citation’ for citing Octave as a whole. interval-1.4.1/COPYING0000644000175000017500000011314612657476042014001 0ustar oliveroliverThe interval package is free software and can be used under the terms of the GNU General Public License Version 3 (or at your option any later version). The wording of the license can be found below. The interval package contains derivative work, which is based on other free software released under various licenses. Original authors are properly attributed in the manual and copyright statements have been retained in the particular source files. For simplicity, any derivative work has been relicensed in this package. Thus, the GPLv3+ is the only effective license for the software in this package. For legal reasons a copy of the Apache License 2.0 is included in this package. You can find the license in the file ‘doc/license/apache-2.0.texi’. However, that license does not apply to the software in this package. The GNU General Public License. Version 3, 29 June 2007 Copyright © 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble ======== The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program—to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers’ and authors’ protection, the GPL clearly explains that there is no warranty for this free software. For both users’ and authors’ sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users’ freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS ==================== 0. Definitions. “This License” refers to version 3 of the GNU General Public License. “Copyright” also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. “The Program” refers to any copyrightable work licensed under this License. Each licensee is addressed as “you”. “Licensees” and “recipients” may be individuals or organizations. To “modify” a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a “modified version” of the earlier work or a work “based on” the earlier work. A “covered work” means either the unmodified Program or a work based on the Program. To “propagate” a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To “convey” a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays “Appropriate Legal Notices” to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The “source code” for a work means the preferred form of the work for making modifications to it. “Object code” means any non-source form of a work. A “Standard Interface” means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The “System Libraries” of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A “Major Component”, in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The “Corresponding Source” for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work’s System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users’ Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work’s users, your or third parties’ legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program’s source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a. The work must carry prominent notices stating that you modified it, and giving a relevant date. b. The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to “keep intact all notices”. c. You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d. If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an “aggregate” if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation’s users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a. Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b. Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c. Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d. Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e. Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A “User Product” is either (1) a “consumer product”, which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, “normally used” refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. “Installation Information” for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. “Additional permissions” are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a. Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b. Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c. Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d. Limiting the use for publicity purposes of names of licensors or authors of the material; or e. Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f. Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered “further restrictions” within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An “entity transaction” is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party’s predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A “contributor” is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor’s “contributor version”. A contributor’s “essential patent claims” are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, “control” includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor’s essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a “patent license” is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To “grant” such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. “Knowingly relying” means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient’s use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is “discriminatory” if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others’ Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License “or any later version” applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy’s public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS =========================== How to Apply These Terms to Your New Programs ============================================= If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the “copyright” line and a pointer to where the full notice is found. ONE LINE TO GIVE THE PROGRAM'S NAME AND A BRIEF IDEA OF WHAT IT DOES. Copyright (C) YEAR NAME OF AUTHOR This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: PROGRAM Copyright (C) YEAR NAME OF AUTHOR This program comes with ABSOLUTELY NO WARRANTY; for details type ‘show w’. This is free software, and you are welcome to redistribute it under certain conditions; type ‘show c’ for details. The hypothetical commands ‘show w’ and ‘show c’ should show the appropriate parts of the General Public License. Of course, your program’s commands might be different; for a GUI interface, you would use an “about box”. You should also get your employer (if you work as a programmer) or school, if any, to sign a “copyright disclaimer” for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . interval-1.4.1/NEWS0000644000175000017500000003060412657476043013443 0ustar oliveroliver GNU Octave Interval Package Summary of important user-visible changes Version 1.4.1 2016-02-13 ======================== • Fixed a compile error for 32-bit systems during package installation (bug #47100) Version 1.4.0 2016-02-09 ======================== • mpower: Improved accuracy and speed. The interval matrix square can now be computed without dependency errors and with tightest accuracy. • factorial: New interval arithmetic operation • expm, norm: New interval matrix operations • The functions recip and sqr have been deprecated and will be removed in a future release. Please use ‘1 ./ X’ and ‘X .^ 2’ instead. Bugfixes • bitunpack, interval_bitpack: The order of inf/sup/dec parts has been fixed. The function documentation describes how the functions behave on little-endian and big-endian systems. Version 1.3.0 2015-12-22 ======================== • postpad, prepad, subsasgn: Implicit new elements during subscript assignment and padding have been initialized with empty intervals before this release. This behavior has changed. Now, the implicit new element are initialized with zero to make a correct interval extension of the corresponding built-in function. • fsolve: New function to solve (systems of) equations and compute the inverse of a set under a function • ctc_intersect, ctc_union: Utility functions for contractors and the fsolve function • det, prod, recip: New interval arithmetic functions • diag: New utility function to create diagonal matrices or extract vectors from diagonals of matrices • decorationpart: Choose between different return types with a second parameter • For several functions it is now possible to broadcast row vectors against column vectors or vectors against matrices. • The user manual has been restructured for better accessibility by new users. A bunch of usage examples demonstrates the package’s capabilities. Bugfixes • sum, sumabs, sumsq: Fixed result for matrices of size zero • powrev1, powrev2: Fixed indexing for vectors Version 1.2.0 2015-10-01 ======================== • The output format for intervals has been changed. The number of decimal places now respects what has been set by the user with the ‘format short’ or ‘format long’ command, and is much shorter by default. Also it is possible to use ‘format hex’. The old format can be accessed with the ‘intervaltotext’ function. • fminsearch: New optimizer function for finding the minimum value of a function over interval constraints using the Skelboe-Moore algorithm • fzero: Changed function parameters to support optimset options • power: Improved speed of the general interval power function and monomials with the notation x .^ n • plot, plot3: Added support for colormaps Bugfixes • mldivide: Fixed algorithm to handle more matrices without error • bisect: Fixed an error during bisection of singleton intervals (thanks to Helmut for finding this during OctConf 2015) Version 1.1.0 2015-08-03 ======================== • meshgrid, mince: New utility functions to help plotting of interval functions • linspace: New interval arithmetic function • intersect, max, min, union: Allow evaluation as aggregate functions within an interval matrix along a common dimension • Improvements to the documentation • Added cross-references between package documentation and function reference • Extended information about interval arithmetic in general • Extended information about implemented IEEE Std 1788-2015 functions and fixed references to the standard document • Added information about plotting intervals • Simplified package description • Graphics with higher resolutions, demo of interval sombrero function plot on first page, and minor style fixes Bugfixes • plot3: Fixed plotting of interval edges when plotting several intervals at once using matrices Version 1.0.0 2015-06-13 ======================== • IEEE Std 1788-2015, IEEE standard for interval arithmetic, was approved on June 11. To mark the occasion, the major version number has been raised. • All interval constructors have been extended to create interval matrices from a single string. Commas or spaces may be used as a column separator (consecutive separators are trimmed). Semicolon and new line characters can be used as a row separator. • hdist, idist, sdist, smig: New interval numeric functions • User manual: Relicensed under GPL, added examples from the former Octave SIMP package, and various minor improvements. Bugfixes • mtimes: Fixed matrix-vector multiplication of decorated intervals • Fixed a linking error in mkoctfile that could prevent package installation (bug #45280) Version 0.2.1 2015-05-30 ======================== • plot, plot3: New interval plotting functions. Pay attention to the included examples, which can be executed with ‘demo @infsup/plot’ and ‘demo @infsup/plot3’ respectively. • polyval: New interval arithmetic algorithm • bisect: New set operation for bisecting algorithms • sinrev, cosrev, tanrev, atan2rev1, atan2rev2: Now allow non-scalar arguments • Simplified licensing: Relicensed parts of the software that were not under GPL • Updated information for citation of the package Bugfixes • Fixed generation of the manual in PDF format • subsasgn: Fixed cases where decoration could be lost (bug #42735) Version 0.2.0 2015-05-03 ======================== • User manual included in the package, see doc/manual.texinfo • New utility functions: cat, postpad, prepad, reshape, resize • and, or: Removed deprecated functions • Improved display output for cell arrays and new function: disp • Minor performance improvements (all decorated interval functions, horzcat, vertcat) Bugfixes • issquare, isrow, iscolumn: Fixed compatibility issues with GNU Octave 4.0 • cbrt: Allow negative values as parameter • cot: Fixed accuracy for x = 0 • cos, csc, sec, sin: Fixed correctness in certain cases • Prevent multibyte characters in Microsoft Windows console Version 0.1.5 2015-04-06 ======================== • Implicit decoration of bare intervals triggers a warning now and can be allowed or forbidden by the user. Implicit decoration of bare interval literals is not affected. • newdec: New operation for explicit promotion of bare intervals into decorated intervals (without warning). • Decorated interval literals with illegal decoration are no longer allowed and produce NaIs. • hull: In contrast to the union function, the interval constructor is no longer considered a set operation and can create intervals with a non-trivial decoration. • setdiff, setxor: New set operations • intersect, union: Renamed set operations; the old function names (and, or) are hereby deprecated and are going to be removed in the next release. • intervaltotext, intervaltoexact: Decimal fractions no longer omit zero before the point, and unnecessary trailing decimal places can be omitted more consistently and in more cases than before (also affects console output). Improved accuracy and performance with support for interval matrices. Bugfixes • mtimes, mldivide: Support for broadcasting of scalar parameters • nextout: Support for decorated intervals • An error in GNU Octave core, which could lead to lost or wrong interval decorations, no longer affects decorated intervals (bug #42735) • Some errors in the function documentation have been fixed (thanks to doctest-for-matlab and Colin’s texinfo compatibility patches) • Fixed interval field access on Windows Version 0.1.4 2015-03-15 ======================== • New interval constructors: hull, midrad • New interval arithmetic functions: cbrt, cot, coth, csc, csch, dilog, ei, erf, erfc, gamma, gammaln, psi, rsqrt, sec, sech • mtimes: Support for fast, less accurate evaluation using BLAS routines • mldivide, mrdivide, inv: Improved performance by using faster mtimes • infsup, infsupdec: Enabled broadcasting of scalar boundaries • rad: May compute mid and rad simultaneously • subsref: Access to interval properties using field syntax: x.inf and x.sup Version 0.1.3 2015-02-24 ======================== • Fixed a compile error that could possibly occur during package installation Version 0.1.2 2015-02-22 ======================== • New interval arithmetic functions: nthroot, hypot, log1p, expm1 • lu: New operation for LU(P) decomposition of interval matrices • nai: New decorated interval constant • mldivide, mrdivide, inv: Greatly improved accuracy and performance of the linear solver • Improved accuracy of vector sums, dot products, pownrev, and powrev2 • powrev1, powrev2, pownrev, mulrev: Now allow non-scalar arguments • overlap: Renamed one overlapping state from equal to equals • mulrevtopair: No longer available, use mulrev with two output parameters for two-output division • setdec: No longer available, use infsupdec instead • Small performance improvements Bugfixes • Compatibility with GNU Octave 4.0 (bug #43925) • Build problems during package installation with environment variables • iscommoninterval: The decorated variant must return true for common intervals without com decoration • eq: The decorated variant must not consider the decoration value • Several decorated functions: When evaluated on a subset of the function’s domain, the result’s decoration must be dac if the function’s restriction to that subset is continuous • Decorated boolean functions: Must return false when evaluated on NaI input • Interval constructors: A PossibleUndefined warning must be issued if an interval is created from two very close decimal numbers (which can not be separated in the floating-point context) where the lower boundary is greater than the upper boundary when compared with infinite precision • Interval constructors: NaNs must produce empty intervals • Decorated interval constructor: Illegal decorations for empty intervals must be adjusted to trv, and illegal decoration com for unbounded intervals must be adjusted to dac. • cancelminus/cancelplus: The functions returned wrong results if the interval widths could not be compared in double-precision • cos: Accuracy for x = [0] improved • pow, powrev1, powrev2: The function must be defined for x = 0 and y > 0 • All reverse operations: Must return a trivial decoration information at best (the only exception is mulrev) Version 0.1.1 2015-02-01 ======================== • Increased speed of computation for large matrices • Improved performance for fma and dot • mpfr_vector_dot_d: Changed syntax for faster computation on intervals • Decorated versions of mtimes, mldivide, mpower, inv and reduction operations sum, dot, subabs, subsquare • Renamed function sumsquare to sumsq in accordance with GNU Octave function names • New function: fzero for finding all roots of an interval arithmetic function Bugfixes • nextout: Function returned wrong results • exacttointerval: Now produces bare intervals instead of decorated intervals in conformance with IEEE P1788 • atanh: Function returned wrong results for ±1 • dot: Function returned wrong results for some inputs • fma: Function returned wrong results for some inputs • infsup: Function returned wrong interval boundaries for decimal numbers, function failed on mixed numerical and string boundaries in single cell array parameter • mulrevtopair: Fixed order of operands in conformance with IEEE P1788 and wrong results when evaluated on intervals that contain zero Version 0.1.0 2015-01-21 ======================== • Initial release version, which already contains all required operations of the preliminary standard document IEEE P1788. interval-1.4.1/doc/image/inverse-power.svg.eps0000644000175000017500000004656012657476043020717 0ustar oliveroliver%!PS-Adobe-3.0 EPSF-3.0 %%Creator: cairo 1.14.0 (http://cairographics.org) %%CreationDate: Sat Feb 13 01:43:15 2016 %%Pages: 1 %%DocumentData: Clean7Bit %%LanguageLevel: 2 %%BoundingBox: 0 -1 362 180 %%EndComments %%BeginProlog save 50 dict begin /q { gsave } bind def /Q { grestore } bind def /cm { 6 array astore concat } bind def /w { setlinewidth } bind def /J { setlinecap } bind def /j { setlinejoin } bind def /M { setmiterlimit } bind def /d { setdash } bind def /m { moveto } bind def /l { lineto } bind def /c { curveto } bind def /h { closepath } bind def /re { exch dup neg 3 1 roll 5 3 roll moveto 0 rlineto 0 exch rlineto 0 rlineto closepath } bind def /S { stroke } bind def /f { fill } bind def /f* { eofill } bind def /n { newpath } bind def /W { clip } bind def /W* { eoclip } bind def /BT { } bind def /ET { } bind def /pdfmark where { pop globaldict /?pdfmark /exec load put } { globaldict begin /?pdfmark /pop load def /pdfmark /cleartomark load def end } ifelse /BDC { mark 3 1 roll /BDC pdfmark } bind def /EMC { mark /EMC pdfmark } bind def /cairo_store_point { /cairo_point_y exch def /cairo_point_x exch def } def /Tj { show currentpoint cairo_store_point } bind def /TJ { { dup type /stringtype eq { show } { -0.001 mul 0 cairo_font_matrix dtransform rmoveto } ifelse } forall currentpoint cairo_store_point } bind def /cairo_selectfont { cairo_font_matrix aload pop pop pop 0 0 6 array astore cairo_font exch selectfont cairo_point_x cairo_point_y moveto } bind def /Tf { pop /cairo_font exch def /cairo_font_matrix where { pop cairo_selectfont } if } bind def /Td { matrix translate cairo_font_matrix matrix concatmatrix dup /cairo_font_matrix exch def dup 4 get exch 5 get cairo_store_point /cairo_font where { pop cairo_selectfont } if } bind def /Tm { 2 copy 8 2 roll 6 array astore /cairo_font_matrix exch def cairo_store_point /cairo_font where { pop cairo_selectfont } if } bind def /g { setgray } bind def /rg { setrgbcolor } bind def /d1 { setcachedevice } bind def %%EndProlog %%BeginSetup %%BeginResource: font Cmmi10 11 dict begin /FontType 42 def /FontName /Cmmi10 def /PaintType 0 def /FontMatrix [ 1 0 0 1 0 0 ] def /FontBBox [ 0 0 0 0 ] def /Encoding 256 array def 0 1 255 { Encoding exch /.notdef put } for Encoding 120 /x put Encoding 121 /y put /CharStrings 3 dict dup begin /.notdef 0 def /x 1 def /y 2 def end readonly def /sfnts [ <00010000000900800003001063767420721a75db00000338000001166670676d0211c2610000 0450000001d8676c7966d7fc9a800000009c0000029c68656164673348fc0000062800000036 686865610e1f03020000066000000024686d74780e7d0176000006840000000c6c6f63610000 047000000690000000106d61787000e500ca000006a00000002070726570566f2373000006c0 0000002600020100000005000500000300070022401b2b02060006042b0009000702048a0305 00058a0701000602090f032b31002b3021112111271121110100040021fc420500fb002104be fb4200000001003fffe9043503890057004c404352423d2c26151200080b37091f011c012e01 0b29190a0e08480102014b01372845091a07020448341c080429550942402c03582329010515 000258554f010602590f032b2b31002b2b30371633323637133635342623220e0107062b0122 3d013e02333216173e0133321e01151406232226353436372623220607030615141633323637 363b0132161514070e01232226270e0123222e01353436333216151406a024424062125d1639 3341724e10040c191014608b4f4b7919236d412c5c3a4334212c3b2925414261145a163b3160 9718040c19080a021dba754b79192071402c5d3a4332222e393b1c7b49016b6324334c517d40 0d13064c915a50453f561f4030344b2a202b41061d7a4bfe965235344ba9650c0b0702047abe 51453c5a1f4031304f29212b4000000000010037fe5c03f00389004c0042403b382f1d1a0414 2d0933011429200a0108060144012d28080914074a000202293d071007030436060212231202 411d000347016e2a0c1506014e10032b2b2b2b30131633323e01370623222e0135343e013736 353423220607062b01223d013e013332161514070e03151416333237133e0133321615140703 0e0223222e01353436333216151406232626ac2b6b618e57185b6a51723f2441181b2d516919 040d1811218868496511094022163a3f7f659b07321d192502cb1b90cb6e3568404237212d46 2f0204fedb4a88c16556386f4f438dad404b303da7670d13067abd604a262a19a86e6a35445e 9b02771b27201a0c04fcd169c075295237385229212f4601010000060008000e001f002d005e fe5cfe73ffd300000389038b057705a40110010400e100cf00be00a8009e009c009a00960093 0091008d0085007f006d00660064005c0052004e004a00480042003d003b0037003500330021 001f080a07f4071906d306c5069c05f805ec05d705d105cf05b605b40581057b05750550050e 04e304dd0489046003fe03f403e703cd03be038b036a03190277022f022701be0193013b011d 00e900e100df00cf00c900c700c500c300be00bc00ba00b800b600b200ae00ac00a800a600a4 00a0009e009c009a009800960093008f008d008b00890087008500830081007d007b00790075 00730071006d00660060005e00520050004c0048004600440042003f003d003b003700350021 000040161514131211100f0e0d0c0b0a090807060504030201002cb200800043208a628a2342 66562d2cb22a0000435478b0002b58173959b0002b58173c59b0002b58b00a2a59b0014310b0 002b58173c59b0002b58b00a2a592d2c2b2d2c2bb0022a2d2cb0022a2d2cb00162b0002342b1 01032542204620686164b0032546206820b0044323612064b140408a545821212121b100211c 5950582121b1000425204668b007254561b0005158211bb0054338591b6164595358232f23f9 1b2f23e959b0012b2d2cb00162b0002342b101032542204620686164b0032546206861645358 232f23f91b2f23e959b0012b2d2cb00162b0002342b1010525423fe9b0012b2d2cb00162b000 2342b1010325423ff9b0012b2d2c111217392d2cc12d2cb2000100432020b004438a45b00343 6169604460422d2c4520b0032342b201020543764323438a23616960b004234218b00b2a2d2c b0002342184569b0406120b000515821b0411bb04061b0005158b0461bb0485959b005234245 20b001234269b0022342b00c2a182d2c204568442d2cba00110005ffc0422b2d2cb211050042 2b2d2c2020b102038a4223b0016142466820b0405458b0406059b00423422d2cb10203431143 12173931002d2c2e2d2cc52d2c3fb0142a2d0001000000010000ae3916995f0f3cf500030800 00000000000000000000000000000000ffbafe00086206000000000600020001000000000001 00000600fe0000000800ffbafcfe086200010000000000000000000000000000000306000100 0491003f03ec0037000000000000004c000001880000029c0001000000030063000300000000 0002000c00060016000000bc005e00000001401c072903240521101c0429580e0d0f87116e0b 6833580458582d0d35008db8033c851d2b2b000000> ] def /f-0-0 currentdict end definefont pop %%EndResource %%BeginResource: font Cmr10 11 dict begin /FontType 42 def /FontName /Cmr10 def /PaintType 0 def /FontMatrix [ 1 0 0 1 0 0 ] def /FontBBox [ 0 0 0 0 ] def /Encoding 256 array def 0 1 255 { Encoding exch /.notdef put } for Encoding 45 /hyphen put Encoding 48 /zero put Encoding 49 /one put Encoding 50 /two put Encoding 65 /A put Encoding 66 /B put /CharStrings 7 dict dup begin /.notdef 0 def /A 1 def /B 2 def /hyphen 3 def /one 4 def /two 5 def /zero 6 def end readonly def /sfnts [ <000100000009008000030010637674204d184f4a00000450000000da6670676d0211c2610000 052c000001d8676c79660d8a2fb80000009c000003b46865616466cf48fc0000070400000036 686865610d5f06130000073c00000024686d747820540307000007600000001c6c6f63610000 0e0c0000077c000000206d61787000f600cb0000079c0000002070726570ef569262000007bc 0000002800020100000005000500000300070022401b2a02060006042a0009000702046c0305 00056c0701000602090f032b31002b3021112111271121110100040021fc420500fb002104be fb42000000020042000005bc05ba001c001f00314028221e1500061b100d030f01012200090a 0702041f071f1e1d1c181514131009310e01010501210f032b31002e2e2b303335323701363b 013217011e0133152135323d0103210306151416331503210342b72a01ae061b1a1b0601c113 6b50fdc5aa6ffe0f5c0261382301c1e1487904e31616fae52b164848370a0140fef8070e3331 480210028e00000000030046000005350577001700250036003a403432010622080c02080f01 26272501061c010122000908070304070102124c132000050f014d0c2c040626015518040806 03380f032b2b2b30333532351134233521321e0115140607321e0115140e0123251416332132 3e0135342e0123213521323e0235342e022321220e011546d3d302f168d48bcd8959bc7885d4 6bfe5a32360104508950427b4ffe7701333e6d572f23445c35fefc25291a484104654148519f 6c7da91a62a45c70ac5d892c15548d504e9560362d556b3c3562502d061d1e00000000010017 017b023501fa00030017401019020000060104400301000501050f032b31002b301335211517 021e017b7f7f000100b20000035e055400110024401d0a010401220706110601040009110701 031209015a0d04010501130f032b2b3f2b30333520351106233532373332161511142115be01 006aa2fb801d070d0100484104333348830b07fb474148000000000100660000039805540032 0044403b2e2918030d2b091210020d22200c0408310103012b14000911070204290109150931 0132302e034f240909051b012a100303481501030602340f032b2b31002b2b3033353437013e 0335342e01232206073633321615140623222635343e0233321e0115140e020f013332363736 3733036604013e485a58333e7b57598e1d080e2e41412e30413a6d894d75ca764e7abe1ee8c5 91c30618193c3a37050601604e6a8a8f5054995c6b55023e312f41432d4d87693863b57959a0 83a61cdf05051aa3fe9300020050ffd303ae0554000f00200023401c1827070c000810270009 00070204550c140005551c03000602220f032b31002b300522021134123633321e0215140206 27323612353402262322060215141e01160200fbb541c1ae87ac5a2141beaf72701a1a6f7374 701a0b306b2d019d011db2013adb84d1ef83b0fecdd735ea011ca09a0104d3d4fefd9a72cad7 930000060008000e001d002b0042fe5afe73ffd30000037303a0057705a401cd00e100db00d5 00b000a800a600a400980093008d007f006d006a0068005e00560052004e004a00480042003d 003b003700350033002f002107fe07ee05ec05c305b005a0057b0552050804df040803fe03e9 031902fc02f402e302aa026d025a0227021f01e901c10185017f016d012500ee00e100df00db 00d900d500cf00c500c300c100be00ba00b800b400b200ae00a600a400a200a000960091008f 008b0087007f007d00790073006f006a0062005200480042003b003500210000401615141312 11100f0e0d0c0b0a090807060504030201002cb200800043208a628a234266562d2cb22a0000 435478b0002b58173959b0002b58173c59b0002b58b00a2a59b0014310b0002b58173c59b000 2b58b00a2a592d2c2b2d2c2bb0022a2d2cb0022a2d2cb00162b0002342b10103254220462068 6164b0032546206820b0044323612064b140408a545821212121b100211c5950582121b10004 25204668b007254561b0005158211bb0054338591b6164595358232f23f91b2f23e959b0012b 2d2cb00162b0002342b101032542204620686164b0032546206861645358232f23f91b2f23e9 59b0012b2d2cb00162b0002342b1010525423fe9b0012b2d2cb00162b0002342b1010325423f f9b0012b2d2c111217392d2cc12d2cb2000100432020b004438a45b003436169604460422d2c 4520b0032342b201020543764323438a23616960b004234218b00b2a2d2cb0002342184569b0 406120b000515821b0411bb04061b0005158b0461bb0485959b00523424520b001234269b002 2342b00c2a182d2c204568442d2cba00110005ffc0422b2d2cb2110500422b2d2c2020b10203 8a4223b0016142466820b0405458b0406059b00423422d2cb1020343114312173931002d2c2e 2d2cc52d2c3fb0142a2d000100000001000039cb36855f0f3cf5000308000000000000000000 0000000000000000ffa6fe00081206000000000600020001000000000001000005a4fe460000 0837ffa6ff8e0812000100000000000000000000000000000007060001000600004205aa0046 02aa0017040000b20400006604000050000000000000004c000000e8000001c0000001f00000 025000000324000003b400010000000700600004000000000002000c00060016000000c40062 00040001401e072703220b1f080f04275d0e0d076a0c5d07550551234a055d5d2b0d35008db8 033c851d2b2b00> ] def /f-1-0 currentdict end definefont pop %%EndResource %%EndSetup %%Page: 1 1 %%BeginPageSetup %%PageBoundingBox: 0 -1 362 180 %%EndPageSetup q 0 -1 362 181 rectclip q 0 g 0.8 w 1 J 0 j [] 0.0 d 4 M q 1 0 0 -1 0 179.239456 cm 66.926 43.836 m 81.098 43.836 l S Q 76.914 137.341 m 82.156 135.411 l 76.914 133.482 l 77.75 134.622 77.746 136.181 76.914 137.341 c h 76.914 137.341 m f* 0.402638 w 1 j 10 M q 1 0 0 -1 0 179.239456 cm 35.539 50.633 m 37.664 50.633 l S Q q 1 0 0 -1 0 179.239456 cm 35.539 75.652 m 37.664 75.652 l S Q q 1 0 0 -1 0 179.239456 cm 35.539 100.695 m 37.664 100.695 l S Q q 1 0 0 -1 0 179.239456 cm 35.539 125.715 m 37.664 125.715 l S Q 0.316883 w q 1 0 0 -1 0 179.239456 cm 78.051 150.758 m 78.051 148.633 l S Q q 1 0 0 -1 0 179.239456 cm 120.562 150.758 m 120.562 148.633 l S Q 0.402638 w q 1 0 0 -1 0 179.239456 cm 35.539 25.59 m 37.664 25.59 l S Q q 1 0 0 -1 0 179.239456 cm 233.953 50.633 m 236.078 50.633 l S Q q 1 0 0 -1 0 179.239456 cm 233.953 75.652 m 236.078 75.652 l S Q q 1 0 0 -1 0 179.239456 cm 233.953 100.695 m 236.078 100.695 l S Q q 1 0 0 -1 0 179.239456 cm 233.953 125.715 m 236.078 125.715 l S Q 0.316884 w q 1 0 0 -1 0 179.239456 cm 276.465 150.758 m 276.465 148.633 l S Q q 1 0 0 -1 0 179.239456 cm 318.977 150.758 m 318.977 148.633 l S Q 0.402638 w q 1 0 0 -1 0 179.239456 cm 233.953 25.59 m 236.078 25.59 l S Q 0.0784314 g 0.4252 w 0 J 0 j 22.9256 M q 1 0 0 -1 0 179.239456 cm 159.543 150.758 m 35.539 150.758 l 35.539 4.117 l S Q 0 g 154.996 30.368 m 160.105 28.489 l 154.996 26.611 l 155.812 27.72 155.809 29.236 154.996 30.368 c h 154.996 30.368 m f* 33.652 170.575 m 35.531 175.685 l 37.41 170.575 l 36.301 171.392 34.785 171.388 33.652 170.575 c h 33.652 170.575 m f* 0.0784314 g q 1 0 0 -1 0 179.239456 cm 357.957 150.758 m 233.953 150.758 l 233.953 4.117 l S Q 0 g 353.41 30.368 m 358.52 28.489 l 353.41 26.611 l 354.227 27.72 354.223 29.236 353.41 30.368 c h 353.41 30.368 m f* 232.066 170.575 m 233.945 175.685 l 235.824 170.575 l 234.715 171.392 233.199 171.388 232.066 170.575 c h 232.066 170.575 m f* BT 12 0 0 12 92.778516 0.134769 Tm /f-0-0 1 Tf (x)Tj 19.680585 3.543424 Td (x)Tj ET 0.0784314 g 1 J [ 0.4252 2.126] 0 d q 1 0 0 -1 0 179.239456 cm 340.238 0.57 m 340.238 150.758 l 324.488 0.57 m 324.488 150.758 l S Q /CairoPattern { q 0 g 0 150 100 -200 re f Q } bind def << /PatternType 1 /PaintType 1 /TilingType 1 /XStep 500 /YStep 100 /BBox [0 0 500 100] /PaintProc { pop CairoPattern } >> [ 0.005 0.005 0.01 -0.01 -1.128906 0.239456 ] makepattern setpattern 324.496 139.989 m 324.496 126.54 l 329.488 124.876 334.879 123.583 340.246 122.54 c 340.246 133.564 l 334.934 135.196 329.57 137.259 324.496 139.989 c h 324.496 139.989 m f 0.0784314 g 0.4252 w 1 J 0 j [ 0.4252 2.126] 0 d 22.9256 M q 1 0 0 -1 0 179.239456 cm 361.504 56.711 m 233.953 56.711 l 361.504 39.25 m 233.953 39.25 l S Q [ 0.4252 2.126] 0 d q 1 0 0 -1 0 179.239456 cm 104.004 0.57 m 104.004 150.758 l 152.172 0.57 m 152.172 150.758 l S Q [ 0.4252 2.126] 0 d q 1 0 0 -1 0 179.239456 cm 163.086 48.406 m 35.539 48.406 l 163.086 39.25 m 35.539 39.25 l S Q 0 g BT 12 0 0 12 49.713293 132.716461 Tm /f-0-0 1 Tf (y)Tj /f-1-0 1 Tf 8.677075 3.161096 Td (A)Tj 16.68129 0 Td (B)Tj /f-0-0 1 Tf -5.235105 -14.20957 Td (x)Tj -7.739945 8.588267 Td (y)Tj -16.552944 0 Td (y)Tj 12.000001 0 0 10.848438 218.912661 79.087771 Tm /f-1-0 1 Tf (-1)Tj -0.130859 -2.336044 Td (-2)Tj 0.329099 4.633154 Td (0)Tj 0.135744 2.336044 Td (1)Tj -0.130859 2.29711 Td (2)Tj -8.857124 -12.848241 Td [(2)4020(1)4090(0)]TJ -7.818577 5.917977 Td (-1)Tj -0.13086 -2.336044 Td (-2)Tj 0.3291 4.633154 Td (0)Tj 0.135744 2.336044 Td (1)Tj -0.13086 2.29711 Td (2)Tj 24.158423 -12.848241 Td [(2)4020(1)4090(0)]TJ ET 0.8 w [] 0.0 d 4 M q 1 0 0 -1 0 179.239456 cm 128.098 94.371 m 128.098 108.543 l S Q 130.031 74.88 m 128.105 69.634 l 126.176 74.88 l 127.312 74.04 128.871 74.048 130.031 74.88 c h 130.031 74.88 m f* q 1 0 0 -1 0 179.239456 cm 280.02 47.98 m 265.848 47.98 l S Q 270.031 129.321 m 264.785 131.251 l 270.031 133.181 l 269.191 132.04 269.199 130.486 270.031 129.321 c h 270.031 129.321 m f* q 1 0 0 -1 0 179.239456 cm 332.363 123.262 m 332.363 109.09 l S Q 330.426 65.966 m 332.355 71.212 l 334.285 65.966 l 333.145 66.806 331.586 66.798 330.426 65.966 c h 330.426 65.966 m f* /CairoPattern { q 0 g 0 150 100 -200 re f Q } bind def << /PatternType 1 /PaintType 1 /TilingType 1 /XStep 500 /YStep 100 /BBox [0 0 500 100] /PaintProc { pop CairoPattern } >> [ -0.005 0.005 0.01 0.01 -1.128906 -1.760544 ] makepattern setpattern 267.676 28.486 m 264.844 55.118 260.898 76.353 245.926 89.861 c 242.777 92.704 238.305 95.689 235.926 97.935 c 233.883 99.868 233.953 100.431 233.953 103.587 c 233.957 102.107 233.852 99.669 234.176 98.263 c 235.055 94.47 240.988 88.431 243.004 85.861 c 255.035 70.501 259.871 52.626 263.426 28.486 c h 267.676 28.486 m f /CairoPattern { q 0 g 0 150 100 -200 re f Q } bind def << /PatternType 1 /PaintType 1 /TilingType 1 /XStep 500 /YStep 100 /BBox [0 0 500 100] /PaintProc { pop CairoPattern } >> [ -0.005 0.005 0.01 0.01 -1.128906 -1.760544 ] makepattern setpattern 163.086 119.376 m 149.266 120.997 129.184 123.736 116.105 130.716 c 100.59 139.001 93.648 151.939 89.098 178.669 c 96.852 178.669 l 99.742 169.556 102.617 162.634 107.43 155.927 c 121.16 136.779 145.988 131.868 163.086 128.607 c h 163.086 119.376 m f /CairoPattern { q 0 g 0 150 100 -200 re f Q } bind def << /PatternType 1 /PaintType 1 /TilingType 1 /XStep 500 /YStep 100 /BBox [0 0 500 100] /PaintProc { pop CairoPattern } >> [ -0.005 0.005 0.01 0.01 -1.128906 -1.760544 ] makepattern setpattern 69.27 28.489 m 66.438 55.122 62.492 76.353 47.52 89.864 c 44.371 92.708 39.898 95.693 37.52 97.939 c 35.477 99.872 35.547 100.431 35.547 103.591 c 35.551 102.111 35.445 99.669 35.77 98.263 c 36.648 94.47 42.582 88.435 44.598 85.864 c 56.629 70.505 61.465 52.63 65.02 28.489 c h 69.27 28.489 m f /CairoPattern { q 0 g 0 150 100 -200 re f Q } bind def << /PatternType 1 /PaintType 1 /TilingType 1 /XStep 500 /YStep 100 /BBox [0 0 500 100] /PaintProc { pop CairoPattern } >> [ 0.005 0.005 0.01 -0.01 -1.128906 0.239456 ] makepattern setpattern 104.02 139.989 m 107.305 136.333 111.18 133.372 115.871 130.841 c 152.145 130.841 l 143.699 132.759 134.508 135.466 126.098 139.989 c h 104.02 139.989 m f 0.2 g 0.7088 w 1 J 1 j [] 0.0 d 22.9256 M q 1 0 0 -1 0 179.239456 cm 69.27 150.75 m 66.438 124.117 62.492 102.887 47.52 89.375 c 44.371 86.531 39.898 83.547 37.52 81.301 c 35.477 79.367 35.547 78.809 35.547 75.648 c 35.551 77.129 35.445 79.57 35.77 80.977 c 36.648 84.77 42.582 90.805 44.598 93.375 c 56.629 108.734 61.465 126.609 65.02 150.75 c S Q /CairoPattern { q 0 g 0 150 100 -200 re f Q } bind def << /PatternType 1 /PaintType 1 /TilingType 1 /XStep 500 /YStep 100 /BBox [0 0 500 100] /PaintProc { pop CairoPattern } >> [ -0.005 0.005 0.01 0.01 -1.128906 -1.760544 ] makepattern setpattern 361.492 119.372 m 347.672 120.993 327.59 123.732 314.512 130.712 c 298.996 138.997 292.055 151.935 287.508 178.665 c 295.258 178.665 l 298.148 169.552 301.023 162.63 305.836 155.923 c 319.566 136.775 344.395 131.864 361.492 128.603 c h 361.492 119.372 m f 0.2 g 0.70866 w 1 J 1 j [] 0.0 d 22.9256 M q 1 0 0 -1 0 179.239456 cm 361.5 59.863 m 347.68 58.242 327.598 55.504 314.52 48.523 c 299.004 40.238 292.062 27.301 287.516 0.57 c 295.266 0.57 m 298.156 9.684 301.031 16.605 305.844 23.312 c 319.574 42.461 344.402 47.371 361.5 50.633 c 267.684 150.758 m 264.852 124.125 260.918 102.883 245.945 89.371 c 242.793 86.527 238.301 83.551 235.926 81.305 c 233.879 79.371 233.953 78.812 233.953 75.652 c 233.957 77.133 233.855 79.559 234.184 80.965 c 235.059 84.758 241.004 90.805 243.02 93.379 c 255.051 108.738 259.875 126.617 263.434 150.758 c S Q 1 g 35.539 105.005 m 36.32 105.005 36.957 104.368 36.957 103.587 c 36.957 102.802 36.32 102.169 35.539 102.169 c 34.758 102.169 34.121 102.802 34.121 103.587 c 34.121 104.368 34.758 105.005 35.539 105.005 c h 35.539 105.005 m f 0.2 g 0 J 0 j q 1 0 0 -1 0 179.239456 cm 35.539 74.234 m 36.32 74.234 36.957 74.871 36.957 75.652 c 36.957 76.438 36.32 77.07 35.539 77.07 c 34.758 77.07 34.121 76.438 34.121 75.652 c 34.121 74.871 34.758 74.234 35.539 74.234 c h 35.539 74.234 m S Q 1 g 233.953 105.005 m 234.734 105.005 235.371 104.368 235.371 103.587 c 235.371 102.802 234.734 102.169 233.953 102.169 c 233.172 102.169 232.535 102.802 232.535 103.587 c 232.535 104.368 233.172 105.005 233.953 105.005 c h 233.953 105.005 m f 0.2 g q 1 0 0 -1 0 179.239456 cm 233.953 74.234 m 234.734 74.234 235.371 74.871 235.371 75.652 c 235.371 76.438 234.734 77.07 233.953 77.07 c 233.172 77.07 232.535 76.438 232.535 75.652 c 232.535 74.871 233.172 74.234 233.953 74.234 c h 233.953 74.234 m S Q 1 J 1 j q 1 0 0 -1 0 179.239456 cm 96.852 0.57 m 99.742 9.684 102.617 16.605 107.43 23.312 c 121.16 42.461 145.988 47.371 163.086 50.633 c 163.086 59.863 m 149.266 58.242 129.184 55.504 116.105 48.523 c 100.59 40.238 93.648 27.301 89.098 0.57 c S Q Q Q showpage %%Trailer end restore %%EOF interval-1.4.1/doc/image/octave-interval.ly.eps0000644000175000017500000006151412657476043021036 0ustar oliveroliver%!PS-Adobe-3.0 EPSF-3.0 %Produced by poppler pdftops version: 0.26.5 (http://poppler.freedesktop.org) %%Creator: LilyPond 2.18.2 %%LanguageLevel: 2 %%DocumentSuppliedResources: (atend) %%BoundingBox: 0 0 77 50 %%HiResBoundingBox: 0 0 77 50 %%DocumentSuppliedResources: (atend) %%EndComments %%BeginProlog %%BeginResource: procset xpdf 3.00 0 %%Copyright: Copyright 1996-2011 Glyph & Cog, LLC /xpdf 75 dict def xpdf begin % PDF special state /pdfDictSize 15 def /pdfSetup { /setpagedevice where { pop 2 dict begin /Policies 1 dict dup begin /PageSize 6 def end def { /Duplex true def } if currentdict end setpagedevice } { pop } ifelse } def /pdfSetupPaper { % Change paper size, but only if different from previous paper size otherwise % duplex fails. PLRM specifies a tolerance of 5 pts when matching paper size % so we use the same when checking if the size changes. /setpagedevice where { pop currentpagedevice /PageSize known { 2 copy currentpagedevice /PageSize get aload pop exch 4 1 roll sub abs 5 gt 3 1 roll sub abs 5 gt or } { true } ifelse { 2 array astore 2 dict begin /PageSize exch def /ImagingBBox null def currentdict end setpagedevice } { pop pop } ifelse } { pop } ifelse } def /pdfStartPage { pdfDictSize dict begin /pdfFillCS [] def /pdfFillXform {} def /pdfStrokeCS [] def /pdfStrokeXform {} def /pdfFill [0] def /pdfStroke [0] def /pdfFillOP false def /pdfStrokeOP false def /pdfLastFill false def /pdfLastStroke false def /pdfTextMat [1 0 0 1 0 0] def /pdfFontSize 0 def /pdfCharSpacing 0 def /pdfTextRender 0 def /pdfPatternCS false def /pdfTextRise 0 def /pdfWordSpacing 0 def /pdfHorizScaling 1 def /pdfTextClipPath [] def } def /pdfEndPage { end } def % PDF color state /cs { /pdfFillXform exch def dup /pdfFillCS exch def setcolorspace } def /CS { /pdfStrokeXform exch def dup /pdfStrokeCS exch def setcolorspace } def /sc { pdfLastFill not { pdfFillCS setcolorspace } if dup /pdfFill exch def aload pop pdfFillXform setcolor /pdfLastFill true def /pdfLastStroke false def } def /SC { pdfLastStroke not { pdfStrokeCS setcolorspace } if dup /pdfStroke exch def aload pop pdfStrokeXform setcolor /pdfLastStroke true def /pdfLastFill false def } def /op { /pdfFillOP exch def pdfLastFill { pdfFillOP setoverprint } if } def /OP { /pdfStrokeOP exch def pdfLastStroke { pdfStrokeOP setoverprint } if } def /fCol { pdfLastFill not { pdfFillCS setcolorspace pdfFill aload pop pdfFillXform setcolor pdfFillOP setoverprint /pdfLastFill true def /pdfLastStroke false def } if } def /sCol { pdfLastStroke not { pdfStrokeCS setcolorspace pdfStroke aload pop pdfStrokeXform setcolor pdfStrokeOP setoverprint /pdfLastStroke true def /pdfLastFill false def } if } def % build a font /pdfMakeFont { 4 3 roll findfont 4 2 roll matrix scale makefont dup length dict begin { 1 index /FID ne { def } { pop pop } ifelse } forall /Encoding exch def currentdict end definefont pop } def /pdfMakeFont16 { exch findfont dup length dict begin { 1 index /FID ne { def } { pop pop } ifelse } forall /WMode exch def currentdict end definefont pop } def % graphics state operators /q { gsave pdfDictSize dict begin } def /Q { end grestore /pdfLastFill where { pop pdfLastFill { pdfFillOP setoverprint } { pdfStrokeOP setoverprint } ifelse } if } def /cm { concat } def /d { setdash } def /i { setflat } def /j { setlinejoin } def /J { setlinecap } def /M { setmiterlimit } def /w { setlinewidth } def % path segment operators /m { moveto } def /l { lineto } def /c { curveto } def /re { 4 2 roll moveto 1 index 0 rlineto 0 exch rlineto neg 0 rlineto closepath } def /h { closepath } def % path painting operators /S { sCol stroke } def /Sf { fCol stroke } def /f { fCol fill } def /f* { fCol eofill } def % clipping operators /W { clip newpath } def /W* { eoclip newpath } def /Ws { strokepath clip newpath } def % text state operators /Tc { /pdfCharSpacing exch def } def /Tf { dup /pdfFontSize exch def dup pdfHorizScaling mul exch matrix scale pdfTextMat matrix concatmatrix dup 4 0 put dup 5 0 put exch findfont exch makefont setfont } def /Tr { /pdfTextRender exch def } def /Tp { /pdfPatternCS exch def } def /Ts { /pdfTextRise exch def } def /Tw { /pdfWordSpacing exch def } def /Tz { /pdfHorizScaling exch def } def % text positioning operators /Td { pdfTextMat transform moveto } def /Tm { /pdfTextMat exch def } def % text string operators /xyshow where { pop /xyshow2 { dup length array 0 2 2 index length 1 sub { 2 index 1 index 2 copy get 3 1 roll 1 add get pdfTextMat dtransform 4 2 roll 2 copy 6 5 roll put 1 add 3 1 roll dup 4 2 roll put } for exch pop xyshow } def }{ /xyshow2 { currentfont /FontType get 0 eq { 0 2 3 index length 1 sub { currentpoint 4 index 3 index 2 getinterval show moveto 2 copy get 2 index 3 2 roll 1 add get pdfTextMat dtransform rmoveto } for } { 0 1 3 index length 1 sub { currentpoint 4 index 3 index 1 getinterval show moveto 2 copy 2 mul get 2 index 3 2 roll 2 mul 1 add get pdfTextMat dtransform rmoveto } for } ifelse pop pop } def } ifelse /cshow where { pop /xycp { 0 3 2 roll { pop pop currentpoint 3 2 roll 1 string dup 0 4 3 roll put false charpath moveto 2 copy get 2 index 2 index 1 add get pdfTextMat dtransform rmoveto 2 add } exch cshow pop pop } def }{ /xycp { currentfont /FontType get 0 eq { 0 2 3 index length 1 sub { currentpoint 4 index 3 index 2 getinterval false charpath moveto 2 copy get 2 index 3 2 roll 1 add get pdfTextMat dtransform rmoveto } for } { 0 1 3 index length 1 sub { currentpoint 4 index 3 index 1 getinterval false charpath moveto 2 copy 2 mul get 2 index 3 2 roll 2 mul 1 add get pdfTextMat dtransform rmoveto } for } ifelse pop pop } def } ifelse /Tj { fCol 0 pdfTextRise pdfTextMat dtransform rmoveto currentpoint 4 2 roll pdfTextRender 1 and 0 eq { 2 copy xyshow2 } if pdfTextRender 3 and dup 1 eq exch 2 eq or { 3 index 3 index moveto 2 copy currentfont /FontType get 3 eq { fCol } { sCol } ifelse xycp currentpoint stroke moveto } if pdfTextRender 4 and 0 ne { 4 2 roll moveto xycp /pdfTextClipPath [ pdfTextClipPath aload pop {/moveto cvx} {/lineto cvx} {/curveto cvx} {/closepath cvx} pathforall ] def currentpoint newpath moveto } { pop pop pop pop } ifelse 0 pdfTextRise neg pdfTextMat dtransform rmoveto } def /TJm { 0.001 mul pdfFontSize mul pdfHorizScaling mul neg 0 pdfTextMat dtransform rmoveto } def /TJmV { 0.001 mul pdfFontSize mul neg 0 exch pdfTextMat dtransform rmoveto } def /Tclip { pdfTextClipPath cvx exec clip newpath /pdfTextClipPath [] def } def /Tclip* { pdfTextClipPath cvx exec eoclip newpath /pdfTextClipPath [] def } def % Level 2/3 image operators /pdfImBuf 100 string def /pdfImStr { 2 copy exch length lt { 2 copy get exch 1 add exch } { () } ifelse } def /skipEOD { { currentfile pdfImBuf readline not { pop exit } if (%-EOD-) eq { exit } if } loop } def /pdfIm { image skipEOD } def /pdfImM { fCol imagemask skipEOD } def /pr { 2 index 2 index 3 2 roll putinterval 4 add } def /pdfImClip { gsave 0 2 4 index length 1 sub { dup 4 index exch 2 copy get 5 index div put 1 add 3 index exch 2 copy get 3 index div put } for pop pop rectclip } def /pdfImClipEnd { grestore } def % shading operators /colordelta { false 0 1 3 index length 1 sub { dup 4 index exch get 3 index 3 2 roll get sub abs 0.004 gt { pop true } if } for exch pop exch pop } def /funcCol { func n array astore } def /funcSH { dup 0 eq { true } { dup 6 eq { false } { 4 index 4 index funcCol dup 6 index 4 index funcCol dup 3 1 roll colordelta 3 1 roll 5 index 5 index funcCol dup 3 1 roll colordelta 3 1 roll 6 index 8 index funcCol dup 3 1 roll colordelta 3 1 roll colordelta or or or } ifelse } ifelse { 1 add 4 index 3 index add 0.5 mul exch 4 index 3 index add 0.5 mul exch 6 index 6 index 4 index 4 index 4 index funcSH 2 index 6 index 6 index 4 index 4 index funcSH 6 index 2 index 4 index 6 index 4 index funcSH 5 3 roll 3 2 roll funcSH pop pop } { pop 3 index 2 index add 0.5 mul 3 index 2 index add 0.5 mul funcCol sc dup 4 index exch mat transform m 3 index 3 index mat transform l 1 index 3 index mat transform l mat transform l pop pop h f* } ifelse } def /axialCol { dup 0 lt { pop t0 } { dup 1 gt { pop t1 } { dt mul t0 add } ifelse } ifelse func n array astore } def /axialSH { dup 0 eq { true } { dup 8 eq { false } { 2 index axialCol 2 index axialCol colordelta } ifelse } ifelse { 1 add 3 1 roll 2 copy add 0.5 mul dup 4 3 roll exch 4 index axialSH exch 3 2 roll axialSH } { pop 2 copy add 0.5 mul axialCol sc exch dup dx mul x0 add exch dy mul y0 add 3 2 roll dup dx mul x0 add exch dy mul y0 add dx abs dy abs ge { 2 copy yMin sub dy mul dx div add yMin m yMax sub dy mul dx div add yMax l 2 copy yMax sub dy mul dx div add yMax l yMin sub dy mul dx div add yMin l h f* } { exch 2 copy xMin sub dx mul dy div add xMin exch m xMax sub dx mul dy div add xMax exch l exch 2 copy xMax sub dx mul dy div add xMax exch l xMin sub dx mul dy div add xMin exch l h f* } ifelse } ifelse } def /radialCol { dup t0 lt { pop t0 } { dup t1 gt { pop t1 } if } ifelse func n array astore } def /radialSH { dup 0 eq { true } { dup 8 eq { false } { 2 index dt mul t0 add radialCol 2 index dt mul t0 add radialCol colordelta } ifelse } ifelse { 1 add 3 1 roll 2 copy add 0.5 mul dup 4 3 roll exch 4 index radialSH exch 3 2 roll radialSH } { pop 2 copy add 0.5 mul dt mul t0 add radialCol sc encl { exch dup dx mul x0 add exch dup dy mul y0 add exch dr mul r0 add 0 360 arc h dup dx mul x0 add exch dup dy mul y0 add exch dr mul r0 add 360 0 arcn h f } { 2 copy dup dx mul x0 add exch dup dy mul y0 add exch dr mul r0 add a1 a2 arcn dup dx mul x0 add exch dup dy mul y0 add exch dr mul r0 add a2 a1 arcn h dup dx mul x0 add exch dup dy mul y0 add exch dr mul r0 add a1 a2 arc dup dx mul x0 add exch dup dy mul y0 add exch dr mul r0 add a2 a1 arc h f } ifelse } ifelse } def end %%EndResource %%EndProlog %%BeginSetup xpdf begin %%BeginResource: font CenturySchL-Roma %!FontType1-1.0: CenturySchL-Roma 12 dict begin /FontInfo 10 dict dup begin /Notice (Copyright \(URW\)++,Copyright 1999 by \(URW\)++ Design & Develo\ pment; Cyrillic glyphs added by Valek Filippov \(C\) 2001-2005) readonly def /FullName (Century Schoolbook L Roman) readonly def /FamilyName (Roman) readonly def /isFixedPitch false def /ItalicAngle 0 def /UnderlinePosition 0 def /UnderlineThickness 0 def end readonly def /FontName /CenturySchL-Roma def /PaintType 0 def /FontType 1 def /FontMatrix [0.001 0 0 0.001 0 0] readonly def /FontBBox [0 -155 513 722] readonly def /StrokeWidth 0 def /Encoding 256 array 0 1 255 {1 index exch /.notdef put} for dup 32 /space put dup 44 /comma put dup 50 /two put dup 51 /three put dup 53 /five put dup 56 /eight put dup 57 /nine put dup 91 /bracketleft put dup 93 /bracketright put readonly def currentdict end currentfile eexec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cleartomark %%EndResource /F10_0 /CenturySchL-Roma 1 1 [ /.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef /.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef /.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef /.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef /space/exclam/quotedbl/numbersign/dollar/percent/ampersand/quotesingle /parenleft/parenright/asterisk/plus/comma/hyphen/period/slash /zero/one/two/three/four/five/six/seven /eight/nine/colon/semicolon/less/equal/greater/question /at/A/B/C/D/E/F/G /H/I/J/K/L/M/N/O /P/Q/R/S/T/U/V/W /X/Y/Z/bracketleft/backslash/bracketright/asciicircum/underscore /grave/a/b/c/d/e/f/g /h/i/j/k/l/m/n/o /p/q/r/s/t/u/v/w /x/y/z/braceleft/bar/braceright/asciitilde/bullet /Euro/bullet/quotesinglbase/florin/quotedblbase/ellipsis/dagger/daggerdbl /circumflex/perthousand/Scaron/guilsinglleft/OE/bullet/Zcaron/bullet /bullet/quoteleft/quoteright/quotedblleft/quotedblright/bullet/endash/emdash /tilde/trademark/scaron/guilsinglright/oe/bullet/zcaron/Ydieresis /space/exclamdown/cent/sterling/currency/yen/brokenbar/section /dieresis/copyright/ordfeminine/guillemotleft/logicalnot/hyphen/registered/macron /degree/plusminus/twosuperior/threesuperior/acute/mu/paragraph/periodcentered /cedilla/onesuperior/ordmasculine/guillemotright/onequarter/onehalf/threequarters/questiondown /Agrave/Aacute/Acircumflex/Atilde/Adieresis/Aring/AE/Ccedilla /Egrave/Eacute/Ecircumflex/Edieresis/Igrave/Iacute/Icircumflex/Idieresis /Eth/Ntilde/Ograve/Oacute/Ocircumflex/Otilde/Odieresis/multiply /Oslash/Ugrave/Uacute/Ucircumflex/Udieresis/Yacute/Thorn/germandbls /agrave/aacute/acircumflex/atilde/adieresis/aring/ae/ccedilla /egrave/eacute/ecircumflex/edieresis/igrave/iacute/icircumflex/idieresis /eth/ntilde/ograve/oacute/ocircumflex/otilde/odieresis/divide /oslash/ugrave/uacute/ucircumflex/udieresis/yacute/thorn/ydieresis] pdfMakeFont %%BeginResource: font Emmentaler-20 %!FontType1-1.0: Emmentaler-20 12 dict begin /FontInfo 10 dict dup begin /Notice (This font is distributed under the GNU General Public License. \ As a special exception, if you create a document which uses this\ font, and embed this font or unaltered portions of this font in\ to the document, this font does not by itself cause the resultin\ ) readonly def /FullName (Emmentaler-20) readonly def /FamilyName (Medium) readonly def /isFixedPitch false def /ItalicAngle 0 def /UnderlinePosition 0 def /UnderlineThickness 0 def end readonly def /FontName /Emmentaler-20 def /PaintType 0 def /FontType 1 def /FontMatrix [0.001 0 0 0.001 0 0] readonly def /FontBBox [0 -635 645 1194] readonly def /StrokeWidth 0 def /Encoding 256 array 0 1 255 {1 index exch /.notdef put} for dup 0 /noteheads.s0 put dup 1 /clefs.G put dup 2 /timesig.C44 put readonly def currentdict end currentfile eexec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cleartomark %%EndResource /F8_0 /Emmentaler-20 1 1 [ /noteheads.s0/clefs.G/timesig.C44/.notdef/.notdef/.notdef/.notdef/.notdef /.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef /.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef /.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef/.notdef /space/exclam/quotedbl/numbersign/dollar/percent/ampersand/quotesingle /parenleft/parenright/asterisk/plus/comma/hyphen/period/slash /zero/one/two/three/four/five/six/seven /eight/nine/colon/semicolon/less/equal/greater/question /at/A/B/C/D/E/F/G /H/I/J/K/L/M/N/O /P/Q/R/S/T/U/V/W /X/Y/Z/bracketleft/backslash/bracketright/asciicircum/underscore /grave/a/b/c/d/e/f/g /h/i/j/k/l/m/n/o /p/q/r/s/t/u/v/w /x/y/z/braceleft/bar/braceright/asciitilde/bullet /Euro/bullet/quotesinglbase/florin/quotedblbase/ellipsis/dagger/daggerdbl /circumflex/perthousand/Scaron/guilsinglleft/OE/bullet/Zcaron/bullet /bullet/quoteleft/quoteright/quotedblleft/quotedblright/bullet/endash/emdash /tilde/trademark/scaron/guilsinglright/oe/bullet/zcaron/Ydieresis /space/exclamdown/cent/sterling/currency/yen/brokenbar/section /dieresis/copyright/ordfeminine/guillemotleft/logicalnot/hyphen/registered/macron /degree/plusminus/twosuperior/threesuperior/acute/mu/paragraph/periodcentered /cedilla/onesuperior/ordmasculine/guillemotright/onequarter/onehalf/threequarters/questiondown /Agrave/Aacute/Acircumflex/Atilde/Adieresis/Aring/AE/Ccedilla /Egrave/Eacute/Ecircumflex/Edieresis/Igrave/Iacute/Icircumflex/Idieresis /Eth/Ntilde/Ograve/Oacute/Ocircumflex/Otilde/Odieresis/multiply /Oslash/Ugrave/Uacute/Ucircumflex/Udieresis/Yacute/Thorn/germandbls /agrave/aacute/acircumflex/atilde/adieresis/aring/ae/ccedilla /egrave/eacute/ecircumflex/edieresis/igrave/iacute/icircumflex/idieresis /eth/ntilde/ograve/oacute/ocircumflex/otilde/odieresis/divide /oslash/ugrave/uacute/ucircumflex/udieresis/yacute/thorn/ydieresis] pdfMakeFont %%EndSetup pdfStartPage %%EndPageSetup [] 0 d 1 i 0 j 0 J 10 M 1 w /DeviceGray {} cs [0] sc /DeviceGray {} CS [0] SC false op false OP {} settransfer 0 0 77 50 re W q q [0.1 0 0 0.1 0 0] cm 4.98132 w 1 J /DeviceGray {} CS [0] SC 2.49219 202.277 m 759.129 202.277 l S 2.49219 252.094 m 759.129 252.094 l S 2.49219 301.906 m 759.129 301.906 l S 2.49219 351.719 m 759.129 351.719 l S 2.49219 401.531 m 759.129 401.531 l S 9.46451 w 0 J 756.887 202.277 m 756.887 401.531 l S /DeviceGray {} cs [0] sc q [10 0 0 10 0 0] cm [1 0 0 1 0 0] Tm 0 0 Td [1 0 0 1 43.3375 35.1719] Tm 0 0 Td /F8_0 19.9253 Tf (\000) [9.863023 0] Tj 0 -17.4348 Td (\000) [9.863023 0] Tj -39.3523 -9.96253 Td (\001) [12.772117 0] Tj -18.4308 -4.98128 Td (\002) [8.448327 0] Tj -22.96127 -32.37858 Td /F10_0 12.3019 Tf ([) [4.096533 0] Tj 1.21109 TJm (2) [6.839856 0] Tj 2.98678 TJm (9) [6.839856 0] Tj 3.01854 TJm (3) [6.839856 0] Tj 2.98678 TJm (,) [3.419928 0] Tj 1.49339 TJm ( ) [3.419928 0] Tj 1.46164 TJm (5) [6.839856 0] Tj 3.01854 TJm (8) [6.839856 0] Tj 2.98678 TJm (8) [6.839856 0] Tj 2.98678 TJm (]) [4.096533 0] Tj Q Q Q showpage %%PageTrailer pdfEndPage %%Trailer end %%DocumentSuppliedResources: %%+ font CenturySchL-Roma %%+ font Emmentaler-20 %%EOF interval-1.4.1/doc/image/inverse-power.svg.pdf0000644000175000017500000003175412657476043020700 0ustar oliveroliver%PDF-1.5 % 3 0 obj << /Length 4 0 R /Filter /FlateDecode >> stream xY[}ׯcZ8z70S'4q Z[w3'13'mK[_ߌدG[띷ߛdj/!{>>R\ŦZ,6q5da'X,J.&r$fD|.j8R1'Mx5ջC׍Z9v+1Bdx]}.|ݿ&r0'ft\ZO^UYdsr  {晈C6 ~5l T% z׸.;K]]E?&|Ξ7QD/2oExw L~BZW^rw9ţ!ħ5H=z/6Ex'>Ѐi}E=5 a|76PrH9 1j^ZB*I`\\{ڲI Ͻ9V^-(sfy1GڴssPpz~ߞp\uzzt9ISOaoRNP S>x:-+y;{byQ8TǏ\EФhtd} ۇC3\dn'燷cHZav(`6y($D` w_~EYtK'讷pIC*>ɦGZJ) f2Ǥ4EXuɤE=I 3F\lצc/.0E\,'D|X0# 3>Ȯ5!CKt}й`:ܸRt JIEn,%ȚAϫWVVܟG{?na 2{EP芝xk-MϿ@rΡ4EEgN@ xҷZk[ET07d%O@._Ά>XlIfp3I^kf@uCүC@oG`}TRxJ]nFKn  { нw.A{%'(23#A`r&WAS8qyBc̲sIґ+ka @[tluAȊ#(`"^t&J[X2lP81'toNӜCbZB ߚ(~]0lxL+8Pu7fnh^c;c={*U* V*m8 ׃H~>ZC"%F }Xfܨ+3 G>;4{)1Bٰܡѣ1:$M@B)]7D!jf$;Ҵq@ڜZ^PȹhQ%Gp7.c?;Z-&Hp)jIKL ;ks顬䂢ܜՙ BʣE&>_5aE3Y@5%Z>TR( YMFu@Í/9G;P}p'&7/ L?`l#wK5akg2мģ?NӫC$]3gw0D$9(jePhYCnanWP1C'M7 V4Pآn&[d}3Oyѓ,ȼ2QÕ 1# dMvfY5f)=)hJrǹx+{kS5 Ί 6L8/b"y>L<>adOLVxqӢH&zg郳#n{5 NZY̝:脤-;uZL#f#s };S]^gJ왎x|2&sMQ+%TxAP3 YĤ@D Ma,RG( ):C|R!B$S` '0aqy4e!7Dde 7澑8KRXW <0z5ڒոл6q6åEQYʺY/i8Ԇ$InT7Yw1 ƺVGRŶ,&ríd_&[ͥY,9Bk.f Zu-!`?Ķ~]њXyPzPQzyRXɨTk!' a`_TA+M0Khd!^/ AO)B}I!|+XЬ.cPv~c enۣ-Tf9wN});^Ӟo~"cjK9aU{ZOwK] +0pmա9 sRdʀW0,IF_|]Ǎ"7*_mXįIUEU7 :l _Nby|cWY endstream endobj 4 0 obj 2459 endobj 2 0 obj << /ExtGState << /a0 << /CA 1 /ca 1 >> >> /Pattern << /p6 6 0 R /p8 8 0 R /p9 9 0 R /p10 10 0 R /p11 11 0 R /p12 12 0 R >> /Font << /f-0-0 5 0 R /f-1-0 7 0 R >> >> endobj 13 0 obj << /Type /Page /Parent 1 0 R /MediaBox [ 0 0 361.873016 179.239456 ] /Contents 3 0 R /Group << /Type /Group /S /Transparency /I true /CS /DeviceRGB >> /Resources 2 0 R >> endobj 6 0 obj << /Length 15 0 R /PatternType 1 /BBox [ 0 0 100 100 ] /XStep 500 /YStep 100 /TilingType 1 /PaintType 1 /Matrix [ 0.005 0.005 0.01 -0.01 -1.128906 0.239456 ] /Resources << /XObject << /x14 14 0 R >> >> >> stream /x14 Do endstream endobj 15 0 obj 11 endobj 8 0 obj << /Length 17 0 R /PatternType 1 /BBox [ 0 0 100 100 ] /XStep 500 /YStep 100 /TilingType 1 /PaintType 1 /Matrix [ -0.005 0.005 0.01 0.01 -1.128906 -1.760544 ] /Resources << /XObject << /x16 16 0 R >> >> >> stream /x16 Do endstream endobj 17 0 obj 11 endobj 9 0 obj << /Length 19 0 R /PatternType 1 /BBox [ 0 0 100 100 ] /XStep 500 /YStep 100 /TilingType 1 /PaintType 1 /Matrix [ -0.005 0.005 0.01 0.01 -1.128906 -1.760544 ] /Resources << /XObject << /x18 18 0 R >> >> >> stream /x18 Do endstream endobj 19 0 obj 11 endobj 10 0 obj << /Length 21 0 R /PatternType 1 /BBox [ 0 0 100 100 ] /XStep 500 /YStep 100 /TilingType 1 /PaintType 1 /Matrix [ -0.005 0.005 0.01 0.01 -1.128906 -1.760544 ] /Resources << /XObject << /x20 20 0 R >> >> >> stream /x20 Do endstream endobj 21 0 obj 11 endobj 11 0 obj << /Length 23 0 R /PatternType 1 /BBox [ 0 0 100 100 ] /XStep 500 /YStep 100 /TilingType 1 /PaintType 1 /Matrix [ 0.005 0.005 0.01 -0.01 -1.128906 0.239456 ] /Resources << /XObject << /x22 22 0 R >> >> >> stream /x22 Do endstream endobj 23 0 obj 11 endobj 12 0 obj << /Length 25 0 R /PatternType 1 /BBox [ 0 0 100 100 ] /XStep 500 /YStep 100 /TilingType 1 /PaintType 1 /Matrix [ -0.005 0.005 0.01 0.01 -1.128906 -1.760544 ] /Resources << /XObject << /x24 24 0 R >> >> >> stream /x24 Do endstream endobj 25 0 obj 11 endobj 14 0 obj << /Length 27 0 R /Filter /FlateDecode /Type /XObject /Subtype /Form /BBox [ 0 0 100 100 ] /Resources 26 0 R >> stream x+2PtDb  tDQBW  endstream endobj 27 0 obj 41 endobj 26 0 obj << /ExtGState << /a0 << /CA 1 /ca 1 >> >> >> endobj 16 0 obj << /Length 29 0 R /Filter /FlateDecode /Type /XObject /Subtype /Form /BBox [ 0 0 100 100 ] /Resources 28 0 R >> stream x+2PtDb  tDQBW  endstream endobj 29 0 obj 41 endobj 28 0 obj << /ExtGState << /a0 << /CA 1 /ca 1 >> >> >> endobj 18 0 obj << /Length 31 0 R /Filter /FlateDecode /Type /XObject /Subtype /Form /BBox [ 0 0 100 100 ] /Resources 30 0 R >> stream x+2PtDb  tDQBW  endstream endobj 31 0 obj 41 endobj 30 0 obj << /ExtGState << /a0 << /CA 1 /ca 1 >> >> >> endobj 20 0 obj << /Length 33 0 R /Filter /FlateDecode /Type /XObject /Subtype /Form /BBox [ 0 0 100 100 ] /Resources 32 0 R >> stream x+2PtDb  tDQBW  endstream endobj 33 0 obj 41 endobj 32 0 obj << /ExtGState << /a0 << /CA 1 /ca 1 >> >> >> endobj 22 0 obj << /Length 35 0 R /Filter /FlateDecode /Type /XObject /Subtype /Form /BBox [ 0 0 100 100 ] /Resources 34 0 R >> stream x+2PtDb  tDQBW  endstream endobj 35 0 obj 41 endobj 34 0 obj << /ExtGState << /a0 << /CA 1 /ca 1 >> >> >> endobj 24 0 obj << /Length 37 0 R /Filter /FlateDecode /Type /XObject /Subtype /Form /BBox [ 0 0 100 100 ] /Resources 36 0 R >> stream x+2PtDb  tDQBW  endstream endobj 37 0 obj 41 endobj 36 0 obj << /ExtGState << /a0 << /CA 1 /ca 1 >> >> >> endobj 38 0 obj << /Length 39 0 R /Filter /FlateDecode /Length1 2388 >> stream xVmLSW~9޶Pj r-R*"r (bе|hQA85Q1nsnnQga6Bc#Ec2]e[%3l<9O9@ /2/޵ui],X=>n؋#SўHO8mUDaeoΏmnMm ]876ր/}~LfŁM=mhh!Z7@` js]9m!s\ 8'C?qC@V-1g%٤$,BI#ͮ3)ʳkISe\O\43Ƨt231{*ʧ 99T:/7R0>V:b'nxgp܄18p ؏;VC7t@+,ETC pB1Ȑ% ?w|3o~~qaco[6,n%t#HɁG| W s F"\8 g0@< b} n;`60Bx4@="zSNO}Z:͒bNN2 1F#= CCMG˶N %NO* $`Ki"OH6LX&֋H u. EaUZt 3;+\X uZNҠT"=vHqnGt?7/)?Nl+ .S@Y  k\'LF[R`H€IZ_+Y׫1[qWz 鼤Dzu*i(Sźh" Eq!MIDGeA] )2\Wٯۋ-;$}e߁910v &*5P1b|> stream x]n wu8eiOB뒡Դ@@u*uYd{,CtsZ" 8(N `˭N& p.$͹ g| !8ON (ѶW̄ +|CY)֌[ᜍE2qDjA{ _ى۫!X_\b}n.Dٌ7_qO endstream endobj 41 0 obj 231 endobj 42 0 obj << /Type /FontDescriptor /FontName /MAPJMV+Cmmi10 /FontFamily (cmmi10) /Flags 32 /FontBBox [ -34 -250 1047 750 ] /ItalicAngle 0 /Ascent 750 /Descent -250 /CapHeight 750 /StemV 80 /StemH 80 /FontFile2 38 0 R >> endobj 5 0 obj << /Type /Font /Subtype /TrueType /BaseFont /MAPJMV+Cmmi10 /FirstChar 32 /LastChar 121 /FontDescriptor 42 0 R /Encoding /WinAnsiEncoding /Widths [ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 570 490 ] /ToUnicode 40 0 R >> endobj 43 0 obj << /Length 44 0 R /Filter /FlateDecode /Length1 2640 >> stream xV}L[?am`0Ő`CB(RB $@IJY*hSjZE,KUuLJQUMjmZKbvA*k={܏s/ A7W'ַeG- |al ]o z`$^1IEDA#SJ7 cHWψV3Sw5_ye Dof)Zqo @j 28dY<zե >EXUXXI ěPy@:܁ki+}wP(S\["ش#%èGE@r.zI2E]\:& ?I>-.T9цss l1@%Ao1(0Zd. *R@t[HTH|! `\ZL\UZ`65֢Qi=KK/#^{&}kԽl_ 3]1?Sm> l,K%ԮYॽWτmt]kK(@ٗw5%lEy]+Kxyilz s:$XHX}fRu0Ȫ}X`WMM>2Y_?Wb[>o8id~]Da^C}p~u9N Ә)a+UJҢ\U++9܍$?&/"l|sk: X`*_$ ,* z/{xe0.|72\ pҞ0 Rt<[b:Pghsⴸ[ |{>eW8cլ"|N?܆EXpޤ8v-5 8a0 ¡)p-?"$ ݫRjylcĐv^CLnJ{3C{:+ol=3؞b@~c K6C6bm7x2s``ۀ+ydbhRKj$0M/5M_I[i#Qrft5T0pHiݤ+H\y['.ZQ3>kfxwH!%]IPm8t'jk¹HHEyo-+`)Vw8ˍȍ/e]`i^rRw%b(] Tty m*_#|via"Ek +ڙ`'Ws~!T僶~Gܥm[OU d endstream endobj 44 0 obj 1746 endobj 45 0 obj << /Length 46 0 R /Filter /FlateDecode >> stream x]Pn )7 TRi\P|¸߇cR0yo.z_FgЏՄ u:f\#mUEժUBx:'B-N@GѺNߗ}M{?K0F˽&WZQM9_G@5Hk܂T[ {j٨Dc9}ǘEU/{[z endstream endobj 46 0 obj 249 endobj 47 0 obj << /Type /FontDescriptor /FontName /QLMNHR+Cmr10 /FontFamily (cmr10) /Flags 32 /FontBBox [ -43 -250 1008 750 ] /ItalicAngle 0 /Ascent 705 /Descent -215 /CapHeight 750 /StemV 80 /StemH 80 /FontFile2 43 0 R >> endobj 7 0 obj << /Type /Font /Subtype /TrueType /BaseFont /QLMNHR+Cmr10 /FirstChar 32 /LastChar 66 /FontDescriptor 47 0 R /Encoding /WinAnsiEncoding /Widths [ 0 0 0 0 0 0 0 0 0 0 0 0 0 333 0 0 500 500 500 0 0 0 0 0 0 0 0 0 0 0 0 0 0 750 708 ] /ToUnicode 45 0 R >> endobj 1 0 obj << /Type /Pages /Kids [ 13 0 R ] /Count 1 >> endobj 48 0 obj << /Creator (cairo 1.14.0 (http://cairographics.org)) /Producer (cairo 1.14.0 (http://cairographics.org)) >> endobj 49 0 obj << /Type /Catalog /Pages 1 0 R >> endobj xref 0 50 0000000000 65535 f 0000011958 00000 n 0000002574 00000 n 0000000015 00000 n 0000002551 00000 n 0000008800 00000 n 0000003015 00000 n 0000011668 00000 n 0000003310 00000 n 0000003606 00000 n 0000003902 00000 n 0000004199 00000 n 0000004495 00000 n 0000002786 00000 n 0000004792 00000 n 0000003288 00000 n 0000005089 00000 n 0000003584 00000 n 0000005386 00000 n 0000003880 00000 n 0000005683 00000 n 0000004177 00000 n 0000005980 00000 n 0000004473 00000 n 0000006277 00000 n 0000004770 00000 n 0000005016 00000 n 0000004994 00000 n 0000005313 00000 n 0000005291 00000 n 0000005610 00000 n 0000005588 00000 n 0000005907 00000 n 0000005885 00000 n 0000006204 00000 n 0000006182 00000 n 0000006501 00000 n 0000006479 00000 n 0000006574 00000 n 0000008184 00000 n 0000008208 00000 n 0000008518 00000 n 0000008541 00000 n 0000009194 00000 n 0000011036 00000 n 0000011060 00000 n 0000011388 00000 n 0000011411 00000 n 0000012024 00000 n 0000012152 00000 n trailer << /Size 50 /Root 49 0 R /Info 48 0 R >> startxref 12205 %%EOF interval-1.4.1/doc/image/octave-interval.ly.pdf0000644000175000017500000004314712657476043021022 0ustar oliveroliver%PDF-1.4 %쏢 5 0 obj <> stream xUN1 O፜DN.񊄐*JS7T >I{mSepKbۚn:Yfx|`†$% E#+ޚIog2?v֙X)Y3PoF:f1D:O#nf9=\v>RF62 N1%k{ĭ27p!cykjQ+O" 'frc`P ڟP!B%mm&adƘAs=U/9l۲uoendstream endobj 6 0 obj 294 endobj 4 0 obj <> /Contents 5 0 R >> endobj 3 0 obj << /Type /Pages /Kids [ 4 0 R ] /Count 1 >> endobj 1 0 obj <> endobj 7 0 obj <>endobj 12 0 obj <> endobj 13 0 obj <> endobj 10 0 obj <> endobj 8 0 obj <> endobj 16 0 obj <> endobj 11 0 obj <> endobj %BeginResource: file (PDF FontFile obj_14) 14 0 obj <>stream xy TS׺?dQԪ'`Vmζ#Z'Ty$@ aYD:`Zu޶׎kwPZ/\kobi1ruYxhnO߭n^=0r`V@2yh+=sH_,,-TCCľ29{vꫯ`ٲeOl?ށ!AT u@?O[q`toy^@ ~~!!s͵] L?x-U<88#88v Q atٻh1E,VZXmaMoaeb_ȴZmb<0c%nj@ NLC| "c|?6PI7Ay.Ll.v`0`ׇ}J2t}qQ'xݴtڱm՛=Z=ׅ/\ۻ&t^ ;0rRq^rֵ582j=j%ƪ**2XVȃ|T^}.K{;S 6;.;5;E$DhS+PE٭<޾w, nln:'B[[-2K߄'YnxYuȬ,o*li|6dBmz7Җ+TB~F2@pQ>y3 oƓqȢr0@IhhҶra)fWP`dGlm BUCj1F#aoN !@(CcIYc&t|&.tKnt{"KD@.\NFVRXYdrJF6'S3-d\?\-]-?aBZRd6iyo+Awݺyy-"vR ;飐F/،Vlu;gTG[w(ժ}G5kUX\0篍e,vXZXZX\R`cYf3VS6ZG)yt fT2gmN 2ZѝQ7uT.iZb}-qܟJ,wkFyc6q##s}ڱ[m؁^~8ݸq8~x_:{w;A0v 7'|c3fMƦljc'2qĐO:iҤe"'ɣ''GL>9)>Sʦ\S7Mu:_^$/\* *zklll+md7n -v>vQvYvev}g78s̕3 :S;0k'/O}y~Zcsp; x#d. iRd!spqgۜ}~<'uJ@N6rټ4!67}{0܁ f"bcCpYO$'U%3\'KL~\(64هw =~H*!3Ȁ: p =/4K0JV=ηU^o /wh7s=W [E^QY'y)! ;^M0Vxm\&M$ۑx?_HT$MGylp]dp`FQن~ }ZPKb9=E}\|}</govkrZ.^@W:gkȶ, ooDe 0Tr>Z4/W^-L+M@ OQ 90UDTK59;P#bs=^.$t47Iv.fqҵoul OKl9 W}"jY C8 *RygT G!z&:;mwT5 pua!P ZAu/Wwz)yBc:ywrSTQ3j<=Qe W'[n=䞨7D=+[^pgfn0(39(jGNp҈ (D:c_u|826Qx-)`J”b|?o9BJ҅2G; S")H&o (i' pߋOYx 1ЧU 3"%#n Ϡ n`4JTQj*n>rp 82kPgj!y|w1DB_v3 uh %%U&@)*` !93>= у?I+Ϣ jRTe*!"=0Tx3wZZƎT&!)CY@^Ď\Jj4|k9Oo ?I+YBaNC' -BQ~Fh%XISD$%A*ĦgmBKd@KmW1jPr]t]އڂ<g.OUv U{ZF2ۊu:}ecMAi=OB\ZLR$Ii+h!<  7_"06 wmom6C,&3+ !#գZ^HjTW;;F.ݻ[flW (N.NSeB.TvĘ\W %7EO ڮc+q2DS)tHϒgĦg N.?*`{F|q>B:+U6i>.B\:?>@+H;c 1 3k/m:LoK̿pGZ֪+= Bxhp) J&$cnĒ"3?t4E\( Rûk֭w{[^~wQs顖Z\%?ҪWGl? O>=o9=hW>S٧5g:׾w$%5@9fgd'JP_St)A.Iw8)&TZ/gnFN2$PQYL=- s  ht:MqAҞXm  ~ wy8*kqGu*o6Z/ Oh2מnk?滆n1F{|j]T'$w8ߔnIR ~`ਪ[ŰtpU8# o<ڴexMxdE7_CA.Ta$uX\ MG"\TXT](lVGwy|! xIrdX\CR>-I&OK I/}pPpHsV?|``\ PBR?%ƥ&vw^dqDf݇3^.@&R"n4h'>KAܖM_3=og'f? )ODiY=TzbfWiْ_x4yd}u@8)e:YYZdG\a2TYyFe&DdR S."Te) .e&".ckARA[#Pr%W0JKT&f|3VEP\ Hm"r^ObַVäҊbI-E)MOGI($*4@u:/ٌ*9?(!NmN<: -mFЋ3Ut(+T5&"ֲP_Fo ˈ׈@ ȕU9ٹ\u Pux7T*vm?Ο 퇰k1ho""q Z$5 AC% )dU;0꿛Lw} zp / o&y@\=0|}!bb0g0ЉΝYL6MRyX/%։Q iy sWj".y'Y_H TS[l˄Rc!G&Ny mx׌NA1ǖDA$"n+r1ѳiy$2sUhH͑3x{%l颪)g(Sw,0Ná.p޾mTEvmw;/p!2YH^V]?X[#Ӈ=..{]Nu;($~`\Wgr%)watyf;(^\Li}px\ dl2{1ϛEZڬҴJyq4C"65툌S4ߓ$'50D]8Dw< zS>SH)؛^BQZSЌ` *V* Im 1RGB@KE}Z]Cb:+M_+OЃ͑ S?IiaaCeDŽV%=P)42OyRhv%+¢ҪvhAn~@vFwӰUd(;4 ; <~# !v%4GYIOJ%t::Ql%#F$SaPu5\dN>nSsy>&B1wT|Xx6`=Ʒ0l9Q0l¡vūxpdp#;q;O`d=!3#C  4syJȆ:3P]<8EvdK'&ȋ%\JkGحDH+S2Z*r* Dwq<hۭ:.1Aױ|N=i8Mznf▒.}{¥.6;)#(B:5RE<*I*`? ;c1x%QΊ-<02 fPĠ a/.ZLJ5%8Kr,E+׹lkllTE(O*,<[֍ {CeWДKF9ޅ[p̐b#xu6"r:,-y*$ >?]\+x4D4ϸu])r&TYdq6©9N+Qd%2%L<@")XYg]Gic퇀z?]wܽ߰ܙOv\ xnF16 x]E09}Z'"c2FBTvc[rԘ']]~{֖}|E*aJI%RJX!#U= PmX'@泶C| [V 0u2>G “Z?`Ҵ s.UKkx/-$ٕh2-[_öuh*=K1ǜg9;,t` Gg?MI6Ñ$T+p^V~ |<=Ef¶%g9z4UC)-s 'ciW<tᣍwV̓Mny q0Wim]T5w",Lp-98DHԄ|jocI^˥Ճ*`rO!9!xrO@]'5“q ( G,>kA()t^0ͥ Ϳ,/fO=_d?!iHSxwʭ!^呍Zρ!6\AA`xj_->){v[(9"nSqn~]TY!a\pF>ƼZ!f-J'VUSMsD 7[MsDWucUFW*EIՍtUJpS5J.ms_CjZ^j^B4*n=Cx8ILt\i䰺Bok<\Dz.zIktX^4 I 8iתy 8<@IȫXd^K`[v9Z~cO`(44Jr&!{o|yùz\~߭O&`l$^rkZPҕ w(>'ΐ,Ql4l?'"˳!]|9N\ _f$*2܋B@,c_h&pC7iV֧Yxޡl/zO;۱,|Wtww\t[BͿfJocdt҇|@}>w>ap8x)ƫh=L/r0REWҕp}+BM9K29xp~> endobj %BeginResource: file (PDF FontFile obj_15) 15 0 obj <>stream x8 xI~0 M[AEEV CN!cCdfϙ}n !@ʩԢbUGmۉlD>yloG)*R3 ewN[<7)Ƅw#xc @Ro_ӷnt_Ⱦed"Wo/\J))V<,/SVfje\ejڢibeYFaMfa^VyYbrZUReVYRu^Iy9%Ԭ2eZ(%YQܼTJBH(NUeث%eCFZYǥ%e"cUjIbu.A%!..v)q7LJ&%Q;+7z_#ww#W_<0qgz&?ƅ^M$!Er+xj!Y' Vݙ\AN ݞIo|i0T$R@:~0_;&ɟrڋ*mJVCM{rc'2XrR!{8? .q^>do&bwmm D^;)X. Vج@rERÏrOi:[7;MEue<_#,mXZ:Y^t? @ܜ~bgaxNl˄) hX}$o,_Ҝ4%Xmlj8)O#"Ƹq}wȄi sV'&lN$)b' ;!861-qiD]"RT<5KNw2;ujS2%:%ϓ ܡ{=K'+bJ'$-HMy7g4|s?1lĄY##Nxoė#Ǎ4|cEiQwzxvӣъFkG;FcS5}1ɹɾ'|1m{&;5U^^p6ǪW d8K/ol!PwwD< ?nhFjbdtPR6Lf0gٹ;:9'r؝ BW댷wE;B(aɚuJ-$(@OƦa5+th= icg'Ee֭'s:;;:srr:-?45----Me#unf?F2mNOuJE ׼~}/Ȁ0 isG7O.yh]ņU-; (Oo0ᢔ/A?Q֚eksT9++hAV^ivЎ~[/D!g5(J'5u8u{Ոٍѵ@ӕ+JWff™-V$4fgq\Tڪ&Zu!lW! T36pEH:v)GՄ ֆ?n_ewCuA S>v8@*`Ky@{A\}RDhWz8elcD_N.X8֊'rcm5'T^.Lh>b-OY -vh:NLr-:V&Vm Pe ׊;ۥbXl1ŜbYbx:R/xp;+?X}pjdb_+)%O~ӠZfP/t'lc6?X d3 hv1x@U|:( i- D;:ڣ]90gqf C|aWkBg8\y9Dl :kWn[`س@Gj`w#0Gav My-l61MxuIh:n"<4{NCRwE2Wޔ\+z936WuLz ^o~{^L&.*7c%xHOC`BA}bF}ȥueAAȒKodz?ۜ>]qa3rB:Ӂ6Y߇sA_~L,Rri0К? fLc_ԏ8:=8 (cnsnׄ^CX"ʨc7>q W;y$z"|up=] kHQ_gvאҜ;َ&Gv}8 WʞC' ݵk+3j6.VVRf*и4='셭-[ i6CcfX09Fk347Lw Y ї*T"4i;/eVEyn~Jȩ4.m;-؁3,8.h{*And6#<OPf_RiՁupֺ@#GHEMY߹pXI4EeJt^fkA˵6; 8cB:wS'vvv50rKO^cK}0N\ NY1D2as%`wz-k6rlR9]QKz3^o,`^InF0Y '`@dV zwylþa)o&M KfP%5F,4rz-D4;.s^] ރnz7Qu:kmyv:ڣB18ef8a"Ƥ7ToR["̍)fPmtfgۣeZ0eRLC:[VJPU5_~@HMx"L)z/S@y B &oK+ D&"V-ө8iYjj! wRS `a}I+Sa=iuHfI|WWM |2g'0 UȚҤokUUMEY ,mǽ[܈p|63ke@9좘mpJyF޾k Γ!e%J~VIٵYF77a/0p[ +JŇF4%ZbPt+[kۼaۮ띳I H%n*quUEMt/88N=d,QE _`0XI`,L x.^V}"p/>2}#LWY/߷!䰸-=YϫO`\epb!Tp;;G|dD::@4Fth$"ZFiU&Ll5v3:Ԗ*oK!X1`1l5F)AZseLFh·r`3Smm7{iK9HdA:3ψ)j{Ԓ-7p kR%neL oɤBKq+/v\'}›u+9^ B28^8D_pw. 1,N.?9;t8#D%O[SggjrO-ZtN+]˂v࿥h_<0x@Pk|QF  oH?&:0a? ve3ŷ67>L㟥.6I..=J6dNV=Nu8-WqNsv|;=הm[Jg;YO&F0X3Yk`RF.ጕf+K>RDRM:µF)y'OYJEXTcI|JJZCsk8E*Q >voa_1gǫSѕn.ݢe C]VʲVFxLnu.XX.8E@L>@[Yk5Yl6)݄xl|ئk:7?iX.:y endstream endobj 17 0 obj <>stream 2016-02-13T01:43:15+01:00 2016-02-13T01:43:15+01:00 LilyPond 2.18.2 Untitled endstream endobj 2 0 obj <>endobj xref 0 18 0000000000 65535 f 0000000606 00000 n 0000017360 00000 n 0000000547 00000 n 0000000398 00000 n 0000000015 00000 n 0000000379 00000 n 0000000671 00000 n 0000001086 00000 n 0000009699 00000 n 0000000783 00000 n 0000001356 00000 n 0000000712 00000 n 0000000742 00000 n 0000001685 00000 n 0000009993 00000 n 0000001243 00000 n 0000015942 00000 n trailer << /Size 18 /Root 1 0 R /Info 2 0 R /ID [] >> startxref 17509 %%EOF interval-1.4.1/doc/image/inverse-power.svg.png0000644000175000017500000006174012657476044020712 0ustar oliveroliverPNG  IHDR\+ ]TsRGB, pHYsttfx IDATxy|_dC ~6 G |޳jok="xgzիjmAU[ P \1BBv53}>`n҉F"JOLy|/L6-[){ XI&Ʋb ^9.1LӬ,~=- ;xr|3Essp)q?7?;wj!esj,o\ ӽ!Fi]?z?,/Cuu{O*lk ,0N4kGr{@YL'k,7nV (EKaȒ%K6h$bݺu6t~g>4B)q{_`B;(.w7UUUi֭[ap*,rAn1A `+ѳ\ %K32;~Tx$NL6 l봶S4Yjjj6kw澂ėo0ƒ<={**gK_VwD"1=Ruiqq@w: q.#pfffި>u̘1,abo\ 7\D"FS7bĈ%H5 4 !:uY1w3ùfX g&rRS ݳ,xbc Z9yOJo 6m{B]NsqqZ3C|ZG=NJ+ض0`H<5=g?ܨmOg!Imup?\J3=ֺ| :|GeB-pfVt pM7r?2 6lؿ @@v8E4?ߨ#ޓ-#S"if۵7m']'~pna~?β g+}1pn'< ØovΌ `ҥmNkiirV\,x.=ǒ%K5]pxB3BD/**:U: i /}ؼ<_cYz۶k*&yoO3={,B'> KMq>_p+⛿4hst9_%%%ആmuSJ]hRVV7Nv ,||WJ)8p wĥtz]OeYgf;O)UFDmiv]/~ Ju8N ~О[=eYoɱ RѢD\0`8dId<ӳ:w9k1`N"zDcd5p[/'2`0xR*jTVa'W=qWlul-ӗ|""Z.p/EGp#c̈́s- `֭[mnn~0 XIa2ZByc8;|>c䀋o?۶ o7333p~EEENZV~ TYo$F-j޽{=sp1=ɫZb\ e>K>`S$9/B]c䡮nm---?~yt3_s5_{O2\LOm65.G♭<h8 @/=Nnz9uX?I*uɡ}{ @۷xض} {Or\L\OWSfk,[ԂX e}dbkB<#pI`+smZ b57%`z~{m2u$z x㍖;w6Dn{Rv֏anp 4hP${:w5jOf$q2[sOKCC.06Mr=,X?I"F@{9ĸ;ΝG!5~9:>Ni|c3֏!i_m۶RV~ \̝;7Fk?@ V!NKFh ##c&{Or\L`eD4l&3ഝ$D4e/R6y_Qnkkm޽ !&{0=o!I Ac,Cqz֮B<3Yٮ1La ZOM? ؂SPL%5k߽֜'}.B t J\k,B_ !!0IF}}JZZZNx 1׹cŊ{r*{O\̑[8w$LU}zD"}>:u A%2oǖcU'|U`B/ s… w7ӦMޓ>jW:ҥKx#==8~ Yf466>*Cqv }%pРA#A<ҹcժUGGHss{R%:PF|zZ_ H3 [۶,:Uiiic$)Β%Kvڶ]?jԨpytйCk9--B?:u=s];p*#< eERJr#`'lwɱ &Nx?mBYCGJy>>ՖeY4@'8d ˲Gakzn;3RFRFD)uᔇHlc0iҤ]iɪ2 d_" EDvyyȘh#/wl-pǼreYs΂3sV'MH)+"Z;f̘ VwI彞`'222 6l ;o<2?##4w4wG֛IZ }ɾZщys;jkk \ӟ'}.DC}}J!ꂂ,8'`].ؽ{YC5>هF8_$ ;h!ĵp8܏}sA"^*eDR =Ʋ1 O$f=0}43f=  '$"-KG~ܞ$%| ãܗf X-jjj^mll\F 3 d_@qOnn`_ZksssguΘȋFy^;GnND?C'3%c,OR)~v^[JKKdzȝ;\n,딾=sa$L`YVRZOu@|cYߚ`sy*0쓩M)U&ȻtxcҤI~LDMq֝ޓ>g" !.'Ko7H_m{lc3˷o~,!-:˼?Hd0%K !B\&ȣ;V\]v'x4=sp11"77i$Hwe;wnc,3\WW8DzڟG?a+opvEEE!!AܑKBZ0=eʔ=s O'Dt]YYه8̄3ew&kRJ5RV;~ >XUc88pc TJZГ$ ܕg qLp=D˗ظ-r0MJ2b:w8@p׮]zϑd9^v <\c,Ù2p~ZWRYu0Lj1r9Bͥ#q}NGˈr:Ĥo,\p7< &>ɔEѢ &8c<;N45 ѣG7&"J>Ft@eee&TogMR'~3 dD)**OTCwO!ѲX}y XV34+RJ'M{adL^"z;=h<$"5>FG,˲pO3 ow;5FqOxcN.>R=z~ >h+l-S!'>.#&]w@5Լ8wJ&ϱ0 RJ5;饔 dE1cdDײsy.e d^DD[*++q :`܀>,++޵,krz IJ nI>倄S"&{zðO2݀z# =LƤDV6,$=eûa#Ia}DR8'!'1D2lذ/}ZiY{ad@Ӑ!C$n|Ͱ0=H(:v*^F=A+2|RQeYbtG>wPJ"]#xbOtɥ))NMac#aH&ơC~a'lIl4AO@L©RsnJyG>ٷ 9DZuu]NwIOO2gDQVVVޓ>ǭ}QwsH8-I`,/X*/^! BהRz81 Xv\O 8NK[%Ћp!jK-[ 0WXuVozܘ*?q`͙.'AN6(VL}I,2hoqqKyI.VJUJfT3l$L af1}HD9+AXҕRJTңðO1RQۄ NKY";:v_`LiSN};vl~ngffzú`0xtboFFƎ`+zP~! ~ͽس5Rʻ~=!fYNd"zϔR-X`5;'ԡ&vM2[8DQJhY1 \}"z BGy|[x7&xϧ+2eD,Cm>% n9N2 ݹRrJW)5K)-,,3q'NXRRR" 5@D?ꮑäO2G7oDQG t|v@W)EJM)xENbt2IOݎ=M2-sT#cE ]_SJ56Wb#~IOp5qذaLYH8>?>R&4[cyv4{wsrr6lXRj'm$Xd! $ȆsYŞeMJG8S~7c;lVh/DT6v} z!i޳S?sssMRji[R Bc{K?}]MD-Jknjᖏ8$߭TJ]VVVGDie] ϥrkG| <#ٶmۑ<vudnXW%A1p IrmF%0!ZF"֭۰{q`DpbLg{<tq~6muY__H9' IDAT N~܅ p#wy;< r:_K,7~f׼+2gNck&ֺ9 477n.˲rE?}ˇ 'hiVL - @=ƍ;n1Ms3E-"N)EH4*6| {A8P{— )e~F)uRjׄ >)))3:k/ ~`R=s!''Gvy fI8u}/J)7B'hSJ=GDC8]яac*= A>Lh BD-D\ 8{?lOղDtuYY2"GDeYrF2l!Yp9?{hoڅ\%f"ݴiӲ=<G;a ?pDg% ׺t87Z$F=NFDPJAD4ByDtqۨ>0j>q=eUYYYQ~`f(v {==滞mДyR47k5i"ZEDwZuɞ֕R~sWn]'W}3Z `8_.Yd_4 Up-ro{Fù;NM~.p ~ -ٮ!up0f si6v7mqGaa~ `ֺ07۶fmm>>MR,vg`pÿsΝhUUUi!~%ŋW1w#U5x ND{/v7ļp8\xfkk!5:7֯ۺL-Rn m! > <\J/777 ʤv0RvR-R߷&?srrFVZZdG `%ZZ ,ŀ!Enj7J~1I$N}|v?@۷?ҝ,//D" !={<uA7I B$^`7I=f׼"rdee >|k>o2<ZZE"e˖#}`ڜ2L>l:R ܫ9sm۾~qgL8˔+tg d,siprZc333ljj}W(&8|ϧ2222D˄~ҲlŊ}i+3#\A+Wض {… ?9!{"'+2ǎ8H@X qԞ={BL4h FGmssx°O\vcMp juƍ۶m> ~5YvtЩ k$NVdmx+2q΃~ashdd ղ7(bYDTmE~ =@~ mﲑ0)I x7[YYOD+Q+=kY99[*2wpD WdocJ3ǭ|4O2L,iN"R[BPKii J`/1oڄq~'wHeY D4eʔ[233gtpBv"sPm,鄱?Nei}aD:%F"H)ui\E8H 8]Bygn% >4J"۵^ Kh[o0 s-, k>T۶[,Zt^:]AW adn# 6 c$8©ڎ;͛ojjڪI-}sǡ.\ @8E8N\oݺ5>ZNVO`,=Y ad\1-~hۻwV;0^-/ݠ-sǡ.\L ܺuk_e(&۶O2 #`NkDk]dѢEѵ ^q z>"'HywYY٠rڶ}a&̖֭wil2ᡘ@7:w_#CO~J&'j˲~zM.զi4i-eYYA+geeE=ࣱod~~ܧ>)`0[Ϗ`M˥rssLJi/&[oL x\JeRʦ|˛+RR7)ew:Ngc Q);MgK)[`|2ZPPp3m{}-Rb)e$ V{4[ |A) 󤔭@`(r1ó5Rʻ)jRʶ0x)erfuu4ͩ#G85nZoq֭kjjʖR^Y[__kD $$wwǶ*++3F#`Ҵ;kl X~zsǎDSޘso0+3|цaPgd¹Tkkk_gU'&UUUo߾ZZqa%Z룴Ä>ڵx9$ 222J谌W.\ >0ٮ](B=aI9pZ&KY֏aT9%F1 >T90 $J0 0 p0naX?a{R8bR!ĩ0 {\¹ 0  0 0 \ ?@Vc'|.&BeX?a{RR-$2Z2Vc'g*g?0@PWɠ ðOO2 5k.c#gH)Y֏ad{纗 c#'m31 {O*\*\88"Vc'pgex0 $$$3|b\ڋOlW{azdKII~`1c_^~`wl V%/'9@-;Yg4k>8˲0_! _/P~>ɰeÙ&opu εczh0'β'eirn0],I}aRo2 <+㼾K"6a_O2L$c^{ໝK=:ueYU{삊 }G2wy"U`/'}W}so[MLzO2r<7$~wɝ0LFgUvm3_}o;w~ueeeeYgfR{9hZ}1f)7:rG5SLßa>]I+[~衇qWûaD8}I]GbFfvvhb!1 $_v'۶?~{0w;tpgF'.)Nl}+%\z.ݝH)*~KeeCgqFs]]~W'ϻIEIFp@Z9) 8Rp8|iZZ"HڏOٓu۶m~V_N6-۶m>WjKJJ~6w(v&ռ'Y}nP򾶣R3Nʷ;DV|/'NL*{O2pp*O`u6G6>}/'N8L }˲N'"MDNm/~CL0AQCuuw5ޓ>ش ;%^Ç}jںU`z>헶m@5k]ͤ$eG !ړWJ]ˇ~JKX֏(lnSJ+¤$ωKKK [1[k}ŧ0guapjkkW2 sx+Vimm:[Q V`Q^!?aVa84{zŋ}D·B gX?gD"B[/Xqmۯr_E&'}\B5hР;v]urtHӣ< UUU/|UkaR{DRJ=bĈ{l>zɒ%S4͠)!D0kjjV90LEJ 3 ˗"q/]tҽtH:w}666NokkFD->,ϬXӯ/ùhaaY5btҏ9,]t͛_pRR5#Y֏YjkkBO2`@MMZ?Mk]cv=URL2zO2wzvvZ-hc`٦MB|q|$%3X֏qmR.\KwxȲ#& '|_\ ,8Ok}߂ z!n)0Ͷm׆I.m6U`gɒ% !~$sEEE!?}$:SNʊ1=sR{+2MsO(:*3d$AD& øN2%ϲghRj:+01_WWw-??oܸqמ={B\aYӡPh02Ip21G mٶm0˖-۱xSv<@e{~b6̛<^zm+u{+ Ӧy%`#G}}ִS Hyyk֬͛B\IDsh +$ ghSJ]'?! &l6577O0>oz۶CYjjj5Msgl8Wm'x4bV ae&|eY_QJ Dt'++++0>_4ID ܇a aѣ,ʎY۲e˙Bj!\#NvvvU`^J! !p:goXbŞo߾u9ޓ>?hZϫ, .ŋ6 s!;9:ddd|*~LP[[R2&M&m֯_J˲`{qb[[[r\ gLWSSDqSM kyD%`cٲe;Ҧ0`J<'i{֏Zu>8XnB;"zoĉ4!&?k, i }20'*"jVJ4FB-&5[u.GxV&ov!233c 1 Qܜmۮ0}ڵWUU /^@q⑒S,sG{lhhX߲ X=.V8%''geY x} IDAT|>mllx1I !{t.6؂hÚ.ZȰKGg^B\qnoNk%!ęDt Z=Jc'ݠ0旖N(++ˌl @ʕ+"Ti{{璛"`!F+#?@ Pqڍ%//U M ,++DDD4'&z j7$_D4wHRrFkkk^\cǎ---W!*r=|rҥ{ DttϚZ7M3Ȼ+X<?nB! |\>̺),X??$jjj6io}W[.f$aDλ/;ImmGap8|LLu#ܮR[[K/!3&VJc/~Zk}_IIɗ''fNk}ֺ PeػquhFF۶ADl`z]F9997zǶmۆ !KJJ~g~;-[öp\HVVZ1 >}ҥKW^mOa@a>Mmmml_TJ͊ Q__Xk}a Y`A$ RJ"l455U !'x|$+xH)*~LrSSSN[hh)&]WWBcccZ[[\. }.s\\dɒ1b4e&$Ϋho[x%`1)P[[4$ 6<+(޽{u{%[5@(1$ Xd=1féuz|k^avU`1).JOO1f̘G< 85J2=sZ/ivO_^CfcǎH)GL7`'R3hO29r {h_`___I=M N~ H0e{]Դ!r '''U`IvhwyǠpf?0bݺu.d+>jW!x,8 Gŋ? ~Ȑ!?sM`k,,Ӆeq-.?dX?&u|.BXe}֋F˖-myϥTyc]wײDԢg88ѥDg@ HQo_RLr*>NKK[zx|4KD|{7\I[ZZ ^c,ED^sp>ji+ƌSAuwYBDgTpu'ؚ`2ڮpf̝;7 ɖeMl׹~?ٶGb8b .lp'C 9#p 4^t{ip=whǤ&<`'؊۹#p˲d{R8FjkkypTlHkk$"uZVcRezJsǒ%Kvܹh41cdt=s)@O&*#iV~wX ,z^g.}5DV1NEq4 ci[rCL3\L]]R!Æa&N5GqB8β*V/:k~m*,, i'}mnz \ 1J/zH_'?f~YNoH¯u >wY?9 6|LҔ ؚ`G(F!{7\l}喉X NO/#ƒ#T4ͩ:7%: N^l >xODe:Y&.!U{=]>McqڌĖ@3]='AGNz$xbbsgI&Q951H$QLiA.pЍ@ }{T* y*_zWqR|9p'Ƙk@p.gٳS!ZZZ07F[ͳaudX-8ZkK7CSv+ty5O}SZLu;/W^[_VID9R"u -WY3[*;JD#%hY>}lMMM;gwߩsxiHiOם7I~"q~dF<gV5775ƌ95\QCC~kjeK1d^וּυX|=ة|ŋ?gO|Y`^/|`cGGު))pgEEER2fKUb0o\U?s{ii9.8+:Z1"uGt}6\X TǮghvMf 6zV)(S)D9yDSԷ24dOZMM%A4uO< \Ef{ǩq?+//?oYp{U?#b{1uD oHqLy<3fTb >pK.b}f̘1 }M4idfny=~|Dqlm'gڵƘǹH-;tڿW 6{k\؝ĵ Լ]puݍ555WMDSLJSgr<]D555ծvTUU +Wpoӽv ߐfNlwpԩSlH ys<ϛHm0ܜٚC/n&Ts-ljyhرsw |Sk׮1Ɯ?u\OrBUAȘ*?2I3fG +{?u`/ S;NB3gΜ4{+>{6uvv^fJI᪯V94u03iΩy=C_!/sN ׉.<ҷoҪ_l.3VT9pܷoeqVv<8Z׫D`FqbW~IprǢE kΩ: ,X%K5,XZՙа x;v,ST?FNٱXrcr4[ Nb SL! cCSu/? :sel7ttt,^,W D''6[k+ Xե"=a̹|h六xl+N\SȀz`ڴieY}4U."QI1O'6rl_#h]T\o ׅ"444,v13X1oz~Q3`s;uB;^i'9kh?sr)F2-'k%84̫׀էFMkٮR"dd$ƍ[cg5[O9zqJhgOK9w aڵ 555_HR[\0qughHHr2߻?vUUUhX" VH>_ƟJgPFT"0yz_p1fރ"<qwh644xJC#ui؂?UםtJ]F/8RQdN-T?fNN4i^IIc*2f2UUU-u]̞0\>p L/!!Kr4[ohxQ"xΘ1#M.ONHN.+MkJKK/"kf+C={Јl.!4&l0k ƍlf[1 @O;E礩~rbr2Y8 6|YƘ:=Ɯs4£*++¡ ]Wq m cSEH{q9~_|EE/1UUUTHfOrN W,X [8|ʼZ[: 4bO}!PVSSsf3ظQTTYfOsN WXk߀v*NSZ#ItXb1fql=\M3iZkTŢ=a95\᳠o߾N ;v&q O"oyӃfkp QhU*U'9+dqMN;&5ڱcROtq \`y)=ghkky-`1p-A,^qL< lFʭ5RT?6kBcLѠA1W߸q73}bU,ZƜS ٚ ̰־K\ >;.5\% H oQ0_-Y8V,cVG-H pF'yq L4"`[t(j>{0|95\Ykeܩl=`H5\A!""Vl<x(-5\rt0`9w۱c >}zq L&d]^4[M8F1p号JJJxr۶muD aYAZk׵>¡'1j"=a95\Šzཨ\577pPDz -f~1pϕ*` J3ǁQZ8ߡo[vY6cLĉR=95\c٧Oyx :c"p>L|iFEc8X'9+O444tT< yTNߵKzGIZ w]<ٚ֞&(I=95\ed-fFKN_7Q/&0To3gǏ_cN `Zk7ѪDfq= +,ׯ_'YwxZ;6 Eعs" ~//}U-7sINٺ8 8NiAvǿkLCـQUxVr,ݰa Dd WEEE^r \ x >j%+wmֶQt8]5`#p0 d2iǩ_CezWQimm{b;tKGr2JJJ0ڊWׯEEE޽[/Û)cK;;;?lQD䃬f,ok&@D3r2|u@J#"TshMHX OaIDATrȑG*Š>H\%)rRf+4g, (gwo`0_{/Jo'-թ4TVJi4,+(M"g]<t zGJQVJOOx`ʣŶ mX^GJQVBZ,9 v0E T[3+TQN(+U!} ޓgve,;r<- |S夈X9x\?LnnQVBrp$"I夈~_eQN1*rRDkXBeQNG%*M8]B6D"TNѻ j[@9x)ˁ/L"TNJ 'P "0 &0#T&QN*' 1ȠFIENDB`interval-1.4.1/doc/image/octave-interval.ly.png0000644000175000017500000001115012657476043021022 0ustar oliveroliverPNG  IHDRlF3 6iCCPdefault_rgb.iccxgP} tXz*eIK,K!b"4ER$VDY$(1ETP;}~=;眙@@ERR|?{NHh!n ( V}](1<X|^:_f ]VTR9 ,~HhrXq_}XQ_}X?@}Q( 1XAN$?bqspbc9*AL!-}?!.^F/{ ؾj]RT0 _3(H&%؂7@(lC !aA 샃P-.yxK:DED A.b8!D qH*#;Ar # db( e:rQ; @ףqh{*=vW(*D_ `T)as0,c[bkڱ^l 9#c88]%2p[q \w7}rx f|'~?O  JH$l&: ÄIH&HXD&$^"HT"ɈL # HVEiD%-h&rKC"/Q(+J%REi\SRTe9՗@NޠNP?i4Z8-vvNmat}/~A)'&-MVKdD5Pc1603;9QhVZsc bL1C1oRVb3Dquq'hBcW'S1w2טS,KJd~f %%%$r%j%.H[NfO?IKIHl\*$͑vN/-T'-+#sD̜,KR'[,{Z*-'Yܠ܂||U9BBEYEbb%ŗ 'S+)*e)5( )-)k(*(w(?UpUbU*TTUUTUTոjj5ԃwwhHiiiik5m4345kZIZj&ڵwtPS:ëWj\5KӵmӝcyuW߯? ٠aaFF¾}?Q.VW>y@WoVW:$VW\_3Zk_Q'Wnp#GK?M8QXMAM?qjii.i|<߉Vֲ6-mdɻ?;Ӯ(9N%=Ni?vY܅tm s?kޯ+ q"bŕKy._weocߓ!W]vvnX8[[ݷMow vf[P;=w8b3r];: ñ13yxqxSѧ5{Txaqb'Wdn!m8H)u]uqq xSUy8j[v9B$Icr"]׳,(ʲLu4Mu] }_AxOaBƘeY8)!6tb'ieY:. S*q7"q*~xpuuǏUT;c ߿ OOO_|`ׯǏ풨Z0 7,s˲RJ0J >`Ɔn@nc.<ϱjZ5UV]εjvsh,Bl]!NUoN<"Y%ELI)ιz0 2)eHh'q_ [kdGѲ%Z;=TMdgЪnN?bYcL4!ІknIt]W1eYiҎEA5DX3RaQ4r 9 (R8qZN*4}p/7Dd2L&HTx٪%@1BM}?z2<|Ç]],)ԧ넝 krs!Lh" C˲,˚/DՔ՚c)SR. ^3a1eY֔)f k> P'sD 0fA'EQ9JZ$IRh`0P?tHDu(<OnU!|-6219u# <;)@Qxjd̩ I`2rgs+ގ Hd#GYsuVp&twيyi:Q+ds $q6p8\XdTc|C2H{a$I(Qmsk #lנW $pǦi4t]/b4!%g۶nZGXly*Jg#ޡj:dGUW$C 5*6ʔܣu^g4M0}۶18:m۰]Ee( 0 (Y<_x4QR"I],k ~/0TaШj:ەue- A [cQz,:18n7y<C*T-iV1 ÀVoBYս8nHG6&`%R+1N *u;tu]]訞#5R GzN KE0j~"}<σ!iTYUyֱu[Z e14M8^ v]ZE L81MjvEq,֐ ǁ1<}) mIENDB`interval-1.4.1/inst/test/mpfr_vector_dot_d.cc-tst0000644000175000017500000000067212657476044021521 0ustar oliveroliver## DO NOT EDIT! Generated automatically from src/mpfr_vector_dot_d.cc %!test; %! [l, u] = mpfr_vector_dot_d (-1, -1, 2, 3); %! assert (l, -3); %! assert (u, 6); %!test; %! x = [realmax, realmax, -realmax, -realmax, 1, eps/2]; %! y = ones (size (x)); %! [l, u] = mpfr_vector_dot_d (x, y, x, y); %! assert (l, 1); %! assert (u, 1 + eps); %!test; %! [l, u] = mpfr_vector_dot_d (0, 0, inf, inf); %! assert (l, 0); %! assert (u, inf); interval-1.4.1/inst/test/mpfr_vector_sum_d.cc-tst0000644000175000017500000000040612657476044021532 0ustar oliveroliver## DO NOT EDIT! Generated automatically from src/mpfr_vector_sum_d.cc %!assert (mpfr_vector_sum_d (0, [eps, realmax, realmax, -realmax, -realmax]), eps) %!assert (mpfr_vector_sum_d (-inf, [eps/2, 1]), 1) %!assert (mpfr_vector_sum_d (+inf, [eps/2, 1]), 1 + eps) interval-1.4.1/inst/test/mpfr_to_string_d.cc-tst0000644000175000017500000000027712657476044021362 0ustar oliveroliver## DO NOT EDIT! Generated automatically from src/mpfr_to_string_d.cc %!test; %! [s, isexact] = mpfr_to_string_d (-inf, "decimal", .1); %! assert (s, {"0.1"}); %! assert (isexact, false); interval-1.4.1/inst/test/mpfr_matrix_mul_d.cc-tst0000644000175000017500000000043312657476044021525 0ustar oliveroliver## DO NOT EDIT! Generated automatically from src/mpfr_matrix_mul_d.cc %!test; %! [l, u] = mpfr_matrix_mul_d (magic (3), magic (3)', magic (3) + 1, magic (3)' + 1); %! assert (l, [101, 71, 53; 71, 83, 71; 53, 71, 101]); %! assert (u, [134, 104, 86; 104, 116, 104; 86, 104, 134]); interval-1.4.1/inst/test/__setround__.cc-tst0000644000175000017500000000071712657476044020461 0ustar oliveroliver## DO NOT EDIT! Generated automatically from src/__setround__.cc %!test %! __setround__ (+inf); %! assert (1 + realmin > 1, true); %! assert (1 - realmin == 1, true); %! __setround__ (0.5); %!test %! __setround__ (-inf); %! assert (1 + realmin == 1, true); %! assert (1 - realmin < 1, true); %! __setround__ (0.5); %!test %! __setround__ (0.5); %! assert (1 + realmin == 1, true); %! assert (1 - realmin == 1, true); %!shared %! __setround__ (0.5); interval-1.4.1/inst/test/mpfr_linspace_d.cc-tst0000644000175000017500000000034412657476044021143 0ustar oliveroliver## DO NOT EDIT! Generated automatically from src/mpfr_linspace_d.cc %!assert (mpfr_linspace_d (-inf, 1, 10, 10), 1 : 10); %!assert (mpfr_linspace_d (inf, 1, 10, 8) - mpfr_linspace_d (-inf, 1, 10, 8), [0 2 2 4 4 4 8 0] .* eps); interval-1.4.1/inst/test/mpfr_function_d.cc-tst0000644000175000017500000000044612657476044021175 0ustar oliveroliver## DO NOT EDIT! Generated automatically from src/mpfr_function_d.cc %!assert (mpfr_function_d ('plus', 0, 2, 2), 4); %!assert (mpfr_function_d ('plus', -inf, 1, eps / 2), 1); %!assert (mpfr_function_d ('plus', +inf, 1, eps / 2), 1 + eps); %!error mpfr_function_d ('Krauskefarben', 0, 47, 11); interval-1.4.1/inst/test/libieeep1788_tests_overlap.tst0000644000175000017500000002221612657476044022515 0ustar oliveroliver## DO NOT EDIT! Generated automatically from test/libieeep1788_tests_overlap.itl ## by the Interval Testing Framework for IEEE 1788. ## https://github.com/nehmeier/ITF1788/tree/635bff73cc64ff8aab0ff2031ee8a53980be0115 ## ## Copyright 2013-2015 Marco Nehmeier (nehmeier@informatik.uni-wuerzburg.de) ## Copyright 2015-2016 Oliver Heimlich ## ## Original author: Marco Nehmeier (unit tests in libieeep1788, ## original license: Apache License 2.0) ## Converted into portable ITL format by Oliver Heimlich with minor corrections. ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## %!#Test library imports %!#Arithmetic library imports pkg load interval %!#Preamble try; error ("__FILE__"); catch test (lasterror.stack.file, "quiet", stdout); end_try_catch; %!function assert_warn (observed_value, expected_value) %! if (not (isequal (observed_value, expected_value))) %! observed_expression = regexprep (argn(1, :), '\s+$', ''); %! expected_expression = regexprep (argn(2, :), '\s+$', ''); %! observed_as_char = disp (observed_value)(1 : end - 1); %! expected_as_char = disp(expected_value)(1 : end - 1); %! warning ([observed_expression, " != ", expected_expression, ... %! "\n ", observed_as_char, " != ", expected_as_char]); %! endif %!endfunction ## minimal_overlap_test %!test %! assert (isequal (overlap (infsup, infsup), "bothEmpty")); %!test %! assert (isequal (overlap (infsup, infsup (1.0, 2.0)), "firstEmpty")); %!test %! assert (isequal (overlap (infsup (1.0, 2.0), infsup), "secondEmpty")); %!test %! assert (isequal (overlap (infsup (-inf, 2.0), infsup (3.0, inf)), "before")); %!test %! assert (isequal (overlap (infsup (-inf, 2.0), infsup (3.0, 4.0)), "before")); %!test %! assert (isequal (overlap (infsup (2.0, 2.0), infsup (3.0, 4.0)), "before")); %!test %! assert (isequal (overlap (infsup (1.0, 2.0), infsup (3.0, 4.0)), "before")); %!test %! assert (isequal (overlap (infsup (1.0, 2.0), infsup (3.0, 3.0)), "before")); %!test %! assert (isequal (overlap (infsup (2.0, 2.0), infsup (3.0, 3.0)), "before")); %!test %! assert (isequal (overlap (infsup (2.0, 2.0), infsup (3.0, inf)), "before")); %!test %! assert (isequal (overlap (infsup (-inf, 2.0), infsup (2.0, 3.0)), "meets")); %!test %! assert (isequal (overlap (infsup (1.0, 2.0), infsup (2.0, 3.0)), "meets")); %!test %! assert (isequal (overlap (infsup (1.0, 2.0), infsup (2.0, inf)), "meets")); %!test %! assert (isequal (overlap (infsup (1.0, 2.0), infsup (1.5, 2.5)), "overlaps")); %!test %! assert (isequal (overlap (infsup (1.0, 2.0), infsup (1.0, inf)), "starts")); %!test %! assert (isequal (overlap (infsup (1.0, 2.0), infsup (1.0, 3.0)), "starts")); %!test %! assert (isequal (overlap (infsup (1.0, 1.0), infsup (1.0, 3.0)), "starts")); %!test %! assert (isequal (overlap (infsup (1.0, 2.0), infsup (-inf, inf)), "containedBy")); %!test %! assert (isequal (overlap (infsup (1.0, 2.0), infsup (-inf, 3.0)), "containedBy")); %!test %! assert (isequal (overlap (infsup (1.0, 2.0), infsup (0.0, 3.0)), "containedBy")); %!test %! assert (isequal (overlap (infsup (2.0, 2.0), infsup (0.0, 3.0)), "containedBy")); %!test %! assert (isequal (overlap (infsup (2.0, 2.0), infsup (0.0, inf)), "containedBy")); %!test %! assert (isequal (overlap (infsup (1.0, 2.0), infsup (-inf, 2.0)), "finishes")); %!test %! assert (isequal (overlap (infsup (1.0, 2.0), infsup (0.0, 2.0)), "finishes")); %!test %! assert (isequal (overlap (infsup (2.0, 2.0), infsup (0.0, 2.0)), "finishes")); %!test %! assert (isequal (overlap (infsup (1.0, 2.0), infsup (1.0, 2.0)), "equals")); %!test %! assert (isequal (overlap (infsup (1.0, 1.0), infsup (1.0, 1.0)), "equals")); %!test %! assert (isequal (overlap (infsup (-inf, 1.0), infsup (-inf, 1.0)), "equals")); %!test %! assert (isequal (overlap (infsup (-inf, inf), infsup (-inf, inf)), "equals")); %!test %! assert (isequal (overlap (infsup (3.0, 4.0), infsup (2.0, 2.0)), "after")); %!test %! assert (isequal (overlap (infsup (3.0, 4.0), infsup (1.0, 2.0)), "after")); %!test %! assert (isequal (overlap (infsup (3.0, 3.0), infsup (1.0, 2.0)), "after")); %!test %! assert (isequal (overlap (infsup (3.0, 3.0), infsup (2.0, 2.0)), "after")); %!test %! assert (isequal (overlap (infsup (3.0, inf), infsup (2.0, 2.0)), "after")); %!test %! assert (isequal (overlap (infsup (2.0, 3.0), infsup (1.0, 2.0)), "metBy")); %!test %! assert (isequal (overlap (infsup (2.0, 3.0), infsup (-inf, 2.0)), "metBy")); %!test %! assert (isequal (overlap (infsup (1.5, 2.5), infsup (1.0, 2.0)), "overlappedBy")); %!test %! assert (isequal (overlap (infsup (1.5, 2.5), infsup (-inf, 2.0)), "overlappedBy")); %!test %! assert (isequal (overlap (infsup (1.0, inf), infsup (1.0, 2.0)), "startedBy")); %!test %! assert (isequal (overlap (infsup (1.0, 3.0), infsup (1.0, 2.0)), "startedBy")); %!test %! assert (isequal (overlap (infsup (1.0, 3.0), infsup (1.0, 1.0)), "startedBy")); %!test %! assert (isequal (overlap (infsup (-inf, 3.0), infsup (1.0, 2.0)), "contains")); %!test %! assert (isequal (overlap (infsup (-inf, inf), infsup (1.0, 2.0)), "contains")); %!test %! assert (isequal (overlap (infsup (0.0, 3.0), infsup (1.0, 2.0)), "contains")); %!test %! assert (isequal (overlap (infsup (0.0, 3.0), infsup (2.0, 2.0)), "contains")); %!test %! assert (isequal (overlap (infsup (-inf, 2.0), infsup (1.0, 2.0)), "finishedBy")); %!test %! assert (isequal (overlap (infsup (0.0, 2.0), infsup (1.0, 2.0)), "finishedBy")); %!test %! assert (isequal (overlap (infsup (0.0, 2.0), infsup (2.0, 2.0)), "finishedBy")); ## minimal_overlap_dec_test %!test %! assert (isequal (overlap (infsupdec (empty, "trv"), infsupdec (empty, "trv")), "bothEmpty")); %!test %! assert (isequal (overlap (infsupdec (empty, "trv"), infsupdec (1.0, 2.0, "com")), "firstEmpty")); %!test %! assert (isequal (overlap (infsupdec (1.0, 2.0, "def"), infsupdec (empty, "trv")), "secondEmpty")); %!test %! assert (isequal (overlap (infsupdec (2.0, 2.0, "def"), infsupdec (3.0, 4.0, "def")), "before")); %!test %! assert (isequal (overlap (infsupdec (1.0, 2.0, "dac"), infsupdec (3.0, 4.0, "com")), "before")); %!test %! assert (isequal (overlap (infsupdec (1.0, 2.0, "com"), infsupdec (3.0, 3.0, "trv")), "before")); %!test %! assert (isequal (overlap (infsupdec (2.0, 2.0, "trv"), infsupdec (3.0, 3.0, "def")), "before")); %!test %! assert (isequal (overlap (infsupdec (1.0, 2.0, "def"), infsupdec (2.0, 3.0, "def")), "meets")); %!test %! assert (isequal (overlap (infsupdec (1.0, 2.0, "dac"), infsupdec (1.5, 2.5, "def")), "overlaps")); %!test %! assert (isequal (overlap (infsupdec (1.0, 2.0, "def"), infsupdec (1.0, 3.0, "com")), "starts")); %!test %! assert (isequal (overlap (infsupdec (1.0, 1.0, "trv"), infsupdec (1.0, 3.0, "def")), "starts")); %!test %! assert (isequal (overlap (infsupdec (1.0, 2.0, "def"), infsupdec (0.0, 3.0, "dac")), "containedBy")); %!test %! assert (isequal (overlap (infsupdec (2.0, 2.0, "trv"), infsupdec (0.0, 3.0, "def")), "containedBy")); %!test %! assert (isequal (overlap (infsupdec (1.0, 2.0, "trv"), infsupdec (0.0, 2.0, "com")), "finishes")); %!test %! assert (isequal (overlap (infsupdec (2.0, 2.0, "def"), infsupdec (0.0, 2.0, "dac")), "finishes")); %!test %! assert (isequal (overlap (infsupdec (1.0, 2.0, "def"), infsupdec (1.0, 2.0, "def")), "equals")); %!test %! assert (isequal (overlap (infsupdec (1.0, 1.0, "dac"), infsupdec (1.0, 1.0, "dac")), "equals")); %!test %! assert (isequal (overlap (infsupdec (3.0, 4.0, "trv"), infsupdec (2.0, 2.0, "trv")), "after")); %!test %! assert (isequal (overlap (infsupdec (3.0, 4.0, "def"), infsupdec (1.0, 2.0, "def")), "after")); %!test %! assert (isequal (overlap (infsupdec (3.0, 3.0, "com"), infsupdec (1.0, 2.0, "dac")), "after")); %!test %! assert (isequal (overlap (infsupdec (3.0, 3.0, "def"), infsupdec (2.0, 2.0, "trv")), "after")); %!test %! assert (isequal (overlap (infsupdec (2.0, 3.0, "def"), infsupdec (1.0, 2.0, "trv")), "metBy")); %!test %! assert (isequal (overlap (infsupdec (1.5, 2.5, "com"), infsupdec (1.0, 2.0, "com")), "overlappedBy")); %!test %! assert (isequal (overlap (infsupdec (1.0, 3.0, "dac"), infsupdec (1.0, 2.0, "def")), "startedBy")); %!test %! assert (isequal (overlap (infsupdec (1.0, 3.0, "com"), infsupdec (1.0, 1.0, "dac")), "startedBy")); %!test %! assert (isequal (overlap (infsupdec (0.0, 3.0, "com"), infsupdec (1.0, 2.0, "dac")), "contains")); %!test %! assert (isequal (overlap (infsupdec (0.0, 3.0, "com"), infsupdec (2.0, 2.0, "def")), "contains")); %!test %! assert (isequal (overlap (infsupdec (0.0, 2.0, "def"), infsupdec (1.0, 2.0, "trv")), "finishedBy")); %!test %! assert (isequal (overlap (infsupdec (0.0, 2.0, "dac"), infsupdec (2.0, 2.0, "def")), "finishedBy")); interval-1.4.1/inst/test/pow_rev.tst0000644000175000017500000030733012657476045017122 0ustar oliveroliver## DO NOT EDIT! Generated automatically from test/pow_rev.itl ## by the Interval Testing Framework for IEEE 1788. ## https://github.com/nehmeier/ITF1788/tree/635bff73cc64ff8aab0ff2031ee8a53980be0115 ## ## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## %!#Test library imports %!#Arithmetic library imports pkg load interval %!#Preamble try; error ("__FILE__"); catch test (lasterror.stack.file, "quiet", stdout); end_try_catch; %!function assert_warn (observed_value, expected_value) %! if (not (isequal (observed_value, expected_value))) %! observed_expression = regexprep (argn(1, :), '\s+$', ''); %! expected_expression = regexprep (argn(2, :), '\s+$', ''); %! observed_as_char = disp (observed_value)(1 : end - 1); %! expected_as_char = disp(expected_value)(1 : end - 1); %! warning ([observed_expression, " != ", expected_expression, ... %! "\n ", observed_as_char, " != ", expected_as_char]); %! endif %!endfunction ## minimal.powRev1_test ## ## The following tests use boundaries for the first parameter whose reciprocal ## can be computed without round-off error in a binary floating-point context. ## Thus, an implementation should be able to compute tight results with the ## formula x = z ^ (1 / y) for the intervals used here. ## ## The test values are structured according to table B.1 in ## Heimlich, Oliver. 2011. “The General Interval Power Function.” ## Diplomarbeit, Institute for Computer Science, University of Würzburg. ## http://exp.ln0.de/heimlich-power-2011.htm. ## %!# Empty intervals %!test %! assert (isequal (powrev1 (infsup, infsup, infsup), infsup)); %!test %! assert (isequal (powrev1 (infsup, infsup (-inf, inf), infsup), infsup)); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup, infsup), infsup)); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (-inf, inf), infsup), infsup)); %!test %! assert (isequal (powrev1 (infsup, infsup, infsup (-inf, inf)), infsup)); %!test %! assert (isequal (powrev1 (infsup, infsup (-inf, inf), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup, infsup (-inf, inf)), infsup)); %!# Entire range %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (-inf, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!# Outside of the function's domain %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (-inf, inf), infsup (-inf, -1.0)), infsup)); %!test %! assert (isequal (powrev1 (infsup (-inf, -1.0), infsup (-inf, inf), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (powrev1 (infsup (-inf, 0.0), infsup (-inf, inf), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (powrev1 (infsup (-inf, 0.0), infsup (-inf, 0.0), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (powrev1 (infsup (-inf, 0.0), infsup (-inf, 0.9), infsup (0.0, 1.0)), infsup)); %!test %! assert (isequal (powrev1 (infsup (-inf, 0.0), infsup (1.1, inf), infsup (1.0, inf)), infsup)); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (1.1, inf), infsup (0.0, 1.0)), infsup)); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (-inf, 0.9), infsup (1.0, inf)), infsup)); %!test %! assert (isequal (powrev1 (infsup (0.0, 0.0), infsup (1.0, 1.0), infsup (-inf, 0.0)), infsup)); %!# 0^y = 0 %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.0, 0.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (-inf, 0.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (-inf, 0.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.0, 0.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (powrev1 (infsup (1.0, 2.0), infsup (0.0, 0.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (powrev1 (infsup (1.0, 1.0), infsup (0.0, 0.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!# 1^y = x^0 = 1 %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (1.0, 1.0), infsup (1.0, 1.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, 0.0), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 0.0), infsup (1.0, 1.0), infsup (2.0, 3.0)), infsup (2.0, 3.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (1.0, 1.0), infsup (20.0, 30.0)), infsup (20.0, 30.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, 0.0), infsup (1.0, 1.0), infsup (1.0, 1.0)), infsup (1.0, 1.0))); %!# y < 0, z overlaps/starts [0,1] %!test %! assert (isequal (powrev1 (infsup (-4.0, -2.0), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (1.189207115002721027e+00, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, -2.0), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, -2.0), infsup (-inf, 0.5), infsup (-inf, inf)), infsup (1.189207115002721027e+00, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, -2.0), infsup (-inf, 0.5), infsup (-inf, inf)), infsup (1.0, inf))); %!# y < 0, z containedBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (-4.0, -2.0), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (1.189207115002721027e+00, 2.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, -2.0), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (1.0, 2.0))); %!# y < 0, z finishes [0, 1] %!test %! assert (isequal (powrev1 (infsup (-4.0, -2.0), infsup (0.25, 1.0), infsup (-inf, inf)), infsup (1.0, 2.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, -2.0), infsup (0.25, 1.0), infsup (-inf, inf)), infsup (1.0, 2.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, -2.0), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (1.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, -2.0), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (1.0, 1.0))); %!# y < 0, z equals/finishedBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (-4.0, -2.0), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, -2.0), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (1.0, inf))); %!# y < 0, z contains/startedBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (-4.0, -2.0), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (7.071067811865474617e-01, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, -2.0), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (7.071067811865474617e-01, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, -2.0), infsup (0.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, -2.0), infsup (0.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, -2.0), infsup (-inf, 2.0), infsup (-inf, inf)), infsup (7.071067811865474617e-01, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, -2.0), infsup (-inf, 2.0), infsup (-inf, inf)), infsup (7.071067811865474617e-01, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, -2.0), infsup (-inf, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, -2.0), infsup (-inf, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!# y < 0, z overlappedBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (-4.0, -2.0), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (7.071067811865474617e-01, 1.414213562373095145e+00))); %!test %! assert (isequal (powrev1 (infsup (-inf, -2.0), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (7.071067811865474617e-01, 1.414213562373095145e+00))); %!test %! assert (isequal (powrev1 (infsup (-4.0, -2.0), infsup (0.5, inf), infsup (-inf, inf)), infsup (0.0, 1.414213562373095145e+00))); %!test %! assert (isequal (powrev1 (infsup (-inf, -2.0), infsup (0.5, inf), infsup (-inf, inf)), infsup (0.0, 1.414213562373095145e+00))); %!# y < 0, z metBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (-4.0, -2.0), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (7.071067811865474617e-01, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, -2.0), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (7.071067811865474617e-01, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, -2.0), infsup (1.0, inf), infsup (-inf, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, -2.0), infsup (1.0, inf), infsup (-inf, inf)), infsup (0.0, 1.0))); %!# y < 0, z after [0, 1] %!test %! assert (isequal (powrev1 (infsup (-4.0, -2.0), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (0.5, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (-inf, -2.0), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (0.5, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, -2.0), infsup (2.0, inf), infsup (-inf, inf)), infsup (0.0, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (-inf, -2.0), infsup (2.0, inf), infsup (-inf, inf)), infsup (0.0, 1.0))); %!# y = 0, z overlaps/starts [0,1] %!test %! assert (isequal (powrev1 (infsup (0.0, 0.0), infsup (0.0, 0.5), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (powrev1 (infsup (0.0, 0.0), infsup (-inf, 0.5), infsup (-inf, inf)), infsup)); %!# y = 0, z containedBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (0.0, 0.0), infsup (0.25, 0.5), infsup (-inf, inf)), infsup)); %!# y = 0, z finishes [0, 1] %!test %! assert (isequal (powrev1 (infsup (0.0, 0.0), infsup (0.25, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 0.0), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!# y = 0, z equals/finishedBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (0.0, 0.0), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!# y = 0, z contains/startedBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (0.0, 0.0), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 0.0), infsup (0.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 0.0), infsup (-inf, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 0.0), infsup (-inf, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!# y = 0, z overlappedBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (0.0, 0.0), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 0.0), infsup (0.5, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!# y = 0, z metBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (0.0, 0.0), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 0.0), infsup (1.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!# y = 0, z after [0, 1] %!test %! assert (isequal (powrev1 (infsup (0.0, 0.0), infsup (2.0, 4.0), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (powrev1 (infsup (0.0, 0.0), infsup (2.0, inf), infsup (-inf, inf)), infsup)); %!# y finishedBy 0, z overlaps/starts [0,1] %!test %! assert (isequal (powrev1 (infsup (-4.0, 0.0), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (1.189207115002721027e+00, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 0.0), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 0.0), infsup (-inf, 0.5), infsup (-inf, inf)), infsup (1.189207115002721027e+00, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 0.0), infsup (-inf, 0.5), infsup (-inf, inf)), infsup (1.0, inf))); %!# y finishedBy 0, z containedBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (-4.0, 0.0), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (1.189207115002721027e+00, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 0.0), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (1.0, inf))); %!# y finishedBy 0, z finishes [0, 1] %!test %! assert (isequal (powrev1 (infsup (-4.0, 0.0), infsup (0.25, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 0.0), infsup (0.25, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 0.0), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 0.0), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!# y finishedBy 0, z equals/finishedBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (-4.0, 0.0), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 0.0), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!# y finishedBy 0, z contains/startedBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (-4.0, 0.0), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 0.0), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 0.0), infsup (0.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 0.0), infsup (0.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 0.0), infsup (-inf, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 0.0), infsup (-inf, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 0.0), infsup (-inf, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 0.0), infsup (-inf, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!# y finishedBy 0, z overlappedBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (-4.0, 0.0), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 0.0), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 0.0), infsup (0.5, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 0.0), infsup (0.5, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!# y finishedBy 0, z metBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (-4.0, 0.0), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 0.0), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 0.0), infsup (1.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 0.0), infsup (1.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!# y finishedBy 0, z after [0, 1] %!test %! assert (isequal (powrev1 (infsup (-4.0, 0.0), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (0.0, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (-inf, 0.0), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 0.0), infsup (2.0, inf), infsup (-inf, inf)), infsup (0.0, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (-inf, 0.0), infsup (2.0, inf), infsup (-inf, inf)), infsup (0.0, 1.0))); %!# y contains 0, z overlaps/starts [0,1] %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (-inf, 0.5), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (-inf, 0.5), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (-inf, 0.5), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (-inf, 0.5), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.0, 0.5), infsup (0.0, 1.0)), infsup (0.0, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.0, 0.5), infsup (0.0, 1.0)), infsup (0.0, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (-inf, 0.5), infsup (0.0, 1.0)), infsup (0.0, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (-inf, 0.5), infsup (0.0, 1.0)), infsup (0.0, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.0, 0.5), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.0, 0.5), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (-inf, 0.5), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (-inf, 0.5), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.0, 0.5), infsup (1.0, inf)), infsup (1.189207115002721027e+00, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.0, 0.5), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (-inf, 0.5), infsup (1.0, inf)), infsup (1.189207115002721027e+00, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (-inf, 0.5), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.0, 0.5), infsup (1.0, inf)), infsup (1.189207115002721027e+00, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.0, 0.5), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (-inf, 0.5), infsup (1.0, inf)), infsup (1.189207115002721027e+00, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (-inf, 0.5), infsup (1.0, inf)), infsup (1.0, inf))); %!# y contains 0, z containedBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.25, 0.5), infsup (0.0, 1.0)), infsup (0.0, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.25, 0.5), infsup (0.0, 1.0)), infsup (0.0, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.25, 0.5), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.25, 0.5), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.25, 0.5), infsup (1.0, inf)), infsup (1.189207115002721027e+00, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.25, 0.5), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.25, 0.5), infsup (1.0, inf)), infsup (1.189207115002721027e+00, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.25, 0.5), infsup (1.0, inf)), infsup (1.0, inf))); %!# y contains 0, z finishes [0, 1] %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.25, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.25, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.25, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.25, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.25, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.25, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (1.0, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (1.0, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.25, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.25, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (1.0, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (1.0, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.25, 1.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.25, 1.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (1.0, 1.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (1.0, 1.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.25, 1.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.25, 1.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (1.0, 1.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (1.0, 1.0), infsup (1.0, inf)), infsup (1.0, inf))); %!# y contains 0, z equals/contains [0, 1] %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.0, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.0, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.0, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.0, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.0, 1.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.0, 1.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.0, 1.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.0, 1.0), infsup (1.0, inf)), infsup (1.0, inf))); %!# y contains 0, z contains/startedBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (-inf, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (-inf, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (-inf, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (-inf, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (-inf, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (-inf, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (-inf, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (-inf, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.0, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.0, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.0, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.0, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (-inf, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (-inf, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (-inf, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (-inf, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.0, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.0, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.0, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.0, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (-inf, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (-inf, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (-inf, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (-inf, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.0, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.0, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.0, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.0, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (-inf, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (-inf, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (-inf, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (-inf, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.0, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.0, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.0, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.0, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (-inf, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (-inf, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (-inf, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (-inf, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!# y contains 0, z overlappedBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.5, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.5, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.5, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.5, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.5, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.5, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.5, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.5, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.5, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.5, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.5, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.5, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.5, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.5, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (0.5, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (0.5, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.5, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.5, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (0.5, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (0.5, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!# y contains 0, z metBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (1.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (1.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (1.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (1.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (1.0, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (1.0, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (1.0, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (1.0, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (1.0, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (1.0, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (1.0, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (1.0, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (1.0, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (1.0, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (1.0, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (1.0, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (1.0, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (1.0, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (1.0, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (1.0, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!# y contains 0, z after [0, 1] %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (2.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (2.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (2.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (2.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (2.0, 4.0), infsup (0.0, 1.0)), infsup (0.0, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (2.0, 4.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (2.0, inf), infsup (0.0, 1.0)), infsup (0.0, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (2.0, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (2.0, 4.0), infsup (0.0, 1.0)), infsup (0.0, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (2.0, 4.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (2.0, inf), infsup (0.0, 1.0)), infsup (0.0, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (2.0, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (2.0, 4.0), infsup (1.0, inf)), infsup (1.189207115002721027e+00, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (2.0, 4.0), infsup (1.0, inf)), infsup (1.189207115002721027e+00, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, 4.0), infsup (2.0, inf), infsup (1.0, inf)), infsup (1.189207115002721027e+00, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, 4.0), infsup (2.0, inf), infsup (1.0, inf)), infsup (1.189207115002721027e+00, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (2.0, 4.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (2.0, 4.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-4.0, inf), infsup (2.0, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (-inf, inf), infsup (2.0, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!# y startedBy 0, z overlaps/starts [0,1] %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (0.0, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (-inf, 0.5), infsup (-inf, inf)), infsup (0.0, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (-inf, 0.5), infsup (-inf, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.0, 0.5), infsup (0.0, 1.0)), infsup (0.0, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (-inf, 0.5), infsup (0.0, 1.0)), infsup (0.0, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.0, 0.5), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (-inf, 0.5), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.0, 0.5), infsup (1.0, inf)), infsup)); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (-inf, 0.5), infsup (1.0, inf)), infsup)); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.0, 0.5), infsup (1.0, inf)), infsup)); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (-inf, 0.5), infsup (1.0, inf)), infsup)); %!# y startedBy 0, z containedBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (0.0, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.25, 0.5), infsup (0.0, 1.0)), infsup (0.0, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.25, 0.5), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.25, 0.5), infsup (1.0, inf)), infsup)); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.25, 0.5), infsup (1.0, inf)), infsup)); %!# y startedBy 0, z finishes [0, 1] %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.25, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.25, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.25, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (1.0, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.25, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (1.0, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.25, 1.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (1.0, 1.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.25, 1.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (1.0, 1.0), infsup (1.0, inf)), infsup (1.0, inf))); %!# y startedBy 0, z equals/contains [0, 1] %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.0, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.0, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.0, 1.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.0, 1.0), infsup (1.0, inf)), infsup (1.0, inf))); %!# y startedBy 0, z contains/startedBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (-inf, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (-inf, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (-inf, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (-inf, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.0, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.0, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (-inf, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (-inf, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.0, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.0, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (-inf, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (-inf, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.0, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.0, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (-inf, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (-inf, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.0, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.0, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (-inf, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (-inf, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!# y startedBy 0, z overlappedBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.5, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.5, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.5, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.5, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.5, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.5, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.5, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (0.5, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.5, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (0.5, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!# y startedBy 0, z metBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (1.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (1.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (1.0, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (1.0, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (1.0, 2.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (1.0, inf), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (1.0, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (1.0, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (1.0, 2.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (1.0, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!# y startedBy 0, z after [0, 1] %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (1.189207115002721027e+00, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (2.0, inf), infsup (-inf, inf)), infsup (1.189207115002721027e+00, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (2.0, inf), infsup (-inf, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (2.0, 4.0), infsup (0.0, 1.0)), infsup)); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (2.0, inf), infsup (0.0, 1.0)), infsup)); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (2.0, 4.0), infsup (0.0, 1.0)), infsup)); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (2.0, inf), infsup (0.0, 1.0)), infsup)); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (2.0, 4.0), infsup (1.0, inf)), infsup (1.189207115002721027e+00, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, 4.0), infsup (2.0, inf), infsup (1.0, inf)), infsup (1.189207115002721027e+00, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (2.0, 4.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (0.0, inf), infsup (2.0, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!# y after 0, z overlaps/starts [0,1] %!test %! assert (isequal (powrev1 (infsup (2.0, 4.0), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (0.0, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (2.0, 4.0), infsup (-inf, 0.5), infsup (-inf, inf)), infsup (0.0, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (2.0, inf), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (2.0, inf), infsup (-inf, 0.5), infsup (-inf, inf)), infsup (0.0, 1.0))); %!# y after 0, z containedBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (2.0, 4.0), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (0.5, 8.408964152537146131e-01))); %!test %! assert (isequal (powrev1 (infsup (2.0, inf), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (0.5, 1.0))); %!# y after 0, z finishes [0, 1] %!test %! assert (isequal (powrev1 (infsup (2.0, 4.0), infsup (0.25, 1.0), infsup (-inf, inf)), infsup (0.5, 1.0))); %!test %! assert (isequal (powrev1 (infsup (2.0, 4.0), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (1.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (2.0, inf), infsup (0.25, 1.0), infsup (-inf, inf)), infsup (0.5, 1.0))); %!test %! assert (isequal (powrev1 (infsup (2.0, inf), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (1.0, 1.0))); %!# y after 0, z equals/contains [0, 1] %!test %! assert (isequal (powrev1 (infsup (2.0, 4.0), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev1 (infsup (2.0, inf), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (0.0, 1.0))); %!# y after 0, z contains/startedBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (2.0, 4.0), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (0.0, 1.414213562373095145e+00))); %!test %! assert (isequal (powrev1 (infsup (2.0, 4.0), infsup (0.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (2.0, 4.0), infsup (-inf, 2.0), infsup (-inf, inf)), infsup (0.0, 1.414213562373095145e+00))); %!test %! assert (isequal (powrev1 (infsup (2.0, 4.0), infsup (-inf, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (2.0, inf), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (0.0, 1.414213562373095145e+00))); %!test %! assert (isequal (powrev1 (infsup (2.0, inf), infsup (0.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev1 (infsup (2.0, inf), infsup (-inf, 2.0), infsup (-inf, inf)), infsup (0.0, 1.414213562373095145e+00))); %!test %! assert (isequal (powrev1 (infsup (2.0, inf), infsup (-inf, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!# y after 0, z overlappedBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (2.0, 4.0), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (7.071067811865474617e-01, 1.414213562373095145e+00))); %!test %! assert (isequal (powrev1 (infsup (2.0, 4.0), infsup (0.5, inf), infsup (-inf, inf)), infsup (7.071067811865474617e-01, inf))); %!test %! assert (isequal (powrev1 (infsup (2.0, inf), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (7.071067811865474617e-01, 1.414213562373095145e+00))); %!test %! assert (isequal (powrev1 (infsup (2.0, inf), infsup (0.5, inf), infsup (-inf, inf)), infsup (7.071067811865474617e-01, inf))); %!# y after 0, z metBy [0, 1] %!test %! assert (isequal (powrev1 (infsup (2.0, 4.0), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (1.0, 1.414213562373095145e+00))); %!test %! assert (isequal (powrev1 (infsup (2.0, 4.0), infsup (1.0, inf), infsup (-inf, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev1 (infsup (2.0, inf), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (1.0, 1.414213562373095145e+00))); %!test %! assert (isequal (powrev1 (infsup (2.0, inf), infsup (1.0, inf), infsup (-inf, inf)), infsup (1.0, inf))); %!# y after 0, z after [0, 1] %!test %! assert (isequal (powrev1 (infsup (2.0, 4.0), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (1.189207115002721027e+00, 2.0))); %!test %! assert (isequal (powrev1 (infsup (2.0, 4.0), infsup (2.0, inf), infsup (-inf, inf)), infsup (1.189207115002721027e+00, inf))); %!test %! assert (isequal (powrev1 (infsup (2.0, inf), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (1.0, 2.0))); %!test %! assert (isequal (powrev1 (infsup (2.0, inf), infsup (2.0, inf), infsup (-inf, inf)), infsup (1.0, inf))); ## minimal.powRev2_test ## ## The following tests use boundaries for the first and second parameter ## whose binary logarithm can be computed without round-off error in a ## binary floating-point context. ## Thus, an implementation should be able to compute tight results with the ## formula y = log2 z / log2 x for the intervals used here. ## Implementations which use natural logarithm would introduce additional ## errors. ## ## The test values are structured according to table B.2 in ## Heimlich, Oliver. 2011. “The General Interval Power Function.” ## Diplomarbeit, Institute for Computer Science, University of Würzburg. ## http://exp.ln0.de/heimlich-power-2011.htm. ## %!# Empty intervals %!test %! assert (isequal (powrev2 (infsup, infsup, infsup), infsup)); %!test %! assert (isequal (powrev2 (infsup, infsup (-inf, inf), infsup), infsup)); %!test %! assert (isequal (powrev2 (infsup (-inf, inf), infsup, infsup), infsup)); %!test %! assert (isequal (powrev2 (infsup (-inf, inf), infsup (-inf, inf), infsup), infsup)); %!test %! assert (isequal (powrev2 (infsup, infsup, infsup (-inf, inf)), infsup)); %!test %! assert (isequal (powrev2 (infsup, infsup (-inf, inf), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (powrev2 (infsup (-inf, inf), infsup, infsup (-inf, inf)), infsup)); %!# Entire range %!test %! assert (isequal (powrev2 (infsup (-inf, inf), infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!# Outside of the function's domain %!test %! assert (isequal (powrev2 (infsup (0.0, 0.0), infsup (-inf, -0.1), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (powrev2 (infsup (0.0, 0.0), infsup (0.1, inf), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (powrev2 (infsup (0.0, 0.0), infsup (0.0, 0.0), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (powrev2 (infsup (-inf, 0.9), infsup (0.0, 0.9), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (powrev2 (infsup (1.1, inf), infsup (1.1, inf), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (powrev2 (infsup (-inf, 0.9), infsup (1.1, inf), infsup (0.0, inf)), infsup)); %!test %! assert (isequal (powrev2 (infsup (1.1, inf), infsup (0.0, 0.9), infsup (0.0, inf)), infsup)); %!# 0^y = 0 %!test %! assert (isequal (powrev2 (infsup (0.0, 0.0), infsup (0.0, 0.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (-inf, 0.0), infsup (-inf, 0.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (-inf, 0.0), infsup (-inf, 0.0), infsup (1.0, 2.0)), infsup (1.0, 2.0))); %!test %! assert (isequal (powrev2 (infsup (-inf, inf), infsup (0.0, 0.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (-inf, inf), infsup (-inf, 0.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (-inf, inf), infsup (-inf, 0.0), infsup (1.0, 2.0)), infsup (1.0, 2.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 0.0), infsup (-inf, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (-inf, 0.0), infsup (-inf, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (-inf, 0.0), infsup (-inf, inf), infsup (1.0, 2.0)), infsup (1.0, 2.0))); %!# 1^y = x^0 = 1 %!test %! assert (isequal (powrev2 (infsup (1.0, 1.0), infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 1.0), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 1.0), infsup (1.0, 1.0), infsup (2.0, 3.0)), infsup (2.0, 3.0))); %!test %! assert (isequal (powrev2 (infsup (-inf, inf), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (-inf, inf), infsup (1.0, 1.0), infsup (2.0, 3.0)), infsup (2.0, 3.0))); %!test %! assert (isequal (powrev2 (infsup (2.0, 3.0), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (powrev2 (infsup (2.0, 3.0), infsup (1.0, 1.0), infsup (2.0, 3.0)), infsup)); %!# x overlaps/starts [0, 1], z overlaps/starts [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 0.5), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 0.5), infsup (0.0, 0.5), infsup (-inf, 0.0)), infsup)); %!# x overlaps/starts [0, 1], z containedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 0.5), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (0.0, 2.0))); %!# x overlaps/starts [0, 1], z finishes [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 0.25), infsup (0.5, 1.0), infsup (-inf, inf)), infsup (0.0, 0.5))); %!test %! assert (isequal (powrev2 (infsup (0.0, 0.25), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!# x overlaps/starts [0, 1], z equals/finishedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 0.25), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 0.25), infsup (0.0, 1.0), infsup (-inf, 0.0)), infsup (0.0, 0.0))); %!# x overlaps/starts [0, 1], z contains/startedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 0.25), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (-0.5, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 0.25), infsup (0.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!# x overlaps/starts [0, 1], z overlappedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 0.25), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (-0.5, 0.5))); %!test %! assert (isequal (powrev2 (infsup (0.0, 0.25), infsup (0.5, inf), infsup (-inf, inf)), infsup (-inf, 0.5))); %!# x overlaps/starts [0, 1], z metBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 0.25), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (-0.5, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 0.25), infsup (1.0, 2.0), infsup (0.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 0.25), infsup (1.0, inf), infsup (-inf, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 0.25), infsup (1.0, inf), infsup (0.0, inf)), infsup (0.0, 0.0))); %!# x overlaps/starts [0, 1], z after [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 0.25), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (-1.0, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 0.25), infsup (2.0, 4.0), infsup (0.0, inf)), infsup)); %!test %! assert (isequal (powrev2 (infsup (0.0, 0.25), infsup (2.0, inf), infsup (-inf, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 0.25), infsup (2.0, inf), infsup (0.0, inf)), infsup)); %!# x containedBy [0, 1], z overlaps/starts [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.25, 0.5), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (0.5, inf))); %!# x containedBy [0, 1], z containedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.25, 0.5), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (0.5, 2.0))); %!# x containedBy [0, 1], z finishes [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.25, 0.5), infsup (0.5, 1.0), infsup (-inf, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev2 (infsup (0.25, 0.5), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!# x containedBy [0, 1], z equals/finishedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.25, 0.5), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.25, 0.5), infsup (0.0, 1.0), infsup (-inf, 0.0)), infsup (0.0, 0.0))); %!# x containedBy [0, 1], z contains/startedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.25, 0.5), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (-1.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.25, 0.5), infsup (0.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!# x containedBy [0, 1], z overlappedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.25, 0.5), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (-1.0, 1.0))); %!test %! assert (isequal (powrev2 (infsup (0.25, 0.5), infsup (0.5, inf), infsup (-inf, inf)), infsup (-inf, 1.0))); %!# x containedBy [0, 1], z metBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.25, 0.5), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (-1.0, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.25, 0.5), infsup (1.0, inf), infsup (-inf, inf)), infsup (-inf, 0.0))); %!# x containedBy [0, 1], z after [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.25, 0.5), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (-2.0, -0.5))); %!test %! assert (isequal (powrev2 (infsup (0.25, 0.5), infsup (2.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!# x finishes [0, 1], z overlaps/starts [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.25, 1.0), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (0.5, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 1.0), infsup (0.0, 0.5), infsup (-inf, inf)), infsup)); %!# x finishes [0, 1], z containedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.25, 1.0), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (0.5, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 1.0), infsup (0.25, 0.5), infsup (-inf, inf)), infsup)); %!# x finishes [0, 1], z finishes [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.25, 1.0), infsup (0.5, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.25, 1.0), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 1.0), infsup (0.5, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 1.0), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!# x finishes [0, 1], z equals/finishedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.25, 1.0), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 1.0), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!# x finishes [0, 1], z contains/startedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.25, 1.0), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 1.0), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.25, 1.0), infsup (0.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 1.0), infsup (0.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!# x finishes [0, 1], z overlappedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.25, 1.0), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 1.0), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.25, 1.0), infsup (0.5, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 1.0), infsup (0.5, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!# x finishes [0, 1], z metBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.25, 1.0), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 1.0), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.25, 1.0), infsup (1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 1.0), infsup (1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!# x finishes [0, 1], z after [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.25, 1.0), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (-inf, -0.5))); %!test %! assert (isequal (powrev2 (infsup (1.0, 1.0), infsup (2.0, 4.0), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (powrev2 (infsup (0.25, 1.0), infsup (2.0, inf), infsup (-inf, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, 1.0), infsup (2.0, inf), infsup (-inf, inf)), infsup)); %!# x equals/finishedBy [0, 1], z overlaps/starts [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.0, 0.5), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.0, 0.5), infsup (0.0, inf)), infsup (0.0, inf))); %!# x equals/finishedBy [0, 1], z containedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.25, 0.5), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.25, 0.5), infsup (0.0, inf)), infsup (0.0, inf))); %!# x equals/finishedBy [0, 1], z finishes [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.5, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.5, 1.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (1.0, 1.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.5, 1.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (1.0, 1.0), infsup (0.0, inf)), infsup (0.0, inf))); %!# x equals/finishedBy [0, 1], z equals/finishedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.0, 1.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.0, 1.0), infsup (0.0, inf)), infsup (0.0, inf))); %!# x equals/finishedBy [0, 1], z contains/startedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.0, 2.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.0, 2.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.0, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.0, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!# x equals/finishedBy [0, 1], z overlappedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.5, 2.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.5, 2.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.5, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.5, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (0.5, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!# x equals/finishedBy [0, 1], z metBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (1.0, 2.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (1.0, 2.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (1.0, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (1.0, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!# x equals/finishedBy [0, 1], z after [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (2.0, 4.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (2.0, 4.0), infsup (0.0, inf)), infsup)); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (2.0, inf), infsup (-inf, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (2.0, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 1.0), infsup (2.0, inf), infsup (0.0, inf)), infsup)); %!# x contains/startedBy [0, 1], z overlaps/starts [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.0, 0.5), infsup (-inf, 0.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.0, 0.5), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.0, 0.5), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.0, 0.5), infsup (0.0, inf)), infsup (0.0, inf))); %!# x contains/startedBy [0, 1], z containedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.25, 0.5), infsup (-inf, 0.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.25, 0.5), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.25, 0.5), infsup (-inf, 0.0)), infsup (-inf, -0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.25, 0.5), infsup (0.0, inf)), infsup (0.0, inf))); %!# x contains/startedBy [0, 1], z finishes [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.5, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.5, 1.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (1.0, 1.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.5, 1.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (1.0, 1.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.5, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.5, 1.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (1.0, 1.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.5, 1.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (1.0, 1.0), infsup (0.0, inf)), infsup (0.0, inf))); %!# x contains/startedBy [0, 1], z equals/finishedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.0, 1.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.0, 1.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.0, 1.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.0, 1.0), infsup (0.0, inf)), infsup (0.0, inf))); %!# x contains/startedBy [0, 1], z contains/startedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.0, 2.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.0, 2.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.0, 2.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.0, 2.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.0, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.0, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.0, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.0, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!# x contains/startedBy [0, 1], z overlappedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.5, 2.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.5, 2.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.5, 2.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.5, 2.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.5, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.5, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (0.5, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.5, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.5, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (0.5, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!# x contains/startedBy [0, 1], z metBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (1.0, 2.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (1.0, 2.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (1.0, 2.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (1.0, 2.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (1.0, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (1.0, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (1.0, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (1.0, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!# x contains/startedBy [0, 1], z after [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (2.0, 4.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (2.0, 4.0), infsup (0.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (2.0, 4.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (2.0, 4.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (2.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (2.0, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, 2.0), infsup (2.0, inf), infsup (0.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (2.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (2.0, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.0, inf), infsup (2.0, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!# x overlappedBy [0, 1], z overlaps/starts [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.0, 0.5), infsup (-inf, 0.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.0, 0.5), infsup (0.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.0, 0.5), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.0, 0.5), infsup (0.0, inf)), infsup (1.0, inf))); %!# x overlappedBy [0, 1], z containedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.25, 0.5), infsup (-inf, 0.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.25, 0.5), infsup (0.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.25, 0.5), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.25, 0.5), infsup (0.0, inf)), infsup (1.0, inf))); %!# x overlappedBy [0, 1], z finishes [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.5, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.5, 1.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (1.0, 1.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.5, 1.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (1.0, 1.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.5, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.5, 1.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (1.0, 1.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.5, 1.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (1.0, 1.0), infsup (0.0, inf)), infsup (0.0, inf))); %!# x overlappedBy [0, 1], z equals/finishedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.0, 1.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.0, 1.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.0, 1.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.0, 1.0), infsup (0.0, inf)), infsup (0.0, inf))); %!# x overlappedBy [0, 1], z contains/startedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.0, 2.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.0, 2.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.0, 2.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.0, 2.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.0, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.0, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.0, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.0, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!# x overlappedBy [0, 1], z overlappedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.5, 2.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.5, 2.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.5, 2.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.5, 2.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.5, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.5, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (0.5, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.5, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.5, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (0.5, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!# x overlappedBy [0, 1], z metBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (1.0, 2.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (1.0, 2.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (1.0, 2.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (1.0, 2.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (1.0, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (1.0, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (1.0, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (1.0, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!# x overlappedBy [0, 1], z after [0, 1] %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (2.0, 4.0), infsup (-inf, 0.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, 2.0), infsup (2.0, 4.0), infsup (0.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (2.0, 4.0), infsup (-inf, 0.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (powrev2 (infsup (0.5, inf), infsup (2.0, 4.0), infsup (0.0, inf)), infsup (0.0, inf))); %!# x metBy [0, 1], z overlaps/starts [0, 1] %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (-inf, -1.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.0, 0.5), infsup (-inf, 0.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.0, 0.5), infsup (0.0, inf)), infsup)); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.0, 0.5), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.0, 0.5), infsup (0.0, inf)), infsup)); %!# x metBy [0, 1], z containedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (-inf, -1.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.25, 0.5), infsup (-inf, 0.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.25, 0.5), infsup (0.0, inf)), infsup)); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.25, 0.5), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.25, 0.5), infsup (0.0, inf)), infsup)); %!# x metBy [0, 1], z finishes [0, 1] %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.5, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.5, 1.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (1.0, 1.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.5, 1.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (1.0, 1.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.5, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.5, 1.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (1.0, 1.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.5, 1.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (1.0, 1.0), infsup (0.0, inf)), infsup (0.0, inf))); %!# x metBy [0, 1], z equals/finishedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.0, 1.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.0, 1.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.0, 1.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.0, 1.0), infsup (0.0, inf)), infsup (0.0, inf))); %!# x metBy [0, 1], z contains/startedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.0, 2.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.0, 2.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.0, 2.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.0, 2.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.0, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.0, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.0, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.0, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!# x metBy [0, 1], z overlappedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.5, 2.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.5, 2.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.5, 2.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.5, 2.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.5, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.5, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (0.5, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.5, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.5, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (0.5, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!# x metBy [0, 1], z metBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (1.0, 2.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (1.0, 2.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (1.0, 2.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (1.0, 2.0), infsup (0.0, inf)), infsup (0.0, inf))); %!# x metBy [0, 1], z after [0, 1] %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (2.0, 4.0), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (2.0, 4.0), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (powrev2 (infsup (1.0, 2.0), infsup (2.0, 4.0), infsup (0.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (powrev2 (infsup (1.0, inf), infsup (2.0, 4.0), infsup (0.0, inf)), infsup (0.0, inf))); %!# x after [0, 1], z overlaps/starts [0, 1] %!test %! assert (isequal (powrev2 (infsup (2.0, 4.0), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (-inf, -0.5))); %!test %! assert (isequal (powrev2 (infsup (2.0, inf), infsup (0.0, 0.5), infsup (-inf, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (2.0, inf), infsup (0.0, 0.5), infsup (0.0, inf)), infsup)); %!# x after [0, 1], z containedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (2.0, 4.0), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (-2.0, -0.5))); %!test %! assert (isequal (powrev2 (infsup (2.0, inf), infsup (0.25, 0.5), infsup (-inf, inf)), infsup (-2.0, 0.0))); %!test %! assert (isequal (powrev2 (infsup (2.0, inf), infsup (0.25, 0.5), infsup (0.0, inf)), infsup)); %!# x after [0, 1], z finishes [0, 1] %!test %! assert (isequal (powrev2 (infsup (2.0, 4.0), infsup (0.5, 1.0), infsup (-inf, inf)), infsup (-1.0, 0.0))); %!test %! assert (isequal (powrev2 (infsup (2.0, inf), infsup (0.5, 1.0), infsup (-inf, inf)), infsup (-1.0, 0.0))); %!test %! assert (isequal (powrev2 (infsup (2.0, 4.0), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (powrev2 (infsup (2.0, inf), infsup (1.0, 1.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!# x after [0, 1], z equals/finishedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (2.0, 4.0), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (2.0, inf), infsup (0.0, 1.0), infsup (-inf, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (powrev2 (infsup (2.0, 4.0), infsup (0.0, 1.0), infsup (0.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (powrev2 (infsup (2.0, inf), infsup (0.0, 1.0), infsup (0.0, inf)), infsup (0.0, 0.0))); %!# x after [0, 1], z contains/startedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (2.0, 4.0), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (-inf, 1.0))); %!test %! assert (isequal (powrev2 (infsup (2.0, inf), infsup (0.0, 2.0), infsup (-inf, inf)), infsup (-inf, 1.0))); %!# x after [0, 1], z overlappedBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (2.0, 4.0), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (-1.0, 1.0))); %!test %! assert (isequal (powrev2 (infsup (2.0, inf), infsup (0.5, 2.0), infsup (-inf, inf)), infsup (-1.0, 1.0))); %!# x after [0, 1], z metBy [0, 1] %!test %! assert (isequal (powrev2 (infsup (2.0, 4.0), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev2 (infsup (2.0, inf), infsup (1.0, 2.0), infsup (-inf, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (powrev2 (infsup (2.0, 4.0), infsup (1.0, 2.0), infsup (-inf, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (powrev2 (infsup (2.0, inf), infsup (1.0, 2.0), infsup (-inf, 0.0)), infsup (0.0, 0.0))); %!# x after [0, 1], z after [0, 1] %!test %! assert (isequal (powrev2 (infsup (2.0, 4.0), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (0.5, 2.0))); %!test %! assert (isequal (powrev2 (infsup (2.0, inf), infsup (2.0, 4.0), infsup (-inf, inf)), infsup (0.0, 2.0))); %!test %! assert (isequal (powrev2 (infsup (2.0, inf), infsup (2.0, 4.0), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (powrev2 (infsup (2.0, 4.0), infsup (2.0, inf), infsup (-inf, inf)), infsup (0.5, inf))); %!test %! assert (isequal (powrev2 (infsup (2.0, inf), infsup (2.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (powrev2 (infsup (2.0, inf), infsup (2.0, inf), infsup (-inf, 0.0)), infsup)); interval-1.4.1/inst/test/libieeep1788_tests_num.tst0000644000175000017500000002452612657476045021653 0ustar oliveroliver## DO NOT EDIT! Generated automatically from test/libieeep1788_tests_num.itl ## by the Interval Testing Framework for IEEE 1788. ## https://github.com/nehmeier/ITF1788/tree/635bff73cc64ff8aab0ff2031ee8a53980be0115 ## ## Copyright 2013-2015 Marco Nehmeier (nehmeier@informatik.uni-wuerzburg.de) ## Copyright 2015-2016 Oliver Heimlich ## ## Original author: Marco Nehmeier (unit tests in libieeep1788, ## original license: Apache License 2.0) ## Converted into portable ITL format by Oliver Heimlich with minor corrections. ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## %!#Test library imports %!#Arithmetic library imports pkg load interval %!#Preamble try; error ("__FILE__"); catch test (lasterror.stack.file, "quiet", stdout); end_try_catch; %!function assert_warn (observed_value, expected_value) %! if (not (isequal (observed_value, expected_value))) %! observed_expression = regexprep (argn(1, :), '\s+$', ''); %! expected_expression = regexprep (argn(2, :), '\s+$', ''); %! observed_as_char = disp (observed_value)(1 : end - 1); %! expected_as_char = disp(expected_value)(1 : end - 1); %! warning ([observed_expression, " != ", expected_expression, ... %! "\n ", observed_as_char, " != ", expected_as_char]); %! endif %!endfunction ## minimal_inf_test %!test %! assert (isequal (inf (infsup), inf)); %!test %! assert (isequal (inf (infsup (-inf, inf)), -inf)); %!test %! assert (isequal (inf (infsup (1.0, 2.0)), 1.0)); %!test %! assert (isequal (inf (infsup (-3.0, -2.0)), -3.0)); %!test %! assert (isequal (inf (infsup (-inf, 2.0)), -inf)); %!test %! assert (isequal (inf (infsup (-inf, 0.0)), -inf)); %!test %! assert (isequal (inf (infsup (-inf, -0.0)), -inf)); %!test %! assert (isequal (inf (infsup (-2.0, inf)), -2.0)); %!test %! assert (isequal (inf (infsup (0.0, inf)), -0.0)); %!test %! assert (isequal (inf (infsup (-0.0, inf)), -0.0)); %!test %! assert (isequal (inf (infsup (-0.0, 0.0)), -0.0)); %!test %! assert (isequal (inf (infsup (0.0, -0.0)), -0.0)); %!test %! assert (isequal (inf (infsup (0.0, 0.0)), -0.0)); %!test %! assert (isequal (inf (infsup (-0.0, -0.0)), -0.0)); ## minimal_inf_dec_test %!test %! assert (isequal (inf (infsupdec (empty, "trv")), inf)); %!test %! assert (isequal (inf (infsupdec (-inf, inf, "def")), -inf)); %!test %! assert (isequal (inf (infsupdec (1.0, 2.0, "com")), 1.0)); %!test %! assert (isequal (inf (infsupdec (-3.0, -2.0, "trv")), -3.0)); %!test %! assert (isequal (inf (infsupdec (-inf, 2.0, "dac")), -inf)); %!test %! assert (isequal (inf (infsupdec (-inf, 0.0, "def")), -inf)); %!test %! assert (isequal (inf (infsupdec (-inf, -0.0, "trv")), -inf)); %!test %! assert (isequal (inf (infsupdec (-2.0, inf, "trv")), -2.0)); %!test %! assert (isequal (inf (infsupdec (0.0, inf, "def")), -0.0)); %!test %! assert (isequal (inf (infsupdec (-0.0, inf, "trv")), -0.0)); %!test %! assert (isequal (inf (infsupdec (-0.0, 0.0, "dac")), -0.0)); %!test %! assert (isequal (inf (infsupdec (0.0, -0.0, "trv")), -0.0)); %!test %! assert (isequal (inf (infsupdec (0.0, 0.0, "trv")), -0.0)); %!test %! assert (isequal (inf (infsupdec (-0.0, -0.0, "trv")), -0.0)); ## minimal_sup_test %!test %! assert (isequal (sup (infsup), -inf)); %!test %! assert (isequal (sup (infsup (-inf, inf)), inf)); %!test %! assert (isequal (sup (infsup (1.0, 2.0)), 2.0)); %!test %! assert (isequal (sup (infsup (-3.0, -2.0)), -2.0)); %!test %! assert (isequal (sup (infsup (-inf, 2.0)), 2.0)); %!test %! assert (isequal (sup (infsup (-inf, 0.0)), 0.0)); %!test %! assert (isequal (sup (infsup (-inf, -0.0)), 0.0)); %!test %! assert (isequal (sup (infsup (-2.0, inf)), inf)); %!test %! assert (isequal (sup (infsup (0.0, inf)), inf)); %!test %! assert (isequal (sup (infsup (-0.0, inf)), inf)); %!test %! assert (isequal (sup (infsup (-0.0, 0.0)), 0.0)); %!test %! assert (isequal (sup (infsup (0.0, -0.0)), 0.0)); %!test %! assert (isequal (sup (infsup (0.0, 0.0)), 0.0)); %!test %! assert (isequal (sup (infsup (-0.0, -0.0)), 0.0)); ## minimal_sup_dec_test %!test %! assert (isequal (sup (infsupdec (empty, "trv")), -inf)); %!test %! assert (isequal (sup (infsupdec (-inf, inf, "def")), inf)); %!test %! assert (isequal (sup (infsupdec (1.0, 2.0, "com")), 2.0)); %!test %! assert (isequal (sup (infsupdec (-3.0, -2.0, "trv")), -2.0)); %!test %! assert (isequal (sup (infsupdec (-inf, 2.0, "dac")), 2.0)); %!test %! assert (isequal (sup (infsupdec (-inf, 0.0, "def")), 0.0)); %!test %! assert (isequal (sup (infsupdec (-inf, -0.0, "trv")), 0.0)); %!test %! assert (isequal (sup (infsupdec (-2.0, inf, "trv")), inf)); %!test %! assert (isequal (sup (infsupdec (0.0, inf, "def")), inf)); %!test %! assert (isequal (sup (infsupdec (-0.0, inf, "trv")), inf)); %!test %! assert (isequal (sup (infsupdec (-0.0, 0.0, "dac")), +0.0)); %!test %! assert (isequal (sup (infsupdec (0.0, -0.0, "trv")), +0.0)); %!test %! assert (isequal (sup (infsupdec (0.0, 0.0, "trv")), +0.0)); %!test %! assert (isequal (sup (infsupdec (-0.0, -0.0, "trv")), +0.0)); ## minimal_mid_test %!test %! assert (isequal (mid (infsup (-inf, inf)), 0.0)); %!test %! assert (isequal (mid (infsup (-1.797693134862315708e+308, 1.797693134862315708e+308)), 0.0)); %!test %! assert (isequal (mid (infsup (0.0, 2.0)), 1.0)); %!test %! assert (isequal (mid (infsup (2.0, 2.0)), 2.0)); %!test %! assert (isequal (mid (infsup (-2.0, 2.0)), 0.0)); %!test %! assert (isequal (mid (infsup (-9.881312916824930884e-324, 4.940656458412465442e-324)), 0.0)); %!test %! assert (isequal (mid (infsup (-4.940656458412465442e-324, 9.881312916824930884e-324)), 0.0)); ## minimal_mid_dec_test %!test %! assert (isequal (mid (infsupdec (-inf, inf, "def")), 0.0)); %!test %! assert (isequal (mid (infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "trv")), 0.0)); %!test %! assert (isequal (mid (infsupdec (0.0, 2.0, "com")), 1.0)); %!test %! assert (isequal (mid (infsupdec (2.0, 2.0, "dac")), 2.0)); %!test %! assert (isequal (mid (infsupdec (-2.0, 2.0, "trv")), 0.0)); %!test %! assert (isequal (mid (infsupdec (-9.881312916824930884e-324, 4.940656458412465442e-324, "trv")), 0.0)); %!test %! assert (isequal (mid (infsupdec (-4.940656458412465442e-324, 9.881312916824930884e-324, "trv")), 0.0)); ## minimal_rad_test %!test %! assert (isequal (rad (infsup (0.0, 2.0)), 1.0)); %!test %! assert (isequal (rad (infsup (2.0, 2.0)), 0.0)); %!test %! assert (isequal (rad (infsup (-inf, inf)), inf)); %!test %! assert (isequal (rad (infsup (0.0, inf)), inf)); %!test %! assert (isequal (rad (infsup (-inf, 1.2)), inf)); ## minimal_rad_dec_test %!test %! assert (isequal (rad (infsupdec (0.0, 2.0, "trv")), 1.0)); %!test %! assert (isequal (rad (infsupdec (2.0, 2.0, "com")), 0.0)); %!test %! assert (isequal (rad (infsupdec (-inf, inf, "trv")), inf)); %!test %! assert (isequal (rad (infsupdec (0.0, inf, "def")), inf)); %!test %! assert (isequal (rad (infsupdec (-inf, 1.2, "trv")), inf)); ## minimal_wid_test %!test %! assert (isequal (wid (infsup (2.0, 2.0)), 0.0)); %!test %! assert (isequal (wid (infsup (1.0, 2.0)), 1.0)); %!test %! assert (isequal (wid (infsup (1.0, inf)), inf)); %!test %! assert (isequal (wid (infsup (-inf, 2.0)), inf)); %!test %! assert (isequal (wid (infsup (-inf, inf)), inf)); ## minimal_wid_dec_test %!test %! assert (isequal (wid (infsupdec (2.0, 2.0, "com")), 0.0)); %!test %! assert (isequal (wid (infsupdec (1.0, 2.0, "trv")), 1.0)); %!test %! assert (isequal (wid (infsupdec (1.0, inf, "trv")), inf)); %!test %! assert (isequal (wid (infsupdec (-inf, 2.0, "def")), inf)); %!test %! assert (isequal (wid (infsupdec (-inf, inf, "trv")), inf)); ## minimal_mag_test %!test %! assert (isequal (mag (infsup (1.0, 2.0)), 2.0)); %!test %! assert (isequal (mag (infsup (-4.0, 2.0)), 4.0)); %!test %! assert (isequal (mag (infsup (-inf, 2.0)), inf)); %!test %! assert (isequal (mag (infsup (1.0, inf)), inf)); %!test %! assert (isequal (mag (infsup (-inf, inf)), inf)); %!test %! assert (isequal (mag (infsup (-0.0, 0.0)), 0.0)); %!test %! assert (isequal (mag (infsup (-0.0, -0.0)), 0.0)); ## minimal_mag_dec_test %!test %! assert (isequal (mag (infsupdec (1.0, 2.0, "com")), 2.0)); %!test %! assert (isequal (mag (infsupdec (-4.0, 2.0, "trv")), 4.0)); %!test %! assert (isequal (mag (infsupdec (-inf, 2.0, "trv")), inf)); %!test %! assert (isequal (mag (infsupdec (1.0, inf, "def")), inf)); %!test %! assert (isequal (mag (infsupdec (-inf, inf, "trv")), inf)); %!test %! assert (isequal (mag (infsupdec (-0.0, 0.0, "trv")), 0.0)); %!test %! assert (isequal (mag (infsupdec (-0.0, -0.0, "trv")), 0.0)); ## minimal_mig_test %!test %! assert (isequal (mig (infsup (1.0, 2.0)), 1.0)); %!test %! assert (isequal (mig (infsup (-4.0, 2.0)), 0.0)); %!test %! assert (isequal (mig (infsup (-4.0, -2.0)), 2.0)); %!test %! assert (isequal (mig (infsup (-inf, 2.0)), 0.0)); %!test %! assert (isequal (mig (infsup (-inf, -2.0)), 2.0)); %!test %! assert (isequal (mig (infsup (-1.0, inf)), 0.0)); %!test %! assert (isequal (mig (infsup (1.0, inf)), 1.0)); %!test %! assert (isequal (mig (infsup (-inf, inf)), 0.0)); %!test %! assert (isequal (mig (infsup (-0.0, 0.0)), 0.0)); %!test %! assert (isequal (mig (infsup (-0.0, -0.0)), 0.0)); ## minimal_mig_dec_test %!test %! assert (isequal (mig (infsupdec (1.0, 2.0, "com")), 1.0)); %!test %! assert (isequal (mig (infsupdec (-4.0, 2.0, "trv")), 0.0)); %!test %! assert (isequal (mig (infsupdec (-4.0, -2.0, "trv")), 2.0)); %!test %! assert (isequal (mig (infsupdec (-inf, 2.0, "def")), 0.0)); %!test %! assert (isequal (mig (infsupdec (-inf, -2.0, "trv")), 2.0)); %!test %! assert (isequal (mig (infsupdec (-1.0, inf, "trv")), 0.0)); %!test %! assert (isequal (mig (infsupdec (1.0, inf, "trv")), 1.0)); %!test %! assert (isequal (mig (infsupdec (-inf, inf, "trv")), 0.0)); %!test %! assert (isequal (mig (infsupdec (-0.0, 0.0, "trv")), 0.0)); %!test %! assert (isequal (mig (infsupdec (-0.0, -0.0, "trv")), 0.0)); interval-1.4.1/inst/test/mpfi.tst0000644000175000017500000064650512657476046016407 0ustar oliveroliver## DO NOT EDIT! Generated automatically from test/mpfi.itl ## by the Interval Testing Framework for IEEE 1788. ## https://github.com/nehmeier/ITF1788/tree/635bff73cc64ff8aab0ff2031ee8a53980be0115 ## ## Copyright 2009–2012 Spaces project, Inria Lorraine ## and Salsa project, INRIA Rocquencourt, ## and Arenaire project, Inria Rhone-Alpes, France ## and Lab. ANO, USTL (Univ. of Lille), France ## Copyright 2015-2016 Oliver Heimlich ## ## Original authors: Philippe Theveny (Philippe.Theveny@ens-lyon.fr) ## and Nathalie Revol (Nathalie.Revol@ens-lyon.fr) ## (unit tests in GNU MPFI, original license: LGPLv2.1+) ## Converted into portable ITL format by Oliver Heimlich. ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## %!#Test library imports %!#Arithmetic library imports pkg load interval %!#Preamble try; error ("__FILE__"); catch test (lasterror.stack.file, "quiet", stdout); end_try_catch; %!function assert_warn (observed_value, expected_value) %! if (not (isequal (observed_value, expected_value))) %! observed_expression = regexprep (argn(1, :), '\s+$', ''); %! expected_expression = regexprep (argn(2, :), '\s+$', ''); %! observed_as_char = disp (observed_value)(1 : end - 1); %! expected_as_char = disp(expected_value)(1 : end - 1); %! warning ([observed_expression, " != ", expected_expression, ... %! "\n ", observed_as_char, " != ", expected_as_char]); %! endif %!endfunction ## mpfi_abs %!# special values %!test %! assert (isequal (abs (infsup (-inf, -7.0)), infsup (+7.0, inf))); %!test %! assert (isequal (abs (infsup (-inf, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (abs (infsup (-inf, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (abs (infsup (-inf, +8.0)), infsup (0.0, inf))); %!test %! assert (isequal (abs (infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (abs (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (abs (infsup (0.0, +8.0)), infsup (0.0, +8.0))); %!test %! assert (isequal (abs (infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (abs (infsup (0.0, +8.0)), infsup (0.0, +8.0))); %!test %! assert (isequal (abs (infsup (0.0, inf)), infsup (0.0, inf))); %!# regular values %!test %! assert (isequal (abs (infsup (7.456540443420410156e+04, 7.456540467834472656e+04)), infsup (7.456540443420410156e+04, 7.456540467834472656e+04))); %!test %! assert (isequal (abs (infsup (-7.456540443420410156e+04, 7.456540467834472656e+04)), infsup (0.0, 7.456540467834472656e+04))); ## mpfi_acos %!# special values %!test %! assert (isequal (acos (infsup (-1.0, 0.0)), infsup (1.570796326794896558e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (acos (infsup (0.0, 0.0)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (0.0, +1.0)), infsup (0.0, 1.570796326794896780e+00))); %!# regular values %!test %! assert (isequal (acos (infsup (-1.0, -0.5)), infsup (2.094395102393195263e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (acos (infsup (-0.75, -0.25)), infsup (1.823476581936975149e+00, 2.418858405776378007e+00))); %!test %! assert (isequal (acos (infsup (-0.5, 0.5)), infsup (1.047197551196597631e+00, 2.094395102393195707e+00))); %!test %! assert (isequal (acos (infsup (0.25, 0.625)), infsup (8.956647938578649049e-01, 1.318116071652817967e+00))); %!test %! assert (isequal (acos (infsup (-1.0, 1.0)), infsup (0.0, 3.141592653589793560e+00))); ## mpfi_acosh %!# special values %!test %! assert (isequal (acosh (infsup (+1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (acosh (infsup (+1.5, inf)), infsup (9.624236501192068305e-01, inf))); %!# regular values %!test %! assert (isequal (acosh (infsup (1.0, 1.5)), infsup (0.0, 9.624236501192069415e-01))); %!test %! assert (isequal (acosh (infsup (1.5, 1.5)), infsup (9.624236501192068305e-01, 9.624236501192069415e-01))); %!test %! assert (isequal (acosh (infsup (2.0, 1000.0)), infsup (1.316957896924816573e+00, 7.600902209541988697e+00))); ## mpfi_add %!# special values %!test %! assert (isequal (infsup (-inf, -7.0) + infsup (-1.0, +8.0), infsup (-inf, +1.0))); %! assert (isequal (plus (infsup (-inf, -7.0), infsup (-1.0, +8.0)), infsup (-inf, +1.0))); %!test %! assert (isequal (infsup (-inf, 0.0) + infsup (+8.0, inf), infsup (-inf, inf))); %! assert (isequal (plus (infsup (-inf, 0.0), infsup (+8.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, +8.0) + infsup (0.0, +8.0), infsup (-inf, +16.0))); %! assert (isequal (plus (infsup (-inf, +8.0), infsup (0.0, +8.0)), infsup (-inf, +16.0))); %!test %! assert (isequal (infsup (-inf, inf) + infsup (0.0, +8.0), infsup (-inf, inf))); %! assert (isequal (plus (infsup (-inf, inf), infsup (0.0, +8.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, 0.0) + infsup (-inf, -7.0), infsup (-inf, -7.0))); %! assert (isequal (plus (infsup (0.0, 0.0), infsup (-inf, -7.0)), infsup (-inf, -7.0))); %!test %! assert (isequal (infsup (0.0, +8.0) + infsup (-7.0, 0.0), infsup (-7.0, +8.0))); %! assert (isequal (plus (infsup (0.0, +8.0), infsup (-7.0, 0.0)), infsup (-7.0, +8.0))); %!test %! assert (isequal (infsup (0.0, 0.0) + infsup (0.0, +8.0), infsup (0.0, +8.0))); %! assert (isequal (plus (infsup (0.0, 0.0), infsup (0.0, +8.0)), infsup (0.0, +8.0))); %!test %! assert (isequal (infsup (0.0, inf) + infsup (0.0, +8.0), infsup (0.0, inf))); %! assert (isequal (plus (infsup (0.0, inf), infsup (0.0, +8.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (0.0, 0.0) + infsup (+8.0, inf), infsup (+8.0, inf))); %! assert (isequal (plus (infsup (0.0, 0.0), infsup (+8.0, inf)), infsup (+8.0, inf))); %!test %! assert (isequal (infsup (0.0, 0.0) + infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (plus (infsup (0.0, 0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, +8.0) + infsup (0.0, +8.0), infsup (0.0, +16.0))); %! assert (isequal (plus (infsup (0.0, +8.0), infsup (0.0, +8.0)), infsup (0.0, +16.0))); %!test %! assert (isequal (infsup (0.0, 0.0) + infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (plus (infsup (0.0, 0.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, inf) + infsup (-7.0, +8.0), infsup (-7.0, inf))); %! assert (isequal (plus (infsup (0.0, inf), infsup (-7.0, +8.0)), infsup (-7.0, inf))); %!# regular values %!test %! assert (isequal (infsup (-0.375, -5.693566843317114508e-73) + infsup (-0.125, 5.659799424266695230e-73), infsup (-5.000000000000000000e-01, -3.376741905041927849e-75))); %! assert (isequal (plus (infsup (-0.375, -5.693566843317114508e-73), infsup (-0.125, 5.659799424266695230e-73)), infsup (-5.000000000000000000e-01, -3.376741905041927849e-75))); %!test %! assert (isequal (infsup (-4.909093465297726553e-91, 3.202558470389760000e+14) + infsup (-4.547473508864641190e-13, 1.264629250000000000e+08), infsup (-4.547473508864642199e-13, 3.202559735019010000e+14))); %! assert (isequal (plus (infsup (-4.909093465297726553e-91, 3.202558470389760000e+14), infsup (-4.547473508864641190e-13, 1.264629250000000000e+08)), infsup (-4.547473508864642199e-13, 3.202559735019010000e+14))); %!test %! assert (isequal (infsup (-4.0, +7.0) + infsup (-2.443359172835548401e+09, 3e300), infsup (-2.443359176835548401e+09, 3.000000000000000752e+300))); %! assert (isequal (plus (infsup (-4.0, +7.0), infsup (-2.443359172835548401e+09, 3e300)), infsup (-2.443359176835548401e+09, 3.000000000000000752e+300))); %!test %! assert (isequal (infsup (7.205869356633318400e+16, 1.152921504606846976e+18) + infsup (2.814792717434890000e+14, 3.0e300), infsup (7.234017283807667200e+16, 3.000000000000000752e+300))); %! assert (isequal (plus (infsup (7.205869356633318400e+16, 1.152921504606846976e+18), infsup (2.814792717434890000e+14, 3.0e300)), infsup (7.234017283807667200e+16, 3.000000000000000752e+300))); %!# signed zeros %!test %! assert (isequal (infsup (+4.0, +8.0) + infsup (-4.0, -2.0), infsup (0.0, +6.0))); %! assert (isequal (plus (infsup (+4.0, +8.0), infsup (-4.0, -2.0)), infsup (0.0, +6.0))); %!test %! assert (isequal (infsup (+4.0, +8.0) + infsup (-9.0, -8.0), infsup (-5.0, 0.0))); %! assert (isequal (plus (infsup (+4.0, +8.0), infsup (-9.0, -8.0)), infsup (-5.0, 0.0))); ## mpfi_add_d %!# special values %!test %! assert (isequal (infsup (-inf, -7.0) + infsup (-4.000000000000000286e-17, -4.000000000000000286e-17), infsup (-inf, -7.0))); %! assert (isequal (plus (infsup (-inf, -7.0), infsup (-4.000000000000000286e-17, -4.000000000000000286e-17)), infsup (-inf, -7.0))); %!test %! assert (isequal (infsup (-inf, -7.0) + infsup (0.0, 0.0), infsup (-inf, -7.0))); %! assert (isequal (plus (infsup (-inf, -7.0), infsup (0.0, 0.0)), infsup (-inf, -7.0))); %!test %! assert (isequal (infsup (-inf, -7.0) + infsup (4.000000000000000286e-17, 4.000000000000000286e-17), infsup (-inf, -6.999999999999999112e+00))); %! assert (isequal (plus (infsup (-inf, -7.0), infsup (4.000000000000000286e-17, 4.000000000000000286e-17)), infsup (-inf, -6.999999999999999112e+00))); %!test %! assert (isequal (infsup (-inf, 0.0) + infsup (-8.000000000000000572e-17, -8.000000000000000572e-17), infsup (-inf, -8.0e-17))); %! assert (isequal (plus (infsup (-inf, 0.0), infsup (-8.000000000000000572e-17, -8.000000000000000572e-17)), infsup (-inf, -8.0e-17))); %!test %! assert (isequal (infsup (-inf, 0.0) + infsup (0.0, 0.0), infsup (-inf, 0.0))); %! assert (isequal (plus (infsup (-inf, 0.0), infsup (0.0, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-inf, 0.0) + infsup (8.000000000000000572e-17, 8.000000000000000572e-17), infsup (-inf, 8.000000000000000572e-17))); %! assert (isequal (plus (infsup (-inf, 0.0), infsup (8.000000000000000572e-17, 8.000000000000000572e-17)), infsup (-inf, 8.000000000000000572e-17))); %!test %! assert (isequal (infsup (-inf, 8.0) + infsup (-1.600000000000000000e+18, -1.600000000000000000e+18), infsup (-inf, -1.599999999999999744e+18))); %! assert (isequal (plus (infsup (-inf, 8.0), infsup (-1.600000000000000000e+18, -1.600000000000000000e+18)), infsup (-inf, -1.599999999999999744e+18))); %!test %! assert (isequal (infsup (-inf, 8.0) + infsup (0.0, 0.0), infsup (-inf, 8.0))); %! assert (isequal (plus (infsup (-inf, 8.0), infsup (0.0, 0.0)), infsup (-inf, 8.0))); %!test %! assert (isequal (infsup (-inf, 8.0) + infsup (1.600000000000000000e+18, 1.600000000000000000e+18), infsup (-inf, 1.600000000000000256e+18))); %! assert (isequal (plus (infsup (-inf, 8.0), infsup (1.600000000000000000e+18, 1.600000000000000000e+18)), infsup (-inf, 1.600000000000000256e+18))); %!test %! assert (isequal (infsup (-inf, inf) + infsup (-1.600000000000000114e-16, -1.600000000000000114e-16), infsup (-inf, inf))); %! assert (isequal (plus (infsup (-inf, inf), infsup (-1.600000000000000114e-16, -1.600000000000000114e-16)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) + infsup (0.0e-17, 0.0e-17), infsup (-inf, inf))); %! assert (isequal (plus (infsup (-inf, inf), infsup (0.0e-17, 0.0e-17)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) + infsup (1.600000000000000114e-16, 1.600000000000000114e-16), infsup (-inf, inf))); %! assert (isequal (plus (infsup (-inf, inf), infsup (1.600000000000000114e-16, 1.600000000000000114e-16)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, 0.0) + infsup (-1.000000000000000072e-17, -1.000000000000000072e-17), infsup (-1.000000000000000072e-17, -1.000000000000000072e-17))); %! assert (isequal (plus (infsup (0.0, 0.0), infsup (-1.000000000000000072e-17, -1.000000000000000072e-17)), infsup (-1.000000000000000072e-17, -1.000000000000000072e-17))); %!test %! assert (isequal (infsup (0.0, 0.0) + infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (plus (infsup (0.0, 0.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) + infsup (1.000000000000000072e-17, 1.000000000000000072e-17), infsup (1.000000000000000072e-17, 1.000000000000000072e-17))); %! assert (isequal (plus (infsup (0.0, 0.0), infsup (1.000000000000000072e-17, 1.000000000000000072e-17)), infsup (1.000000000000000072e-17, 1.000000000000000072e-17))); %!test %! assert (isequal (infsup (0.0, 8.0) + infsup (-3.000000000000000061e-17, -3.000000000000000061e-17), infsup (-3.000000000000000061e-17, 8.0))); %! assert (isequal (plus (infsup (0.0, 8.0), infsup (-3.000000000000000061e-17, -3.000000000000000061e-17)), infsup (-3.000000000000000061e-17, 8.0))); %!test %! assert (isequal (infsup (0.0, 8.0) + infsup (0.0, 0.0), infsup (0.0, 8.0))); %! assert (isequal (plus (infsup (0.0, 8.0), infsup (0.0, 0.0)), infsup (0.0, 8.0))); %!test %! assert (isequal (infsup (0.0, 8.0) + infsup (2.999999999999999444e-17, 2.999999999999999444e-17), infsup (2.999999999999999444e-17, 8.000000000000001776e+00))); %! assert (isequal (plus (infsup (0.0, 8.0), infsup (2.999999999999999444e-17, 2.999999999999999444e-17)), infsup (2.999999999999999444e-17, 8.000000000000001776e+00))); %!test %! assert (isequal (infsup (0.0, inf) + infsup (-7.000000000000000347e-17, -7.000000000000000347e-17), infsup (-7.000000000000000347e-17, inf))); %! assert (isequal (plus (infsup (0.0, inf), infsup (-7.000000000000000347e-17, -7.000000000000000347e-17)), infsup (-7.000000000000000347e-17, inf))); %!test %! assert (isequal (infsup (0.0, inf) + infsup (0.0, 0.0), infsup (0.0, inf))); %! assert (isequal (plus (infsup (0.0, inf), infsup (0.0, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (0.0, inf) + infsup (6.999999999999999114e-17, 6.999999999999999114e-17), infsup (6.999999999999999114e-17, inf))); %! assert (isequal (plus (infsup (0.0, inf), infsup (6.999999999999999114e-17, 6.999999999999999114e-17)), infsup (6.999999999999999114e-17, inf))); %!# regular values %!test %! assert (isequal (infsup (-32.0, -17.0) + infsup (-3.141592653589793116e+01, -3.141592653589793116e+01), infsup (-6.341592653589793116e+01, -4.841592653589793116e+01))); %! assert (isequal (plus (infsup (-32.0, -17.0), infsup (-3.141592653589793116e+01, -3.141592653589793116e+01)), infsup (-6.341592653589793116e+01, -4.841592653589793116e+01))); %!test %! assert (isequal (infsup (-3.141592653589793116e+01, -17.0) + infsup (3.141592653589793116e+01, 3.141592653589793116e+01), infsup (0.0, 1.441592653589793116e+01))); %! assert (isequal (plus (infsup (-3.141592653589793116e+01, -17.0), infsup (3.141592653589793116e+01, 3.141592653589793116e+01)), infsup (0.0, 1.441592653589793116e+01))); %!test %! assert (isequal (infsup (-32.0, -1.570796326794896558e+01) + infsup (1.570796326794896558e+01, 1.570796326794896558e+01), infsup (-1.629203673205103442e+01, 0.0))); %! assert (isequal (plus (infsup (-32.0, -1.570796326794896558e+01), infsup (1.570796326794896558e+01, 1.570796326794896558e+01)), infsup (-1.629203673205103442e+01, 0.0))); %!test %! assert (isequal (infsup (1.820444444444444443e+01, 3.202559735019019375e+14) + infsup (3.5, 3.5), infsup (2.170444444444444443e+01, 3.202559735019054375e+14))); %! assert (isequal (plus (infsup (1.820444444444444443e+01, 3.202559735019019375e+14), infsup (3.5, 3.5)), infsup (2.170444444444444443e+01, 3.202559735019054375e+14))); %!test %! assert (isequal (infsup (7.111111111111111105e-02, 3.202559735019019375e+14) + infsup (3.5, 3.5), infsup (3.571111111111110681e+00, 3.202559735019054375e+14))); %! assert (isequal (plus (infsup (7.111111111111111105e-02, 3.202559735019019375e+14), infsup (3.5, 3.5)), infsup (3.571111111111110681e+00, 3.202559735019054375e+14))); %!test %! assert (isequal (infsup (-2.550000000000000000e+02, 1.137777777777777777e+00) + infsup (256.5, 256.5), infsup (1.500000000000000000e+00, 2.576377777777777851e+02))); %! assert (isequal (plus (infsup (-2.550000000000000000e+02, 1.137777777777777777e+00), infsup (256.5, 256.5)), infsup (1.500000000000000000e+00, 2.576377777777777851e+02))); %!test %! assert (isequal (infsup (-1.999999999999999778e+00, -2.713328551617526225e-166) + infsup (4097.5, 4097.5), infsup (4.095500000000000000e+03, 4.097500000000000000e+03))); %! assert (isequal (plus (infsup (-1.999999999999999778e+00, -2.713328551617526225e-166), infsup (4097.5, 4097.5)), infsup (4.095500000000000000e+03, 4.097500000000000000e+03))); %!test %! assert (isequal (infsup (1.820444444444444443e+01, 3.202559735019019375e+14) + infsup (-3.5, -3.5), infsup (1.470444444444444443e+01, 3.202559735018984375e+14))); %! assert (isequal (plus (infsup (1.820444444444444443e+01, 3.202559735019019375e+14), infsup (-3.5, -3.5)), infsup (1.470444444444444443e+01, 3.202559735018984375e+14))); %!test %! assert (isequal (infsup (7.111111111111111105e-02, 3.202559735019019375e+14) + infsup (-3.5, -3.5), infsup (-3.428888888888889319e+00, 3.202559735018984375e+14))); %! assert (isequal (plus (infsup (7.111111111111111105e-02, 3.202559735019019375e+14), infsup (-3.5, -3.5)), infsup (-3.428888888888889319e+00, 3.202559735018984375e+14))); %!test %! assert (isequal (infsup (-2.550000000000000000e+02, 1.137777777777777777e+00) + infsup (-256.5, -256.5), infsup (-5.115000000000000000e+02, -2.553622222222222149e+02))); %! assert (isequal (plus (infsup (-2.550000000000000000e+02, 1.137777777777777777e+00), infsup (-256.5, -256.5)), infsup (-5.115000000000000000e+02, -2.553622222222222149e+02))); %!test %! assert (isequal (infsup (-1.999999999999999778e+00, -2.713328551617526225e-166) + infsup (-4097.5, -4097.5), infsup (-4.099500000000000000e+03, -4.097500000000000000e+03))); %! assert (isequal (plus (infsup (-1.999999999999999778e+00, -2.713328551617526225e-166), infsup (-4097.5, -4097.5)), infsup (-4.099500000000000000e+03, -4.097500000000000000e+03))); ## mpfi_asin %!# special values %!test %! assert (isequal (asin (infsup (-1.0, 0.0)), infsup (-1.570796326794896780e+00, 0.0))); %!test %! assert (isequal (asin (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (asin (infsup (0.0, +1.0)), infsup (0.0, 1.570796326794896780e+00))); %!# regular values %!test %! assert (isequal (asin (infsup (-1.0, -0.5)), infsup (-1.570796326794896780e+00, -5.235987755982988157e-01))); %!test %! assert (isequal (asin (infsup (-0.75, -0.25)), infsup (-8.480620789814811156e-01, -2.526802551420786469e-01))); %!test %! assert (isequal (asin (infsup (-0.5, 0.5)), infsup (-5.235987755982989267e-01, 5.235987755982989267e-01))); %!test %! assert (isequal (asin (infsup (0.25, 0.625)), infsup (2.526802551420786469e-01, 6.751315329370316531e-01))); %!test %! assert (isequal (asin (infsup (-1.0, 1.0)), infsup (-1.570796326794896780e+00, 1.570796326794896780e+00))); ## mpfi_asinh %!# special values %!test %! assert (isequal (asinh (infsup (-inf, -7.0)), infsup (-inf, -2.644120761058629032e+00))); %!test %! assert (isequal (asinh (infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (asinh (infsup (-inf, +8.0)), infsup (-inf, 2.776472280723718100e+00))); %!test %! assert (isequal (asinh (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (asinh (infsup (-1.0, 0.0)), infsup (-8.813735870195430477e-01, 0.0))); %!test %! assert (isequal (asinh (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (asinh (infsup (0.0, +1.0)), infsup (0.0, 8.813735870195430477e-01))); %!test %! assert (isequal (asinh (infsup (0.0, +8.0)), infsup (0.0, 2.776472280723718100e+00))); %!test %! assert (isequal (asinh (infsup (0.0, inf)), infsup (0.0, inf))); %!# regular values %!test %! assert (isequal (asinh (infsup (-6.0, -4.0)), infsup (-2.491779852644912197e+00, -2.094712547261101232e+00))); %!test %! assert (isequal (asinh (infsup (-2.0, -0.5)), infsup (-1.443635475178810523e+00, -4.812118250596034152e-01))); %!test %! assert (isequal (asinh (infsup (-1.0, -0.5)), infsup (-8.813735870195430477e-01, -4.812118250596034152e-01))); %!test %! assert (isequal (asinh (infsup (-0.75, -0.25)), infsup (-6.931471805599453972e-01, -2.474664615472634277e-01))); %!test %! assert (isequal (asinh (infsup (-0.5, 0.5)), infsup (-4.812118250596034708e-01, 4.812118250596034708e-01))); %!test %! assert (isequal (asinh (infsup (0.25, 0.625)), infsup (2.474664615472634277e-01, 5.901436857819590820e-01))); %!test %! assert (isequal (asinh (infsup (-1.0, 1.0)), infsup (-8.813735870195430477e-01, 8.813735870195430477e-01))); %!test %! assert (isequal (asinh (infsup (0.125, 17.0)), infsup (1.246767469214427326e-01, 3.527224456199966163e+00))); %!test %! assert (isequal (asinh (infsup (17.0, 42.0)), infsup (3.527224456199965719e+00, 4.430958492080543820e+00))); %!test %! assert (isequal (asinh (infsup (-42.0, 17.0)), infsup (-4.430958492080543820e+00, 3.527224456199966163e+00))); ## mpfi_atan %!# special values %!test %! assert (isequal (atan (infsup (-inf, -7.0)), infsup (-1.570796326794896780e+00, -1.428899272190732539e+00))); %!test %! assert (isequal (atan (infsup (-inf, 0.0)), infsup (-1.570796326794896780e+00, 0.0))); %!test %! assert (isequal (atan (infsup (-inf, +8.0)), infsup (-1.570796326794896780e+00, 1.446441332248135314e+00))); %!test %! assert (isequal (atan (infsup (-inf, inf)), infsup (-1.570796326794896780e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (-1.0, 0.0)), infsup (-7.853981633974483900e-01, 0.0))); %!test %! assert (isequal (atan (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (atan (infsup (0.0, +1.0)), infsup (0.0, 7.853981633974483900e-01))); %!test %! assert (isequal (atan (infsup (0.0, +8.0)), infsup (0.0, 1.446441332248135314e+00))); %!test %! assert (isequal (atan (infsup (0.0, inf)), infsup (0.0, 1.570796326794896780e+00))); %!# regular values %!test %! assert (isequal (atan (infsup (-6.0, -4.0)), infsup (-1.405647649380269870e+00, -1.325817663668032331e+00))); %!test %! assert (isequal (atan (infsup (-2.0, -0.5)), infsup (-1.107148717794090631e+00, -4.636476090008060935e-01))); %!test %! assert (isequal (atan (infsup (-1.0, -0.5)), infsup (-7.853981633974483900e-01, -4.636476090008060935e-01))); %!test %! assert (isequal (atan (infsup (-0.75, -0.25)), infsup (-6.435011087932844820e-01, -2.449786631268641435e-01))); %!test %! assert (isequal (atan (infsup (-0.5, 0.5)), infsup (-4.636476090008061490e-01, 4.636476090008061490e-01))); %!test %! assert (isequal (atan (infsup (0.25, 0.625)), infsup (2.449786631268641435e-01, 5.585993153435624414e-01))); %!test %! assert (isequal (atan (infsup (-1.0, 1.0)), infsup (-7.853981633974483900e-01, 7.853981633974483900e-01))); %!test %! assert (isequal (atan (infsup (0.125, 17.0)), infsup (1.243549945467614243e-01, 1.512040504079174008e+00))); %!test %! assert (isequal (atan (infsup (17.0, 42.0)), infsup (1.512040504079173786e+00, 1.546991300609826814e+00))); %!test %! assert (isequal (atan (infsup (-42.0, 17.0)), infsup (-1.546991300609826814e+00, 1.512040504079174008e+00))); ## mpfi_atan2 %!# special values %!test %! assert (isequal (atan2 (infsup (-inf, -7.0), infsup (-1.0, +8.0)), infsup (-1.712693381399060577e+00, -7.188299996216244159e-01))); %!test %! assert (isequal (atan2 (infsup (-inf, 0.0), infsup (+8.0, inf)), infsup (-1.570796326794896780e+00, 0.0))); %!test %! assert (isequal (atan2 (infsup (-inf, +8.0), infsup (0.0, +8.0)), infsup (-1.570796326794896780e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (-inf, inf), infsup (0.0, +8.0)), infsup (-1.570796326794896780e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 0.0), infsup (-inf, -7.0)), infsup (3.141592653589793116e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, +8.0), infsup (-7.0, 0.0)), infsup (1.570796326794896558e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 0.0), infsup (0.0, +8.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (atan2 (infsup (0.0, inf), infsup (0.0, +8.0)), infsup (0.0, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 0.0), infsup (+8.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (atan2 (infsup (0.0, 0.0), infsup (-inf, inf)), infsup (0.0, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, +8.0), infsup (-7.0, +8.0)), infsup (0.0, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 0.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup (0.0, inf), infsup (0.0, +8.0)), infsup (0.0, 1.570796326794896780e+00))); %!# regular values %!test %! assert (isequal (atan2 (infsup (-17.0, -5.0), infsup (-4002.0, -1.0)), infsup (-3.140343278927514969e+00, -1.629552149510619108e+00))); %!test %! assert (isequal (atan2 (infsup (-17.0, -5.0), infsup (1.0, 4002.0)), infsup (-1.512040504079174008e+00, -1.249374662278356866e-03))); %!test %! assert (isequal (atan2 (infsup (5.0, 17.0), infsup (1.0, 4002.0)), infsup (1.249374662278356866e-03, 1.512040504079174008e+00))); %!test %! assert (isequal (atan2 (infsup (5.0, 17.0), infsup (-4002.0, -1.0)), infsup (1.629552149510619108e+00, 3.140343278927514969e+00))); %!test %! assert (isequal (atan2 (infsup (-17.0, 5.0), infsup (-4002.0, 1.0)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); ## mpfi_atanh %!# special values %!test %! assert (isequal (atanh (infsup (-1.0, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (atanh (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (atanh (infsup (0.0, +1.0)), infsup (0.0, inf))); %!# regular values %!test %! assert (isequal (atanh (infsup (-1.0, -0.5)), infsup (-inf, -5.493061443340547800e-01))); %!test %! assert (isequal (atanh (infsup (-0.75, -0.25)), infsup (-9.729550745276567270e-01, -2.554128118829953054e-01))); %!test %! assert (isequal (atanh (infsup (-0.5, 0.5)), infsup (-5.493061443340548911e-01, 5.493061443340548911e-01))); %!test %! assert (isequal (atanh (infsup (0.25, 0.625)), infsup (2.554128118829953054e-01, 7.331685343967135893e-01))); %!test %! assert (isequal (atanh (infsup (-1.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (atanh (infsup (0.125, 1.0)), infsup (1.256572141404530274e-01, inf))); ## mpfi_bounded_p %!# special values %!test %! assert (isequal (iscommoninterval (infsup (-inf, -8.0)), false)); %!test %! assert (isequal (iscommoninterval (infsup (-inf, 0.0)), false)); %!test %! assert (isequal (iscommoninterval (infsup (-inf, 5.0)), false)); %!test %! assert (isequal (iscommoninterval (infsup (-inf, inf)), false)); %!test %! assert (iscommoninterval (infsup (-8.0, 0.0))); %!test %! assert (iscommoninterval (infsup (0.0, 0.0))); %!test %! assert (iscommoninterval (infsup (0.0, 5.0))); %!test %! assert (isequal (iscommoninterval (infsup (0.0, inf)), false)); %!test %! assert (isequal (iscommoninterval (infsup (5.0, inf)), false)); %!# regular values %!test %! assert (iscommoninterval (infsup (-34.0, -17.0))); %!test %! assert (iscommoninterval (infsup (-8.0, -1.0))); %!test %! assert (iscommoninterval (infsup (-34.0, 17.0))); %!test %! assert (iscommoninterval (infsup (-3.141592653589793116e+00, 3.141592653589793560e+00))); %!test %! assert (iscommoninterval (infsup (3.141592653589793116e+00, 3.141592653589793560e+00))); %!test %! assert (iscommoninterval (infsup (+8.0, 5.070602400912906347e+30))); %!test %! assert (iscommoninterval (infsup (9.999999999999998890e-01, 2.0))); ## mpfi_cbrt %!# special values %!test %! assert (isequal (cbrt (infsup (-inf, -125.0)), infsup (-inf, -5.0))); %!test %! assert (isequal (cbrt (infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (cbrt (infsup (-inf, +64.0)), infsup (-inf, +4.0))); %!test %! assert (isequal (cbrt (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (cbrt (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (cbrt (infsup (0.0, +27.0)), infsup (0.0, +3.0))); %!test %! assert (isequal (cbrt (infsup (0.0, inf)), infsup (0.0, inf))); %!# regular values %!test %! assert (isequal (cbrt (infsup (6.400000000000000000e+01, 1.250000000000000000e+02)), infsup (4.0, 5.0))); %!test %! assert (isequal (cbrt (infsup (-1.866945721837885044e-91, 2.160000000000000000e+02)), infsup (-5.715364030403196328e-31, 6.0))); %!test %! assert (isequal (cbrt (infsup (3.752421802055952558e-300, 2.729924395354002306e-189)), infsup (1.553950629986428998e-100, 1.397602084890329947e-63))); ## mpfi_cos %!# special values %!test %! assert (isequal (cos (infsup (-inf, -7.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-inf, 0.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-inf, +8.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-inf, inf)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-1.0, 0.0)), infsup (5.403023058681396540e-01, 1.0))); %!test %! assert (isequal (cos (infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (cos (infsup (0.0, +1.0)), infsup (5.403023058681396540e-01, 1.0))); %!test %! assert (isequal (cos (infsup (0.0, +8.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (0.0, inf)), infsup (-1.0, 1.0))); %!# regular values %!test %! assert (isequal (cos (infsup (-2.0, -0.5)), infsup (-4.161468365471424069e-01, 8.775825618903727587e-01))); %!test %! assert (isequal (cos (infsup (-1.0, -0.25)), infsup (5.403023058681396540e-01, 9.689124217106448445e-01))); %!test %! assert (isequal (cos (infsup (-0.5, 0.5)), infsup (8.775825618903726477e-01, 1.0))); %!test %! assert (isequal (cos (infsup (-4.5, 0.625)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (1.0, 3.141592653589793116e+00)), infsup (-1.0, 5.403023058681397650e-01))); %!test %! assert (isequal (cos (infsup (0.125, 17.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (17.0, 42.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-7.0, 1.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-7.0, 0.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-7.0, -1.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-7.0, -2.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-7.0, -3.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-7.0, -4.0)), infsup (-6.536436208636119405e-01, 1.0))); %!test %! assert (isequal (cos (infsup (-7.0, -5.0)), infsup (2.836621854632262463e-01, 1.0))); %!test %! assert (isequal (cos (infsup (-7.0, -6.0)), infsup (7.539022543433046009e-01, 1.0))); %!test %! assert (isequal (cos (infsup (-7.0, -7.0)), infsup (7.539022543433046009e-01, 7.539022543433047119e-01))); %!test %! assert (isequal (cos (infsup (-6.0, 1.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-6.0, 0.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-6.0, -1.0)), infsup (-1.0, 9.601702866503660783e-01))); %!test %! assert (isequal (cos (infsup (-6.0, -2.0)), infsup (-1.0, 9.601702866503660783e-01))); %!test %! assert (isequal (cos (infsup (-6.0, -3.0)), infsup (-1.0, 9.601702866503660783e-01))); %!test %! assert (isequal (cos (infsup (-6.0, -4.0)), infsup (-6.536436208636119405e-01, 9.601702866503660783e-01))); %!test %! assert (isequal (cos (infsup (-6.0, -5.0)), infsup (2.836621854632262463e-01, 9.601702866503660783e-01))); %!test %! assert (isequal (cos (infsup (-6.0, -6.0)), infsup (9.601702866503659672e-01, 9.601702866503660783e-01))); %!test %! assert (isequal (cos (infsup (-5.0, 1.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-5.0, 0.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-5.0, -1.0)), infsup (-1.0, 5.403023058681397650e-01))); %!test %! assert (isequal (cos (infsup (-5.0, -2.0)), infsup (-1.0, 2.836621854632263018e-01))); %!test %! assert (isequal (cos (infsup (-5.0, -3.0)), infsup (-1.0, 2.836621854632263018e-01))); %!test %! assert (isequal (cos (infsup (-5.0, -4.0)), infsup (-6.536436208636119405e-01, 2.836621854632263018e-01))); %!test %! assert (isequal (cos (infsup (-5.0, -5.0)), infsup (2.836621854632262463e-01, 2.836621854632263018e-01))); %!test %! assert (isequal (cos (infsup (-4.0, 1.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-4.0, 0.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-4.0, -1.0)), infsup (-1.0, 5.403023058681397650e-01))); %!test %! assert (isequal (cos (infsup (-4.0, -2.0)), infsup (-1.0, -4.161468365471423514e-01))); %!test %! assert (isequal (cos (infsup (-4.0, -3.0)), infsup (-1.0, -6.536436208636118295e-01))); %!test %! assert (isequal (cos (infsup (-4.0, -4.0)), infsup (-6.536436208636119405e-01, -6.536436208636118295e-01))); ## mpfi_cosh %!# special values %!test %! assert (isequal (cosh (infsup (-inf, -7.0)), infsup (5.483170351552120110e+02, inf))); %!test %! assert (isequal (cosh (infsup (-inf, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (cosh (infsup (-inf, +8.0)), infsup (1.0, inf))); %!test %! assert (isequal (cosh (infsup (-inf, inf)), infsup (1.0, inf))); %!test %! assert (isequal (cosh (infsup (-1.0, 0.0)), infsup (1.0, 1.543080634815243934e+00))); %!test %! assert (isequal (cosh (infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (cosh (infsup (0.0, +1.0)), infsup (1.0, 1.543080634815243934e+00))); %!test %! assert (isequal (cosh (infsup (0.0, +8.0)), infsup (1.0, 1.490479161252178301e+03))); %!test %! assert (isequal (cosh (infsup (0.0, inf)), infsup (1.0, inf))); %!# regular values %!test %! assert (isequal (cosh (infsup (-0.125, 0.0)), infsup (1.0, 1.007822677825710889e+00))); %!test %! assert (isequal (cosh (infsup (0.0, 5.000000000000001110e-01)), infsup (1.0, 1.127625965206380920e+00))); %!test %! assert (isequal (cosh (infsup (-4.5, -0.625)), infsup (1.201753692975606302e+00, 4.501412014853003285e+01))); %!test %! assert (isequal (cosh (infsup (1.0, 3.0)), infsup (1.543080634815243712e+00, 1.006766199577776710e+01))); %!test %! assert (isequal (cosh (infsup (17.0, 7.090895657128239691e+02)), infsup (1.207747637678766809e+07, 4.494232837155419541e+307))); ## mpfi_cot %!# special values %!test %! assert (isequal (cot (infsup (-inf, -7.0)), infsup (-inf, inf))); %!test %! assert (isequal (cot (infsup (-inf, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (cot (infsup (-inf, +8.0)), infsup (-inf, inf))); %!test %! assert (isequal (cot (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (cot (infsup (-8.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (cot (infsup (-3.0, 0.0)), infsup (-inf, 7.015252551434533856e+00))); %!test %! assert (isequal (cot (infsup (-1.0, 0.0)), infsup (-inf, -6.420926159343306461e-01))); %!test %! assert (isequal (cot (infsup (0.0, +1.0)), infsup (6.420926159343306461e-01, inf))); %!test %! assert (isequal (cot (infsup (0.0, +3.0)), infsup (-7.015252551434533856e+00, inf))); %!test %! assert (isequal (cot (infsup (0.0, +8.0)), infsup (-inf, inf))); %!test %! assert (isequal (cot (infsup (0.0, inf)), infsup (-inf, inf))); %!# regular values %!test %! assert (isequal (cot (infsup (-3.0, -2.0)), infsup (4.576575543602857121e-01, 7.015252551434533856e+00))); %!test %! assert (isequal (cot (infsup (-3.0, -1.570796326794896780e+00)), infsup (1.608122649676636354e-16, 7.015252551434533856e+00))); %!test %! assert (isequal (cot (infsup (-2.0, 1.570796326794896780e+00)), infsup (-inf, inf))); %!test %! assert (isequal (cot (infsup (0.125, 0.5)), infsup (1.830487721712451776e+00, 7.958289865867011592e+00))); %!test %! assert (isequal (cot (infsup (0.125, 1.570796326794896780e+00)), infsup (-1.608122649676636601e-16, 7.958289865867011592e+00))); %!test %! assert (isequal (cot (infsup (1.570796326794896780e+00, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (cot (infsup (4.0, 6.283185307179586232e+00)), infsup (-4.082809838298842500e+15, 8.636911544506166161e-01))); %!test %! assert (isequal (cot (infsup (3.141592653589793258e+02, 3.151592653589792690e+02)), infsup (6.420926159344081396e-01, 5.090647314608024375e+14))); ## mpfi_coth %!# special values %!test %! assert (isequal (coth (infsup (-inf, -7.0)), infsup (-1.000001663058821100e+00, -1.0))); %!test %! assert (isequal (coth (infsup (-inf, 0.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (coth (infsup (-inf, +8.0)), infsup (-inf, inf))); %!test %! assert (isequal (coth (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (coth (infsup (-8.0, 0.0)), infsup (-inf, -1.000000225070374560e+00))); %!test %! assert (isequal (coth (infsup (-3.0, 0.0)), infsup (-inf, -1.004969823313689004e+00))); %!test %! assert (isequal (coth (infsup (-1.0, 0.0)), infsup (-inf, -1.313035285499331239e+00))); %!test %! assert (isequal (coth (infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (coth (infsup (0.0, +1.0)), infsup (1.313035285499331239e+00, inf))); %!test %! assert (isequal (coth (infsup (0.0, +3.0)), infsup (1.004969823313689004e+00, inf))); %!test %! assert (isequal (coth (infsup (0.0, +8.0)), infsup (1.000000225070374560e+00, inf))); %!test %! assert (isequal (coth (infsup (0.0, inf)), infsup (1.0, inf))); %!# regular values %!test %! assert (isequal (coth (infsup (-3.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (coth (infsup (-10.0, -8.0)), infsup (-1.000000225070374782e+00, -1.000000004122307162e+00))); %!test %! assert (isequal (coth (infsup (7.0, 17.0)), infsup (1.000000000000003331e+00, 1.000001663058821100e+00))); %!test %! assert (isequal (coth (infsup (1.562500000000000347e-02, 5.000000000000001110e-01)), infsup (2.163953413738652021e+00, 6.400520824856424440e+01))); ## mpfi_csc %!# special values %!test %! assert (isequal (csc (infsup (-inf, -7.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-inf, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-inf, 8.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-8.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-3.0, 0.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (csc (infsup (-1.0, 0.0)), infsup (-inf, -1.188395105778121019e+00))); %!test %! assert (isequal (csc (infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (csc (infsup (0.0, +1.0)), infsup (1.188395105778121019e+00, inf))); %!test %! assert (isequal (csc (infsup (0.0, 3.0)), infsup (1.0, inf))); %!test %! assert (isequal (csc (infsup (0.0, 8.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (0.0, inf)), infsup (-inf, inf))); %!# regular values %!test %! assert (isequal (csc (infsup (-6.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-6.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-6.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-6.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-6.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-6.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-6.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-6.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-6.0, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-6.0, -2.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-6.0, -3.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-6.0, -4.0)), infsup (1.0, 3.578899547254406066e+00))); %!test %! assert (isequal (csc (infsup (-6.0, -5.0)), infsup (1.042835212771405784e+00, 3.578899547254406066e+00))); %!test %! assert (isequal (csc (infsup (-6.0, -6.0)), infsup (3.578899547254405622e+00, 3.578899547254406066e+00))); %!test %! assert (isequal (csc (infsup (-5.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-5.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-5.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-5.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-5.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-5.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-5.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-5.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-5.0, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-5.0, -2.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-5.0, -3.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-5.0, -4.0)), infsup (1.0, 1.321348708810902384e+00))); %!test %! assert (isequal (csc (infsup (-5.0, -5.0)), infsup (1.042835212771405784e+00, 1.042835212771406006e+00))); %!test %! assert (isequal (csc (infsup (-4.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-4.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-4.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-4.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-4.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-4.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-4.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-4.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-4.0, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-4.0, -2.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-4.0, -3.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-4.0, -4.0)), infsup (1.321348708810902162e+00, 1.321348708810902384e+00))); %!test %! assert (isequal (csc (infsup (-3.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-3.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-3.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-3.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-3.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-3.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-3.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-3.0, 0.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (csc (infsup (-3.0, -1.0)), infsup (-7.086167395737186681e+00, -1.0))); %!test %! assert (isequal (csc (infsup (-3.0, -2.0)), infsup (-7.086167395737186681e+00, -1.099750170294616414e+00))); %!test %! assert (isequal (csc (infsup (-3.0, -3.0)), infsup (-7.086167395737186681e+00, -7.086167395737185792e+00))); %!test %! assert (isequal (csc (infsup (-2.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-2.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-2.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-2.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-2.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-2.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-2.0, 0.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (csc (infsup (-2.0, -1.0)), infsup (-1.188395105778121241e+00, -1.0))); %!test %! assert (isequal (csc (infsup (-2.0, -2.0)), infsup (-1.099750170294616636e+00, -1.099750170294616414e+00))); %!test %! assert (isequal (csc (infsup (-1.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-1.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-1.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-1.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-1.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-1.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-1.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (-1.0, 0.0)), infsup (-inf, -1.188395105778121019e+00))); %!test %! assert (isequal (csc (infsup (-1.0, -1.0)), infsup (-1.188395105778121241e+00, -1.188395105778121019e+00))); %!test %! assert (isequal (csc (infsup (1.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (1.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (1.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (1.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (1.0, 3.0)), infsup (1.0, 7.086167395737186681e+00))); %!test %! assert (isequal (csc (infsup (1.0, 2.0)), infsup (1.0, 1.188395105778121241e+00))); %!test %! assert (isequal (csc (infsup (1.0, 1.0)), infsup (1.188395105778121019e+00, 1.188395105778121241e+00))); %!test %! assert (isequal (csc (infsup (2.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (2.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (2.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (2.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (2.0, 3.0)), infsup (1.099750170294616414e+00, 7.086167395737186681e+00))); %!test %! assert (isequal (csc (infsup (2.0, 2.0)), infsup (1.099750170294616414e+00, 1.099750170294616636e+00))); %!test %! assert (isequal (csc (infsup (3.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (3.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (3.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (3.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (3.0, 3.0)), infsup (7.086167395737185792e+00, 7.086167395737186681e+00))); %!test %! assert (isequal (csc (infsup (4.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (4.0, 6.0)), infsup (-3.578899547254406066e+00, -1.0))); %!test %! assert (isequal (csc (infsup (4.0, 5.0)), infsup (-1.321348708810902384e+00, -1.0))); %!test %! assert (isequal (csc (infsup (4.0, 4.0)), infsup (-1.321348708810902384e+00, -1.321348708810902162e+00))); %!test %! assert (isequal (csc (infsup (5.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (5.0, 6.0)), infsup (-3.578899547254406066e+00, -1.042835212771405784e+00))); %!test %! assert (isequal (csc (infsup (5.0, 5.0)), infsup (-1.042835212771406006e+00, -1.042835212771405784e+00))); %!test %! assert (isequal (csc (infsup (6.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (csc (infsup (6.0, 6.0)), infsup (-3.578899547254406066e+00, -3.578899547254405622e+00))); %!test %! assert (isequal (csc (infsup (7.0, 7.0)), infsup (1.522101062563730345e+00, 1.522101062563730567e+00))); ## mpfi_csch %!# special values %!test %! assert (isequal (csch (infsup (-inf, -7.0)), infsup (-1.823765447622379028e-03, 0.0))); %!test %! assert (isequal (csch (infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (csch (infsup (-inf, +8.0)), infsup (-inf, inf))); %!test %! assert (isequal (csch (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (csch (infsup (-8.0, 0.0)), infsup (-inf, -6.709253313077229598e-04))); %!test %! assert (isequal (csch (infsup (-3.0, 0.0)), infsup (-inf, -9.982156966882273219e-02))); %!test %! assert (isequal (csch (infsup (-1.0, 0.0)), infsup (-inf, -8.509181282393214474e-01))); %!test %! assert (isequal (csch (infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (csch (infsup (0.0, +1.0)), infsup (8.509181282393214474e-01, inf))); %!test %! assert (isequal (csch (infsup (0.0, +3.0)), infsup (9.982156966882273219e-02, inf))); %!test %! assert (isequal (csch (infsup (0.0, +8.0)), infsup (6.709253313077229598e-04, inf))); %!test %! assert (isequal (csch (infsup (0.0, inf)), infsup (0.0, inf))); %!# regular values %!test %! assert (isequal (csch (infsup (-3.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (csch (infsup (-10.0, -8.0)), infsup (-6.709253313077230682e-04, -9.079985971212215304e-05))); %!test %! assert (isequal (csch (infsup (7.0, 17.0)), infsup (8.279875437570346897e-08, 1.823765447622379028e-03))); %!test %! assert (isequal (csch (infsup (1.562500000000000347e-02, 5.000000000000001110e-01)), infsup (1.919034751334943056e+00, 6.399739590750608187e+01))); ## mpfi_d_div %!# special values %!test %! assert (isequal (infsup (-3.999999999999999670e-17, -3.999999999999999670e-17) ./ infsup (-inf, -7.0), infsup (0.0, 5.714285714285713924e-18))); %! assert (isequal (rdivide (infsup (-3.999999999999999670e-17, -3.999999999999999670e-17), infsup (-inf, -7.0)), infsup (0.0, 5.714285714285713924e-18))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (-inf, -7.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (-inf, -7.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (3.999999999999999670e-17, 3.999999999999999670e-17) ./ infsup (-inf, -7.0), infsup (-5.714285714285713924e-18, 0.0))); %! assert (isequal (rdivide (infsup (3.999999999999999670e-17, 3.999999999999999670e-17), infsup (-inf, -7.0)), infsup (-5.714285714285713924e-18, 0.0))); %!test %! assert (isequal (infsup (-8.000000000000000572e-17, -8.000000000000000572e-17) ./ infsup (-inf, 0.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-8.000000000000000572e-17, -8.000000000000000572e-17), infsup (-inf, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (-inf, 0.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (-inf, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (8.000000000000000572e-17, 8.000000000000000572e-17) ./ infsup (-inf, 0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (8.000000000000000572e-17, 8.000000000000000572e-17), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-1.600000000000000000e+18, -1.600000000000000000e+18) ./ infsup (-inf, 8.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-1.600000000000000000e+18, -1.600000000000000000e+18), infsup (-inf, 8.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (-inf, 8.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (-inf, 8.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (1.600000000000000000e+18, 1.600000000000000000e+18) ./ infsup (-inf, 8.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (1.600000000000000000e+18, 1.600000000000000000e+18), infsup (-inf, 8.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-1.600000000000000114e-16, -1.600000000000000114e-16) ./ infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-1.600000000000000114e-16, -1.600000000000000114e-16), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0e-17, 0.0e-17) ./ infsup (-inf, inf), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0e-17, 0.0e-17), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (1.600000000000000114e-16, 1.600000000000000114e-16) ./ infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (1.600000000000000114e-16, 1.600000000000000114e-16), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-1.000000000000000072e-17, -1.000000000000000072e-17) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (-1.000000000000000072e-17, -1.000000000000000072e-17), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (1.000000000000000072e-17, 1.000000000000000072e-17) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (1.000000000000000072e-17, 1.000000000000000072e-17), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (-3.000000000000000061e-17, -3.000000000000000061e-17) ./ infsup (0.0, 7.0), infsup (-inf, -4.285714285714285251e-18))); %! assert (isequal (rdivide (infsup (-3.000000000000000061e-17, -3.000000000000000061e-17), infsup (0.0, 7.0)), infsup (-inf, -4.285714285714285251e-18))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (0.0, 7.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (0.0, 7.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (3.000000000000000061e-17, 3.000000000000000061e-17) ./ infsup (0.0, 7.0), infsup (4.285714285714285251e-18, inf))); %! assert (isequal (rdivide (infsup (3.000000000000000061e-17, 3.000000000000000061e-17), infsup (0.0, 7.0)), infsup (4.285714285714285251e-18, inf))); %!test %! assert (isequal (infsup (-7.000000000000000347e-17, -7.000000000000000347e-17) ./ infsup (0.0, inf), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-7.000000000000000347e-17, -7.000000000000000347e-17), infsup (0.0, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (0.0, inf), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (0.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (6.999999999999999114e-17, 6.999999999999999114e-17) ./ infsup (0.0, inf), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (6.999999999999999114e-17, 6.999999999999999114e-17), infsup (0.0, inf)), infsup (0.0, inf))); %!# regular values %!test %! assert (isequal (infsup (-2.5, -2.5) ./ infsup (-8.0, 8.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-2.5, -2.5), infsup (-8.0, 8.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-2.5, -2.5) ./ infsup (-8.0, -5.0), infsup (3.125000000000000000e-01, 0.5))); %! assert (isequal (rdivide (infsup (-2.5, -2.5), infsup (-8.0, -5.0)), infsup (3.125000000000000000e-01, 0.5))); %!test %! assert (isequal (infsup (-2.5, -2.5) ./ infsup (25.0, 40.0), infsup (-1.000000000000000056e-01, -6.250000000000000000e-02))); %! assert (isequal (rdivide (infsup (-2.5, -2.5), infsup (25.0, 40.0)), infsup (-1.000000000000000056e-01, -6.250000000000000000e-02))); %!test %! assert (isequal (infsup (-2.5, -2.5) ./ infsup (-16.0, -7.0), infsup (1.562500000000000000e-01, 3.571428571428571508e-01))); %! assert (isequal (rdivide (infsup (-2.5, -2.5), infsup (-16.0, -7.0)), infsup (1.562500000000000000e-01, 3.571428571428571508e-01))); %!test %! assert (isequal (infsup (-2.5, -2.5) ./ infsup (11.0, 143.0), infsup (-2.272727272727272929e-01, -1.748251748251748033e-02))); %! assert (isequal (rdivide (infsup (-2.5, -2.5), infsup (11.0, 143.0)), infsup (-2.272727272727272929e-01, -1.748251748251748033e-02))); %!test %! assert (isequal (infsup (33.125, 33.125) ./ infsup (8.28125, 530.0), infsup (6.250000000000000000e-02, 4.0))); %! assert (isequal (rdivide (infsup (33.125, 33.125), infsup (8.28125, 530.0)), infsup (6.250000000000000000e-02, 4.0))); %!test %! assert (isequal (infsup (33.125, 33.125) ./ infsup (-530.0, -496.875), infsup (-6.666666666666667962e-02, -6.250000000000000000e-02))); %! assert (isequal (rdivide (infsup (33.125, 33.125), infsup (-530.0, -496.875)), infsup (-6.666666666666667962e-02, -6.250000000000000000e-02))); %!test %! assert (isequal (infsup (33.125, 33.125) ./ infsup (54.0, 265.0), infsup (0.125, 6.134259259259259300e-01))); %! assert (isequal (rdivide (infsup (33.125, 33.125), infsup (54.0, 265.0)), infsup (0.125, 6.134259259259259300e-01))); %!test %! assert (isequal (infsup (33.125, 33.125) ./ infsup (52.0, 54.0), infsup (6.134259259259258190e-01, 6.370192307692308376e-01))); %! assert (isequal (rdivide (infsup (33.125, 33.125), infsup (52.0, 54.0)), infsup (6.134259259259258190e-01, 6.370192307692308376e-01))); ## mpfi_diam_abs %!# special values %!test %! assert (isequal (wid (infsup (-inf, -8.0)), inf)); %!test %! assert (isequal (wid (infsup (-inf, 0.0)), inf)); %!test %! assert (isequal (wid (infsup (-inf, 5.0)), inf)); %!test %! assert (isequal (wid (infsup (-inf, inf)), inf)); %!test %! assert (isequal (wid (infsup (-inf, 0.0)), inf)); %!test %! assert (isequal (wid (infsup (-8.0, 0.0)), +8)); %!test %! assert (isequal (wid (infsup (0.0, 0.0)), -0)); %!test %! assert (isequal (wid (infsup (0.0, 5.0)), +5)); %!test %! assert (isequal (wid (infsup (0.0, inf)), inf)); %!# regular values %!test %! assert (isequal (wid (infsup (-34.0, -17.0)), 17)); ## mpfi_div %!# special values %!test %! assert (isequal (infsup (-inf, -7.0) ./ infsup (-1.0, +8.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, -7.0), infsup (-1.0, +8.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 0.0) ./ infsup (+8.0, inf), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-inf, 0.0), infsup (+8.0, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-inf, +8.0) ./ infsup (0.0, +8.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, +8.0), infsup (0.0, +8.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup (0.0, +8.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, inf), infsup (0.0, +8.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (-inf, -7.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (-inf, -7.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, +8.0) ./ infsup (-7.0, 0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (0.0, +8.0), infsup (-7.0, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (0.0, +8.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (0.0, +8.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, inf) ./ infsup (0.0, +8.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (0.0, inf), infsup (0.0, +8.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (+8.0, inf), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (+8.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (-inf, inf), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, +8.0) ./ infsup (-7.0, +8.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (0.0, +8.0), infsup (-7.0, +8.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, inf) ./ infsup (0.0, +8.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (0.0, inf), infsup (0.0, +8.0)), infsup (0.0, inf))); %!# regular value %!test %! assert (isequal (infsup (-1.234567890000000000e+08, -3.003000000000000000e+04) ./ infsup (-2.860000000000000000e+02, -9.000000000000000000e+00), infsup (1.050000000000000000e+02, 1.371742100000000000e+07))); %! assert (isequal (rdivide (infsup (-1.234567890000000000e+08, -3.003000000000000000e+04), infsup (-2.860000000000000000e+02, -9.000000000000000000e+00)), infsup (1.050000000000000000e+02, 1.371742100000000000e+07))); %!test %! assert (isequal (infsup (-1.234567890000000000e+08, -8.022692722045614289e-02) ./ infsup (-4.655552514652689666e+01, -9.000000000000000000e+00), infsup (1.723252545599116220e-03, 1.371742100000000000e+07))); %! assert (isequal (rdivide (infsup (-1.234567890000000000e+08, -8.022692722045614289e-02), infsup (-4.655552514652689666e+01, -9.000000000000000000e+00)), infsup (1.723252545599116220e-03, 1.371742100000000000e+07))); %!test %! assert (isequal (infsup (-1.011478505940748729e+00, -4.582214355468750000e-01) ./ infsup (-2.860000000000000000e+02, -2.885141339691025750e-02), infsup (1.602172851562500000e-03, 3.505819600675333447e+01))); %! assert (isequal (rdivide (infsup (-1.011478505940748729e+00, -4.582214355468750000e-01), infsup (-2.860000000000000000e+02, -2.885141339691025750e-02)), infsup (1.602172851562500000e-03, 3.505819600675333447e+01))); %!test %! assert (isequal (infsup (-1.011478505940748729e+00, -8.022692722045614289e-02) ./ infsup (-2.909720321657931041e+00, -2.885141339691025750e-02), infsup (2.757204072958585953e-02, 3.505819600675333447e+01))); %! assert (isequal (rdivide (infsup (-1.011478505940748729e+00, -8.022692722045614289e-02), infsup (-2.909720321657931041e+00, -2.885141339691025750e-02)), infsup (2.757204072958585953e-02, 3.505819600675333447e+01))); %!test %! assert (isequal (infsup (-3.199335425627046480e+80, -1.785000000000000000e+03) ./ infsup (-7.000000000000000000e+00, 0.0), infsup (2.550000000000000000e+02, inf))); %! assert (isequal (rdivide (infsup (-3.199335425627046480e+80, -1.785000000000000000e+03), infsup (-7.000000000000000000e+00, 0.0)), infsup (2.550000000000000000e+02, inf))); %!test %! assert (isequal (infsup (-2.560000000000000000e+02, -9.207771443835954805e-01) ./ infsup (-1.486045243803458593e+00, 0.0), infsup (6.196158214045437429e-01, inf))); %! assert (isequal (rdivide (infsup (-2.560000000000000000e+02, -9.207771443835954805e-01), infsup (-1.486045243803458593e+00, 0.0)), infsup (6.196158214045437429e-01, inf))); %!test %! assert (isequal (infsup (-1.148236704163043909e+00, -6.001224414812756924e-01) ./ infsup (-5.769162195036162677e-01, 2.794322589058405581e-01), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-1.148236704163043909e+00, -6.001224414812756924e-01), infsup (-5.769162195036162677e-01, 2.794322589058405581e-01)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-100.0, -15.0) ./ infsup (0.0, +3.0), infsup (-inf, -5.0))); %! assert (isequal (rdivide (infsup (-100.0, -15.0), infsup (0.0, +3.0)), infsup (-inf, -5.0))); %!test %! assert (isequal (infsup (-2.0, -1.148236704163043909e+00) ./ infsup (0.0, 5.769162195036162677e-01), infsup (-inf, -1.990300610981255991e+00))); %! assert (isequal (rdivide (infsup (-2.0, -1.148236704163043909e+00), infsup (0.0, 5.769162195036162677e-01)), infsup (-inf, -1.990300610981255991e+00))); %!test %! assert (isequal (infsup (-4.886718345000000000e+09, -4.804800000000000000e+05) ./ infsup (1.035000000000000000e+03, 4.576000000000000000e+03), infsup (-4.721467000000000000e+06, -1.050000000000000000e+02))); %! assert (isequal (rdivide (infsup (-4.886718345000000000e+09, -4.804800000000000000e+05), infsup (1.035000000000000000e+03, 4.576000000000000000e+03)), infsup (-4.721467000000000000e+06, -1.050000000000000000e+02))); %!test %! assert (isequal (infsup (-8.377603228949244141e-01, -3.333999742949345091e-12) ./ infsup (4.532967658553376467e+00, 9.191685613161424376e+62), infsup (-1.848149790599393216e-01, -3.627190793139666743e-75))); %! assert (isequal (rdivide (infsup (-8.377603228949244141e-01, -3.333999742949345091e-12), infsup (4.532967658553376467e+00, 9.191685613161424376e+62)), infsup (-1.848149790599393216e-01, -3.627190793139666743e-75))); %!test %! assert (isequal (infsup (-4.886718345000000000e+09, -1.690035415063386504e+00) ./ infsup (7.896423339843750000e-03, 1.538379475155964848e-01), infsup (-6.188521226240000000e+11, -1.098581619396635745e+01))); %! assert (isequal (rdivide (infsup (-4.886718345000000000e+09, -1.690035415063386504e+00), infsup (7.896423339843750000e-03, 1.538379475155964848e-01)), infsup (-6.188521226240000000e+11, -1.098581619396635745e+01))); %!test %! assert (isequal (infsup (-1.340416516631879063e+01, -1.690035415063386504e+00) ./ infsup (2.833104786595860292e-01, 3.938251456399270012e+01), infsup (-4.731263463934446634e+01, -4.291334450768108377e-02))); %! assert (isequal (rdivide (infsup (-1.340416516631879063e+01, -1.690035415063386504e+00), infsup (2.833104786595860292e-01, 3.938251456399270012e+01)), infsup (-4.731263463934446634e+01, -4.291334450768108377e-02))); %!test %! assert (isequal (infsup (-1.234567890000000000e+08, 0.0) ./ infsup (-1.440000000000000000e+02, -9.000000000000000000e+00), infsup (0.0, 1.371742100000000000e+07))); %! assert (isequal (rdivide (infsup (-1.234567890000000000e+08, 0.0), infsup (-1.440000000000000000e+02, -9.000000000000000000e+00)), infsup (0.0, 1.371742100000000000e+07))); %!test %! assert (isequal (infsup (-7.875890313239129747e-02, 0.0) ./ infsup (-3.906250000000000000e-03, -3.752026718402494930e-03), infsup (0.0, 2.099102939382174071e+01))); %! assert (isequal (rdivide (infsup (-7.875890313239129747e-02, 0.0), infsup (-3.906250000000000000e-03, -3.752026718402494930e-03)), infsup (0.0, 2.099102939382174071e+01))); %!test %! assert (isequal (infsup (-6.413817828600000000e+10, 0.0) ./ infsup (-4.581298449000000000e+10, 0.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-6.413817828600000000e+10, 0.0), infsup (-4.581298449000000000e+10, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-1.148236704163043909e+00, 0.0) ./ infsup (-5.769162195036162677e-01, 2.794322589058405581e-01), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-1.148236704163043909e+00, 0.0), infsup (-5.769162195036162677e-01, 2.794322589058405581e-01)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-6.413817828600000000e+10, 0.0) ./ infsup (0.0, 3.000000000000000000e+00), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-6.413817828600000000e+10, 0.0), infsup (0.0, 3.000000000000000000e+00)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-1.234567890000000000e+08, 0.0) ./ infsup (9.000000000000000000e+00, 1.440000000000000000e+02), infsup (-1.371742100000000000e+07, 0.0))); %! assert (isequal (rdivide (infsup (-1.234567890000000000e+08, 0.0), infsup (9.000000000000000000e+00, 1.440000000000000000e+02)), infsup (-1.371742100000000000e+07, 0.0))); %!test %! assert (isequal (infsup (-7.875890313239129747e-02, 0.0) ./ infsup (3.752026718402494930e-03, 9.000000000000000000e+00), infsup (-2.099102939382174071e+01, 0.0))); %! assert (isequal (rdivide (infsup (-7.875890313239129747e-02, 0.0), infsup (3.752026718402494930e-03, 9.000000000000000000e+00)), infsup (-2.099102939382174071e+01, 0.0))); %!test %! assert (isequal (infsup (-1.234567890000000000e+08, 4.262400000000000000e+04) ./ infsup (-2.806000000000000000e+03, -9.000000000000000000e+00), infsup (-4.736000000000000000e+03, 1.371742100000000000e+07))); %! assert (isequal (rdivide (infsup (-1.234567890000000000e+08, 4.262400000000000000e+04), infsup (-2.806000000000000000e+03, -9.000000000000000000e+00)), infsup (-4.736000000000000000e+03, 1.371742100000000000e+07))); %!test %! assert (isequal (infsup (-1.800000000000000000e+01, 1.600000000000000000e+01) ./ infsup (-8.063085270350000000e+11, -9.000000000000000000e+00), infsup (-1.777777777777777901e+00, 2.0))); %! assert (isequal (rdivide (infsup (-1.800000000000000000e+01, 1.600000000000000000e+01), infsup (-8.063085270350000000e+11, -9.000000000000000000e+00)), infsup (-1.777777777777777901e+00, 2.0))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, 4.582214355468750000e-01) ./ infsup (-8.796093022200000000e+11, -2.860000000000000000e+02), infsup (-1.602172851562500000e-03, 3.496503496503496934e-03))); %! assert (isequal (rdivide (infsup (-1.000000000000000000e+00, 4.582214355468750000e-01), infsup (-8.796093022200000000e+11, -2.860000000000000000e+02)), infsup (-1.602172851562500000e-03, 3.496503496503496934e-03))); %!test %! assert (isequal (infsup (-7.098547996011581596e-01, 6.900706076855589011e+00) ./ infsup (-1.524656123849300000e+13, -8.096558996257990914e-01), infsup (-8.523010923584831033e+00, 8.767364011418107284e-01))); %! assert (isequal (rdivide (infsup (-7.098547996011581596e-01, 6.900706076855589011e+00), infsup (-1.524656123849300000e+13, -8.096558996257990914e-01)), infsup (-8.523010923584831033e+00, 8.767364011418107284e-01))); %!test %! assert (isequal (infsup (-3.199335425627046480e+80, 1.785000000000000000e+03) ./ infsup (-7.000000000000000000e+00, 0.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-3.199335425627046480e+80, 1.785000000000000000e+03), infsup (-7.000000000000000000e+00, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-1.148236704163043909e+00, 6.001224414812756924e-01) ./ infsup (-5.769162195036162677e-01, 2.794322589058405581e-01), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-1.148236704163043909e+00, 6.001224414812756924e-01), infsup (-5.769162195036162677e-01, 2.794322589058405581e-01)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, +15.0) ./ infsup (-3.0, +3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (0.0, +15.0), infsup (-3.0, +3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-3.003000000000000000e+04, 8.972767232000000000e+11) ./ infsup (2.860000000000000000e+02, 3.003000000000000000e+03), infsup (-1.050000000000000000e+02, 3.137331200000000000e+09))); %! assert (isequal (rdivide (infsup (-3.003000000000000000e+04, 8.972767232000000000e+11), infsup (2.860000000000000000e+02, 3.003000000000000000e+03)), infsup (-1.050000000000000000e+02, 3.137331200000000000e+09))); %!test %! assert (isequal (infsup (-1.600000000000000000e+01, 8.972767232000000000e+11) ./ infsup (2.860000000000000000e+02, 3.003000000000000000e+03), infsup (-5.594405594405595095e-02, 3.137331200000000000e+09))); %! assert (isequal (rdivide (infsup (-1.600000000000000000e+01, 8.972767232000000000e+11), infsup (2.860000000000000000e+02, 3.003000000000000000e+03)), infsup (-5.594405594405595095e-02, 3.137331200000000000e+09))); %!test %! assert (isequal (infsup (-3.003000000000000000e+04, 1.024000000000000000e+03) ./ infsup (2.860000000000000000e+02, 3.003000000000000000e+03), infsup (-1.050000000000000000e+02, 3.580419580419580861e+00))); %! assert (isequal (rdivide (infsup (-3.003000000000000000e+04, 1.024000000000000000e+03), infsup (2.860000000000000000e+02, 3.003000000000000000e+03)), infsup (-1.050000000000000000e+02, 3.580419580419580861e+00))); %!test %! assert (isequal (infsup (-1.094531424968872235e+00, 2.080935869470149413e+00) ./ infsup (1.149189461478033136e+00, 2.730000000000000000e+02), infsup (-9.524377499608617237e-01, 1.810785722655120944e+00))); %! assert (isequal (rdivide (infsup (-1.094531424968872235e+00, 2.080935869470149413e+00), infsup (1.149189461478033136e+00, 2.730000000000000000e+02)), infsup (-9.524377499608617237e-01, 1.810785722655120944e+00))); %!test %! assert (isequal (infsup (0.0, 1.234567890000000000e+08) ./ infsup (-1.000000000000000000e+01, -9.000000000000000000e+00), infsup (-1.371742100000000000e+07, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 1.234567890000000000e+08), infsup (-1.000000000000000000e+01, -9.000000000000000000e+00)), infsup (-1.371742100000000000e+07, 0.0))); %!test %! assert (isequal (infsup (0.0, 1.674790800242983879e+00) ./ infsup (-9.375000000000000000e-01, -8.900092612419525651e-01), infsup (-1.881767834534572748e+00, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 1.674790800242983879e+00), infsup (-9.375000000000000000e-01, -8.900092612419525651e-01)), infsup (-1.881767834534572748e+00, 0.0))); %!test %! assert (isequal (infsup (0.0, 1.000000000000000000e+01) ./ infsup (-9.000000000000000000e+00, 0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 1.000000000000000000e+01), infsup (-9.000000000000000000e+00, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (0.0, 1.000000000000000000e+01) ./ infsup (-1.0, +1.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (0.0, 1.000000000000000000e+01), infsup (-1.0, +1.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, 1.234567890000000000e+08) ./ infsup (9.000000000000000000e+00, 1.000000000000000000e+01), infsup (0.0, 1.371742100000000000e+07))); %! assert (isequal (rdivide (infsup (0.0, 1.234567890000000000e+08), infsup (9.000000000000000000e+00, 1.000000000000000000e+01)), infsup (0.0, 1.371742100000000000e+07))); %!test %! assert (isequal (infsup (0.0, 1.372726670594058396e+00) ./ infsup (2.225298220308889352e+00, 1.000000000000000000e+01), infsup (0.0, 6.168731265167295419e-01))); %! assert (isequal (rdivide (infsup (0.0, 1.372726670594058396e+00), infsup (2.225298220308889352e+00, 1.000000000000000000e+01)), infsup (0.0, 6.168731265167295419e-01))); %!test %! assert (isequal (infsup (3.003000000000000000e+04, 1.234567890000000000e+08) ./ infsup (-2.860000000000000000e+02, -9.000000000000000000e+00), infsup (-1.371742100000000000e+07, -1.050000000000000000e+02))); %! assert (isequal (rdivide (infsup (3.003000000000000000e+04, 1.234567890000000000e+08), infsup (-2.860000000000000000e+02, -9.000000000000000000e+00)), infsup (-1.371742100000000000e+07, -1.050000000000000000e+02))); %!test %! assert (isequal (infsup (4.582214355468750000e-01, 1.603374748222124779e+01) ./ infsup (-2.860000000000000000e+02, -2.286926490048424743e+00), infsup (-7.011046289416036359e+00, -1.602172851562500000e-03))); %! assert (isequal (rdivide (infsup (4.582214355468750000e-01, 1.603374748222124779e+01), infsup (-2.860000000000000000e+02, -2.286926490048424743e+00)), infsup (-7.011046289416036359e+00, -1.602172851562500000e-03))); %!test %! assert (isequal (infsup (6.045543549399371441e-01, 1.234567890000000000e+08) ./ infsup (-2.113739798239034684e+01, -9.000000000000000000e+00), infsup (-1.371742100000000000e+07, -2.860117198169773861e-02))); %! assert (isequal (rdivide (infsup (6.045543549399371441e-01, 1.234567890000000000e+08), infsup (-2.113739798239034684e+01, -9.000000000000000000e+00)), infsup (-1.371742100000000000e+07, -2.860117198169773861e-02))); %!test %! assert (isequal (infsup (8.802057619444758618e-01, 1.024602584497202873e+00) ./ infsup (-3.157474458321694599e-01, -1.779681367608609566e-01), infsup (-5.757224878259978418e+00, -2.787689254697360841e+00))); %! assert (isequal (rdivide (infsup (8.802057619444758618e-01, 1.024602584497202873e+00), infsup (-3.157474458321694599e-01, -1.779681367608609566e-01)), infsup (-5.757224878259978418e+00, -2.787689254697360841e+00))); %!test %! assert (isequal (infsup (3.003000000000000000e+04, 6.116600000000000000e+04) ./ infsup (-2.860000000000000000e+02, 0.0), infsup (-inf, -1.050000000000000000e+02))); %! assert (isequal (rdivide (infsup (3.003000000000000000e+04, 6.116600000000000000e+04), infsup (-2.860000000000000000e+02, 0.0)), infsup (-inf, -1.050000000000000000e+02))); %!test %! assert (isequal (infsup (1.037610958488276169e-01, 6.116600000000000000e+04) ./ infsup (-8.870683004794921445e-01, 0.0), infsup (-inf, -1.169708079893521518e-01))); %! assert (isequal (rdivide (infsup (1.037610958488276169e-01, 6.116600000000000000e+04), infsup (-8.870683004794921445e-01, 0.0)), infsup (-inf, -1.169708079893521518e-01))); %!test %! assert (isequal (infsup (5.0, 6.0) ./ infsup (-3.157474458321694599e-01, 1.779681367608609566e-01), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (5.0, 6.0), infsup (-3.157474458321694599e-01, 1.779681367608609566e-01)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (3.003000000000000000e+04, 9.786700000000000000e+05) ./ infsup (0.0, 2.860000000000000000e+02), infsup (1.050000000000000000e+02, inf))); %! assert (isequal (rdivide (infsup (3.003000000000000000e+04, 9.786700000000000000e+05), infsup (0.0, 2.860000000000000000e+02)), infsup (1.050000000000000000e+02, inf))); %!test %! assert (isequal (infsup (1.496153990149218460e+00, 9.786700000000000000e+05) ./ infsup (0.0, 1.283943542366996704e+00), infsup (1.165280201799998139e+00, inf))); %! assert (isequal (rdivide (infsup (1.496153990149218460e+00, 9.786700000000000000e+05), infsup (0.0, 1.283943542366996704e+00)), infsup (1.165280201799998139e+00, inf))); %!test %! assert (isequal (infsup (1.593578642000000000e+09, 7.418529635000000000e+09) ./ infsup (3.136799000000000000e+06, 8.952689000000000000e+06), infsup (1.780000000000000000e+02, 2.365000000000000000e+03))); %! assert (isequal (rdivide (infsup (1.593578642000000000e+09, 7.418529635000000000e+09), infsup (3.136799000000000000e+06, 8.952689000000000000e+06)), infsup (1.780000000000000000e+02, 2.365000000000000000e+03))); %!test %! assert (isequal (infsup (7.198359729899688961e-03, 7.418529635000000000e+09) ./ infsup (2.991484642028808594e+00, 1.424014817987124104e+01), infsup (5.054975298694381908e-04, 2.479882240000000000e+09))); %! assert (isequal (rdivide (infsup (7.198359729899688961e-03, 7.418529635000000000e+09), infsup (2.991484642028808594e+00, 1.424014817987124104e+01)), infsup (5.054975298694381908e-04, 2.479882240000000000e+09))); %!test %! assert (isequal (infsup (3.710339409299194813e-01, 1.002109217638827987e+00) ./ infsup (2.286926490048424743e+00, 8.537949562072753906e+00), infsup (4.345703125000000000e-02, 4.381903930885022724e-01))); %! assert (isequal (rdivide (infsup (3.710339409299194813e-01, 1.002109217638827987e+00), infsup (2.286926490048424743e+00, 8.537949562072753906e+00)), infsup (4.345703125000000000e-02, 4.381903930885022724e-01))); %!test %! assert (isequal (infsup (3.228846131764277760e-02, 3.599978364696688526e+00) ./ infsup (5.102487095624549385e-01, 7.548398876996481599e-01), infsup (4.277524524577111520e-02, 7.055340458937599202e+00))); %! assert (isequal (rdivide (infsup (3.228846131764277760e-02, 3.599978364696688526e+00), infsup (5.102487095624549385e-01, 7.548398876996481599e-01)), infsup (4.277524524577111520e-02, 7.055340458937599202e+00))); ## mpfi_div_d %!# special values %!test %! assert (isequal (infsup (-inf, -7.0) ./ infsup (-7.0, -7.0), infsup (1.0, inf))); %! assert (isequal (rdivide (infsup (-inf, -7.0), infsup (-7.0, -7.0)), infsup (1.0, inf))); %!test %! assert (isequal (infsup (-inf, -7.0) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (-inf, -7.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (-inf, -7.0) ./ infsup (7.0, 7.0), infsup (-inf, -1.0))); %! assert (isequal (rdivide (infsup (-inf, -7.0), infsup (7.0, 7.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (infsup (-inf, 0.0) ./ infsup (-8.000000000000000572e-17, -8.000000000000000572e-17), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-inf, 0.0), infsup (-8.000000000000000572e-17, -8.000000000000000572e-17)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-inf, 0.0) ./ infsup (8.000000000000000572e-17, 8.000000000000000572e-17), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-inf, 0.0), infsup (8.000000000000000572e-17, 8.000000000000000572e-17)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-inf, 8.0) ./ infsup (-3.0, -3.0), infsup (-2.666666666666666963e+00, inf))); %! assert (isequal (rdivide (infsup (-inf, 8.0), infsup (-3.0, -3.0)), infsup (-2.666666666666666963e+00, inf))); %!test %! assert (isequal (infsup (-inf, 8.0) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (-inf, 8.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (-inf, 8.0) ./ infsup (3.0, 3.0), infsup (-inf, 2.666666666666666963e+00))); %! assert (isequal (rdivide (infsup (-inf, 8.0), infsup (3.0, 3.0)), infsup (-inf, 2.666666666666666963e+00))); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup (-1.600000000000000114e-16, -1.600000000000000114e-16), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, inf), infsup (-1.600000000000000114e-16, -1.600000000000000114e-16)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup (0.0e-17, 0.0e-17), infsup)); %! assert (isequal (rdivide (infsup (-inf, inf), infsup (0.0e-17, 0.0e-17)), infsup)); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup (1.600000000000000114e-16, 1.600000000000000114e-16), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, inf), infsup (1.600000000000000114e-16, 1.600000000000000114e-16)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (-1.000000000000000072e-17, -1.000000000000000072e-17), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (-1.000000000000000072e-17, -1.000000000000000072e-17)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (1.000000000000000072e-17, 1.000000000000000072e-17), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (1.000000000000000072e-17, 1.000000000000000072e-17)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 8.0) ./ infsup (-3.000000000000000061e-17, -3.000000000000000061e-17), infsup (-2.666666666666666880e+17, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 8.0), infsup (-3.000000000000000061e-17, -3.000000000000000061e-17)), infsup (-2.666666666666666880e+17, 0.0))); %!test %! assert (isequal (infsup (0.0, 8.0) ./ infsup (3.000000000000000061e-17, 3.000000000000000061e-17), infsup (0.0, 2.666666666666666880e+17))); %! assert (isequal (rdivide (infsup (0.0, 8.0), infsup (3.000000000000000061e-17, 3.000000000000000061e-17)), infsup (0.0, 2.666666666666666880e+17))); %!test %! assert (isequal (infsup (0.0, inf) ./ infsup (-7.000000000000000347e-17, -7.000000000000000347e-17), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (0.0, inf), infsup (-7.000000000000000347e-17, -7.000000000000000347e-17)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (0.0, inf) ./ infsup (6.999999999999999114e-17, 6.999999999999999114e-17), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (0.0, inf), infsup (6.999999999999999114e-17, 6.999999999999999114e-17)), infsup (0.0, inf))); %!# regular values %!test %! assert (isequal (infsup (-4.294967296000000954e+09, -5.000000000000001110e-01) ./ infsup (-1.0, -1.0), infsup (5.000000000000001110e-01, 4.294967296000000954e+09))); %! assert (isequal (rdivide (infsup (-4.294967296000000954e+09, -5.000000000000001110e-01), infsup (-1.0, -1.0)), infsup (5.000000000000001110e-01, 4.294967296000000954e+09))); %!test %! assert (isequal (infsup (-4.294967296000001907e+09, -5.000000000000001110e-01) ./ infsup (5.000000000000001110e-01, 5.000000000000001110e-01), infsup (-8.589934592000001907e+09, -1.0))); %! assert (isequal (rdivide (infsup (-4.294967296000001907e+09, -5.000000000000001110e-01), infsup (5.000000000000001110e-01, 5.000000000000001110e-01)), infsup (-8.589934592000001907e+09, -1.0))); %!test %! assert (isequal (infsup (-4.294967296000000954e+09, -5.000000596046448864e-01) ./ infsup (5.000000000000001110e-01, 5.000000000000001110e-01), infsup (-8.589934592000000000e+09, -1.000000119209289329e+00))); %! assert (isequal (rdivide (infsup (-4.294967296000000954e+09, -5.000000596046448864e-01), infsup (5.000000000000001110e-01, 5.000000000000001110e-01)), infsup (-8.589934592000000000e+09, -1.000000119209289329e+00))); %!test %! assert (isequal (infsup (-4.294967296000001907e+09, -5.000000596046448864e-01) ./ infsup (5.000000000000001110e-01, 5.000000000000001110e-01), infsup (-8.589934592000001907e+09, -1.000000119209289329e+00))); %! assert (isequal (rdivide (infsup (-4.294967296000001907e+09, -5.000000596046448864e-01), infsup (5.000000000000001110e-01, 5.000000000000001110e-01)), infsup (-8.589934592000001907e+09, -1.000000119209289329e+00))); %!test %! assert (isequal (infsup (-5.688888888888888884e-01, 4.003199668773774219e+13) ./ infsup (-5.124095576030431000e+15, -5.124095576030431000e+15), infsup (-7.812500000000000000e-03, 1.110223024625156540e-16))); %! assert (isequal (rdivide (infsup (-5.688888888888888884e-01, 4.003199668773774219e+13), infsup (-5.124095576030431000e+15, -5.124095576030431000e+15)), infsup (-7.812500000000000000e-03, 1.110223024625156540e-16))); %!test %! assert (isequal (infsup (-5.688888888888888884e-01, 5.000000000000001110e-01) ./ infsup (-5.124095576030431000e+15, -5.124095576030431000e+15), infsup (-9.757819552369542371e-17, 1.110223024625156540e-16))); %! assert (isequal (rdivide (infsup (-5.688888888888888884e-01, 5.000000000000001110e-01), infsup (-5.124095576030431000e+15, -5.124095576030431000e+15)), infsup (-9.757819552369542371e-17, 1.110223024625156540e-16))); %!test %! assert (isequal (infsup (-1.0, 4.003199668773774219e+13) ./ infsup (-5.124095576030431000e+15, -5.124095576030431000e+15), infsup (-7.812500000000000000e-03, 1.951563910473908228e-16))); %! assert (isequal (rdivide (infsup (-1.0, 4.003199668773774219e+13), infsup (-5.124095576030431000e+15, -5.124095576030431000e+15)), infsup (-7.812500000000000000e-03, 1.951563910473908228e-16))); %!test %! assert (isequal (infsup (-1.0, 5.000000000000001110e-01) ./ infsup (-5.124095576030431000e+15, -5.124095576030431000e+15), infsup (-9.757819552369542371e-17, 1.951563910473908228e-16))); %! assert (isequal (rdivide (infsup (-1.0, 5.000000000000001110e-01), infsup (-5.124095576030431000e+15, -5.124095576030431000e+15)), infsup (-9.757819552369542371e-17, 1.951563910473908228e-16))); ## mpfi_d_sub %!# special values %!test %! assert (isequal (infsup (-4.000000000000000286e-17, -4.000000000000000286e-17) - infsup (-inf, -7.0), infsup (6.999999999999999112e+00, inf))); %! assert (isequal (minus (infsup (-4.000000000000000286e-17, -4.000000000000000286e-17), infsup (-inf, -7.0)), infsup (6.999999999999999112e+00, inf))); %!test %! assert (isequal (infsup (0.0, 0.0) - infsup (-inf, -7.0), infsup (7.0, inf))); %! assert (isequal (minus (infsup (0.0, 0.0), infsup (-inf, -7.0)), infsup (7.0, inf))); %!test %! assert (isequal (infsup (4.000000000000000286e-17, 4.000000000000000286e-17) - infsup (-inf, -7.0), infsup (7.0, inf))); %! assert (isequal (minus (infsup (4.000000000000000286e-17, 4.000000000000000286e-17), infsup (-inf, -7.0)), infsup (7.0, inf))); %!test %! assert (isequal (infsup (-8.192000000000000586e-14, -8.192000000000000586e-14) - infsup (-inf, 0.0), infsup (-8.192000000000000586e-14, inf))); %! assert (isequal (minus (infsup (-8.192000000000000586e-14, -8.192000000000000586e-14), infsup (-inf, 0.0)), infsup (-8.192000000000000586e-14, inf))); %!test %! assert (isequal (infsup (0.0, 0.0) - infsup (-inf, 0.0), infsup (0.0, inf))); %! assert (isequal (minus (infsup (0.0, 0.0), infsup (-inf, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (8.192000000000000586e-14, 8.192000000000000586e-14) - infsup (-inf, 0.0), infsup (8.192000000000000586e-14, inf))); %! assert (isequal (minus (infsup (8.192000000000000586e-14, 8.192000000000000586e-14), infsup (-inf, 0.0)), infsup (8.192000000000000586e-14, inf))); %!test %! assert (isequal (infsup (-1.600000000000000000e+18, -1.600000000000000000e+18) - infsup (-inf, 8.0), infsup (-1.600000000000000256e+18, inf))); %! assert (isequal (minus (infsup (-1.600000000000000000e+18, -1.600000000000000000e+18), infsup (-inf, 8.0)), infsup (-1.600000000000000256e+18, inf))); %!test %! assert (isequal (infsup (0.0, 0.0) - infsup (-inf, 8.0), infsup (-8.0, inf))); %! assert (isequal (minus (infsup (0.0, 0.0), infsup (-inf, 8.0)), infsup (-8.0, inf))); %!test %! assert (isequal (infsup (1.600000000000000000e+18, 1.600000000000000000e+18) - infsup (-inf, 8.0), infsup (1.599999999999999744e+18, inf))); %! assert (isequal (minus (infsup (1.600000000000000000e+18, 1.600000000000000000e+18), infsup (-inf, 8.0)), infsup (1.599999999999999744e+18, inf))); %!test %! assert (isequal (infsup (-1.600000000000000114e-16, -1.600000000000000114e-16) - infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (minus (infsup (-1.600000000000000114e-16, -1.600000000000000114e-16), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0e-17, 0.0e-17) - infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (minus (infsup (0.0e-17, 0.0e-17), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (1.600000000000000114e-16, 1.600000000000000114e-16) - infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (minus (infsup (1.600000000000000114e-16, 1.600000000000000114e-16), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-1.000000000000000072e-17, -1.000000000000000072e-17) - infsup (0.0, 0.0), infsup (-1.000000000000000072e-17, -1.000000000000000072e-17))); %! assert (isequal (minus (infsup (-1.000000000000000072e-17, -1.000000000000000072e-17), infsup (0.0, 0.0)), infsup (-1.000000000000000072e-17, -1.000000000000000072e-17))); %!test %! assert (isequal (infsup (0.0, 0.0) - infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (minus (infsup (0.0, 0.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (1.000000000000000072e-17, 1.000000000000000072e-17) - infsup (0.0, 0.0), infsup (1.000000000000000072e-17, 1.000000000000000072e-17))); %! assert (isequal (minus (infsup (1.000000000000000072e-17, 1.000000000000000072e-17), infsup (0.0, 0.0)), infsup (1.000000000000000072e-17, 1.000000000000000072e-17))); %!test %! assert (isequal (infsup (-3.000000000000000061e-17, -3.000000000000000061e-17) - infsup (0.0, 8.0), infsup (-8.000000000000001776e+00, -3.000000000000000061e-17))); %! assert (isequal (minus (infsup (-3.000000000000000061e-17, -3.000000000000000061e-17), infsup (0.0, 8.0)), infsup (-8.000000000000001776e+00, -3.000000000000000061e-17))); %!test %! assert (isequal (infsup (0.0, 0.0) - infsup (0.0, 8.0), infsup (-8.0, 0.0))); %! assert (isequal (minus (infsup (0.0, 0.0), infsup (0.0, 8.0)), infsup (-8.0, 0.0))); %!test %! assert (isequal (infsup (3.000000000000000061e-17, 3.000000000000000061e-17) - infsup (0.0, 8.0), infsup (-8.0, 3.000000000000000061e-17))); %! assert (isequal (minus (infsup (3.000000000000000061e-17, 3.000000000000000061e-17), infsup (0.0, 8.0)), infsup (-8.0, 3.000000000000000061e-17))); %!test %! assert (isequal (infsup (-7.000000000000000347e-17, -7.000000000000000347e-17) - infsup (0.0, inf), infsup (-inf, -7.000000000000000347e-17))); %! assert (isequal (minus (infsup (-7.000000000000000347e-17, -7.000000000000000347e-17), infsup (0.0, inf)), infsup (-inf, -7.000000000000000347e-17))); %!test %! assert (isequal (infsup (0.0, 0.0) - infsup (0.0, inf), infsup (-inf, 0.0))); %! assert (isequal (minus (infsup (0.0, 0.0), infsup (0.0, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-6.999999999999999114e-17, -6.999999999999999114e-17) - infsup (0.0, inf), infsup (-inf, -6.999999999999999114e-17))); %! assert (isequal (minus (infsup (-6.999999999999999114e-17, -6.999999999999999114e-17), infsup (0.0, inf)), infsup (-inf, -6.999999999999999114e-17))); %!# regular values %!test %! assert (isequal (infsup (-3.141592653589793116e+01, -3.141592653589793116e+01) - infsup (17.0, 32.0), infsup (-6.341592653589793116e+01, -4.841592653589793116e+01))); %! assert (isequal (minus (infsup (-3.141592653589793116e+01, -3.141592653589793116e+01), infsup (17.0, 32.0)), infsup (-6.341592653589793116e+01, -4.841592653589793116e+01))); %!test %! assert (isequal (infsup (3.141592653589793116e+01, 3.141592653589793116e+01) - infsup (17.0, 3.141592653589793116e+01), infsup (0.0, 1.441592653589793116e+01))); %! assert (isequal (minus (infsup (3.141592653589793116e+01, 3.141592653589793116e+01), infsup (17.0, 3.141592653589793116e+01)), infsup (0.0, 1.441592653589793116e+01))); %!test %! assert (isequal (infsup (1.570796326794896558e+01, 1.570796326794896558e+01) - infsup (1.570796326794896558e+01, 32.0), infsup (-1.629203673205103442e+01, 0.0))); %! assert (isequal (minus (infsup (1.570796326794896558e+01, 1.570796326794896558e+01), infsup (1.570796326794896558e+01, 32.0)), infsup (-1.629203673205103442e+01, 0.0))); %!test %! assert (isequal (infsup (3.5, 3.5) - infsup (-3.202559735019019375e+14, -1.820444444444444443e+01), infsup (2.170444444444444443e+01, 3.202559735019054375e+14))); %! assert (isequal (minus (infsup (3.5, 3.5), infsup (-3.202559735019019375e+14, -1.820444444444444443e+01)), infsup (2.170444444444444443e+01, 3.202559735019054375e+14))); %!test %! assert (isequal (infsup (3.5, 3.5) - infsup (-3.202559735019019375e+14, -7.111111111111111105e-02), infsup (3.571111111111110681e+00, 3.202559735019054375e+14))); %! assert (isequal (minus (infsup (3.5, 3.5), infsup (-3.202559735019019375e+14, -7.111111111111111105e-02)), infsup (3.571111111111110681e+00, 3.202559735019054375e+14))); %!test %! assert (isequal (infsup (256.5, 256.5) - infsup (-1.137777777777777777e+00, 2.550000000000000000e+02), infsup (1.500000000000000000e+00, 2.576377777777777851e+02))); %! assert (isequal (minus (infsup (256.5, 256.5), infsup (-1.137777777777777777e+00, 2.550000000000000000e+02)), infsup (1.500000000000000000e+00, 2.576377777777777851e+02))); %!test %! assert (isequal (infsup (4097.5, 4097.5) - infsup (2.713328551617526225e-166, 1.999999999999999778e+00), infsup (4.095500000000000000e+03, 4.097500000000000000e+03))); %! assert (isequal (minus (infsup (4097.5, 4097.5), infsup (2.713328551617526225e-166, 1.999999999999999778e+00)), infsup (4.095500000000000000e+03, 4.097500000000000000e+03))); %!test %! assert (isequal (infsup (-3.5, -3.5) - infsup (-3.202559735019019375e+14, -1.820444444444444443e+01), infsup (1.470444444444444443e+01, 3.202559735018984375e+14))); %! assert (isequal (minus (infsup (-3.5, -3.5), infsup (-3.202559735019019375e+14, -1.820444444444444443e+01)), infsup (1.470444444444444443e+01, 3.202559735018984375e+14))); %!test %! assert (isequal (infsup (-3.5, -3.5) - infsup (-3.202559735019019375e+14, -7.111111111111111105e-02), infsup (-3.428888888888889319e+00, 3.202559735018984375e+14))); %! assert (isequal (minus (infsup (-3.5, -3.5), infsup (-3.202559735019019375e+14, -7.111111111111111105e-02)), infsup (-3.428888888888889319e+00, 3.202559735018984375e+14))); %!test %! assert (isequal (infsup (-256.5, -256.5) - infsup (-1.137777777777777777e+00, 2.550000000000000000e+02), infsup (-5.115000000000000000e+02, -2.553622222222222149e+02))); %! assert (isequal (minus (infsup (-256.5, -256.5), infsup (-1.137777777777777777e+00, 2.550000000000000000e+02)), infsup (-5.115000000000000000e+02, -2.553622222222222149e+02))); %!test %! assert (isequal (infsup (-4097.5, -4097.5) - infsup (2.713328551617526225e-166, 1.999999999999999778e+00), infsup (-4.099500000000000000e+03, -4.097500000000000000e+03))); %! assert (isequal (minus (infsup (-4097.5, -4097.5), infsup (2.713328551617526225e-166, 1.999999999999999778e+00)), infsup (-4.099500000000000000e+03, -4.097500000000000000e+03))); ## mpfi_exp %!# special values %!test %! assert (isequal (exp (infsup (-inf, -7.0)), infsup (0.0, 9.118819655545162437e-04))); %!test %! assert (isequal (exp (infsup (-inf, 0.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (exp (infsup (-inf, +1.0)), infsup (0.0, 2.718281828459045535e+00))); %!test %! assert (isequal (exp (infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (exp (infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (exp (infsup (0.0, +1.0)), infsup (1.0, 2.718281828459045535e+00))); %!test %! assert (isequal (exp (infsup (0.0, inf)), infsup (1.0, inf))); %!# regular values %!test %! assert (isequal (exp (infsup (-123.0, -17.0)), infsup (3.817497188671174176e-54, 4.139937718785166831e-08))); %!test %! assert (isequal (exp (infsup (-0.125, 0.25)), infsup (8.824969025845953441e-01, 1.284025416687741616e+00))); %!test %! assert (isequal (exp (infsup (-0.125, 0.0)), infsup (8.824969025845953441e-01, 1.0))); %!test %! assert (isequal (exp (infsup (0.0, 0.25)), infsup (1.0, 1.284025416687741616e+00))); %!test %! assert (isequal (exp (infsup (7.105427357601001859e-14, 7.815970093361102045e-14)), infsup (1.000000000000071054e+00, 1.000000000000078382e+00))); ## mpfi_exp2 %!# special values %!test %! assert (isequal (pow2 (infsup (-inf, -1.0)), infsup (0.0, 0.5))); %!test %! assert (isequal (pow2 (infsup (-inf, 0.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow2 (infsup (-inf, 1.0)), infsup (0.0, 2.0))); %!test %! assert (isequal (pow2 (infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow2 (infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow2 (infsup (0.0, +1.0)), infsup (1.0, 2.0))); %!test %! assert (isequal (pow2 (infsup (0.0, inf)), infsup (1.0, inf))); %!# regular values %!test %! assert (isequal (pow2 (infsup (-123.0, -17.0)), infsup (9.403954806578300064e-38, 7.629394531250000000e-06))); %!test %! assert (isequal (pow2 (infsup (-7.0, 7.0)), infsup (7.812500000000000000e-03, 1.280000000000000000e+02))); %!test %! assert (isequal (pow2 (infsup (-0.125, 0.25)), infsup (9.170040432046712153e-01, 1.189207115002721249e+00))); %!test %! assert (isequal (pow2 (infsup (-0.125, 0.0)), infsup (9.170040432046712153e-01, 1.0))); %!test %! assert (isequal (pow2 (infsup (0.0, 0.25)), infsup (1.0, 1.189207115002721249e+00))); %!test %! assert (isequal (pow2 (infsup (7.105427357601001859e-14, 7.815970093361102045e-14)), infsup (1.000000000000049072e+00, 1.000000000000054179e+00))); ## mpfi_expm1 %!# special values %!test %! assert (isequal (expm1 (infsup (-inf, -7.0)), infsup (-1.0, -9.990881180344454160e-01))); %!test %! assert (isequal (expm1 (infsup (-inf, 0.0)), infsup (-1.0, 0.0))); %!test %! assert (isequal (expm1 (infsup (-inf, 1.0)), infsup (-1.0, 1.718281828459045313e+00))); %!test %! assert (isequal (expm1 (infsup (-inf, inf)), infsup (-1.0, inf))); %!test %! assert (isequal (expm1 (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (expm1 (infsup (0.0, 1.0)), infsup (0.0, 1.718281828459045313e+00))); %!test %! assert (isequal (expm1 (infsup (0.0, inf)), infsup (0.0, inf))); %!# regular values %!test %! assert (isequal (expm1 (infsup (-36.0, -36.0)), infsup (-9.999999999999997780e-01, -9.999999999999996669e-01))); %!test %! assert (isequal (expm1 (infsup (-0.125, 0.25)), infsup (-1.175030974154046004e-01, 2.840254166877415054e-01))); %!test %! assert (isequal (expm1 (infsup (-0.125, 0.0)), infsup (-1.175030974154046004e-01, 0.0))); %!test %! assert (isequal (expm1 (infsup (0.0, 0.25)), infsup (0.0, 2.840254166877415054e-01))); %!test %! assert (isequal (expm1 (infsup (7.105427357601001859e-14, 7.815970093361102045e-14)), infsup (7.105427357601254294e-14, 7.815970093361408754e-14))); ## mpfi_hypot %!# special values %!test %! assert (isequal (hypot (infsup (-inf, -7.0), infsup (-1.0, 8.0)), infsup (7.0, inf))); %!test %! assert (isequal (hypot (infsup (-inf, 0.0), infsup (8.0, inf)), infsup (8.0, inf))); %!test %! assert (isequal (hypot (infsup (-inf, 8.0), infsup (0.0, 8.0)), infsup (0.0, inf))); %!test %! assert (isequal (hypot (infsup (-inf, inf), infsup (0.0, 8.0)), infsup (0.0, inf))); %!test %! assert (isequal (hypot (infsup (0.0, 0.0), infsup (-inf, -7.0)), infsup (7.0, inf))); %!test %! assert (isequal (hypot (infsup (0.0, 3.0), infsup (-4.0, 0.0)), infsup (0.0, 5.0))); %!test %! assert (isequal (hypot (infsup (0.0, 0.0), infsup (0.0, 8.0)), infsup (0.0, 8.0))); %!test %! assert (isequal (hypot (infsup (0.0, inf), infsup (0.0, 8.0)), infsup (0.0, inf))); %!test %! assert (isequal (hypot (infsup (0.0, 0.0), infsup (8.0, inf)), infsup (8.0, inf))); %!test %! assert (isequal (hypot (infsup (0.0, 0.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (hypot (infsup (0.0, 5.0), infsup (0.0, 12.0)), infsup (0.0, 13.0))); %!test %! assert (isequal (hypot (infsup (0.0, 0.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (hypot (infsup (0.0, inf), infsup (-7.0, 8.0)), infsup (0.0, inf))); %!# regular values %!test %! assert (isequal (hypot (infsup (-12.0, -5.0), infsup (-35.0, -12.0)), infsup (13.0, 37.0))); %!test %! assert (isequal (hypot (infsup (6.0, 7.0), infsup (1.0, 24.0)), infsup (6.082762530298219339e+00, 25.0))); %!test %! assert (isequal (hypot (infsup (-4.0, +7.0), infsup (-25.0, 3.0)), infsup (0.0, 2.596150997149434048e+01))); %!test %! assert (isequal (hypot (infsup (6.082762530298219339e+00, 2.596150997149434048e+01), infsup (6.082762530298219339e+00, 2.596150997149434048e+01)), infsup (8.602325267042624901e+00, 3.671511950137164604e+01))); ## mpfi_intersect %!# special values %!test %! assert (isequal (intersect (infsup (-inf, -7.0), infsup (-1.0, +8.0)), infsup)); %!test %! assert (isequal (intersect (infsup (-inf, 0.0), infsup (+8.0, inf)), infsup)); %!test %! assert (isequal (intersect (infsup (-inf, +8.0), infsup (0.0, +8.0)), infsup (0.0, +8.0))); %!test %! assert (isequal (intersect (infsup (-inf, inf), infsup (0.0, +8.0)), infsup (0.0, +8.0))); %!test %! assert (isequal (intersect (infsup (0.0, 0.0), infsup (-inf, -7.0)), infsup)); %!test %! assert (isequal (intersect (infsup (0.0, +8.0), infsup (-7.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (intersect (infsup (0.0, 0.0), infsup (0.0, +8.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (intersect (infsup (0.0, inf), infsup (0.0, +8.0)), infsup (0.0, +8.0))); %!test %! assert (isequal (intersect (infsup (0.0, 0.0), infsup (+8.0, inf)), infsup)); %!test %! assert (isequal (intersect (infsup (0.0, 0.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (intersect (infsup (0.0, +8.0), infsup (-7.0, +8.0)), infsup (0.0, +8.0))); %!test %! assert (isequal (intersect (infsup (0.0, 0.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (intersect (infsup (0.0, inf), infsup (0.0, +8.0)), infsup (0.0, +8.0))); %!# regular values %!test %! assert (isequal (intersect (infsup (1.800000000000000000e+01, 1.440000000000000000e+02), infsup (-1.300000000000000000e+01, 5.200000000000000000e+01)), infsup (1.800000000000000000e+01, 5.200000000000000000e+01))); ## mpfi_inv %!# special values %!test %! assert (isequal (1 ./ infsup (-inf, -.25), infsup (-4.0, 0.0))); %! assert (isequal (rdivide (1, infsup (-inf, -.25)), infsup (-4.0, 0.0))); %! assert (isequal (pown (infsup (-inf, -.25), -1), infsup (-4.0, 0.0))); %! assert (isequal (infsup (-inf, -.25) .^ -1, infsup (-4.0, 0.0))); %! assert (isequal (power (infsup (-inf, -.25), -1), infsup (-4.0, 0.0))); %! assert (isequal (infsup (-inf, -.25) ^ -1, infsup (-4.0, 0.0))); %! assert (isequal (mpower (infsup (-inf, -.25), -1), infsup (-4.0, 0.0))); %!test %! assert (isequal (1 ./ infsup (-inf, 0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (1, infsup (-inf, 0.0)), infsup (-inf, 0.0))); %! assert (isequal (pown (infsup (-inf, 0.0), -1), infsup (-inf, 0.0))); %! assert (isequal (infsup (-inf, 0.0) .^ -1, infsup (-inf, 0.0))); %! assert (isequal (power (infsup (-inf, 0.0), -1), infsup (-inf, 0.0))); %! assert (isequal (infsup (-inf, 0.0) ^ -1, infsup (-inf, 0.0))); %! assert (isequal (mpower (infsup (-inf, 0.0), -1), infsup (-inf, 0.0))); %!test %! assert (isequal (1 ./ infsup (-inf, +4.0), infsup (-inf, inf))); %! assert (isequal (rdivide (1, infsup (-inf, +4.0)), infsup (-inf, inf))); %! assert (isequal (pown (infsup (-inf, +4.0), -1), infsup (-inf, inf))); %! assert (isequal (infsup (-inf, +4.0) .^ -1, infsup (-inf, inf))); %! assert (isequal (power (infsup (-inf, +4.0), -1), infsup (-inf, inf))); %! assert (isequal (infsup (-inf, +4.0) ^ -1, infsup (-inf, inf))); %! assert (isequal (mpower (infsup (-inf, +4.0), -1), infsup (-inf, inf))); %!test %! assert (isequal (1 ./ infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (1, infsup (-inf, inf)), infsup (-inf, inf))); %! assert (isequal (pown (infsup (-inf, inf), -1), infsup (-inf, inf))); %! assert (isequal (infsup (-inf, inf) .^ -1, infsup (-inf, inf))); %! assert (isequal (power (infsup (-inf, inf), -1), infsup (-inf, inf))); %! assert (isequal (infsup (-inf, inf) ^ -1, infsup (-inf, inf))); %! assert (isequal (mpower (infsup (-inf, inf), -1), infsup (-inf, inf))); %!test %! assert (isequal (1 ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (1, infsup (0.0, 0.0)), infsup)); %! assert (isequal (pown (infsup (0.0, 0.0), -1), infsup)); %! assert (isequal (infsup (0.0, 0.0) .^ -1, infsup)); %! assert (isequal (power (infsup (0.0, 0.0), -1), infsup)); %! assert (isequal (infsup (0.0, 0.0) ^ -1, infsup)); %! assert (isequal (mpower (infsup (0.0, 0.0), -1), infsup)); %!test %! assert (isequal (1 ./ infsup (0.0, +2.0), infsup (+.5, inf))); %! assert (isequal (rdivide (1, infsup (0.0, +2.0)), infsup (+.5, inf))); %! assert (isequal (pown (infsup (0.0, +2.0), -1), infsup (+.5, inf))); %! assert (isequal (infsup (0.0, +2.0) .^ -1, infsup (+.5, inf))); %! assert (isequal (power (infsup (0.0, +2.0), -1), infsup (+.5, inf))); %! assert (isequal (infsup (0.0, +2.0) ^ -1, infsup (+.5, inf))); %! assert (isequal (mpower (infsup (0.0, +2.0), -1), infsup (+.5, inf))); %!test %! assert (isequal (1 ./ infsup (0.0, inf), infsup (0.0, inf))); %! assert (isequal (rdivide (1, infsup (0.0, inf)), infsup (0.0, inf))); %! assert (isequal (pown (infsup (0.0, inf), -1), infsup (0.0, inf))); %! assert (isequal (infsup (0.0, inf) .^ -1, infsup (0.0, inf))); %! assert (isequal (power (infsup (0.0, inf), -1), infsup (0.0, inf))); %! assert (isequal (infsup (0.0, inf) ^ -1, infsup (0.0, inf))); %! assert (isequal (mpower (infsup (0.0, inf), -1), infsup (0.0, inf))); %!# regular values %!test %! assert (isequal (1 ./ infsup (-8.0, -2.0), infsup (-.5, -0.125))); %! assert (isequal (rdivide (1, infsup (-8.0, -2.0)), infsup (-.5, -0.125))); %! assert (isequal (pown (infsup (-8.0, -2.0), -1), infsup (-.5, -0.125))); %! assert (isequal (infsup (-8.0, -2.0) .^ -1, infsup (-.5, -0.125))); %! assert (isequal (power (infsup (-8.0, -2.0), -1), infsup (-.5, -0.125))); %! assert (isequal (infsup (-8.0, -2.0) ^ -1, infsup (-.5, -0.125))); %! assert (isequal (mpower (infsup (-8.0, -2.0), -1), infsup (-.5, -0.125))); %!test %! assert (isequal (1 ./ infsup (6.250000000000000000e-02, 6.329046211334584671e-01), infsup (1.580016903983283205e+00, 1.600000000000000000e+01))); %! assert (isequal (rdivide (1, infsup (6.250000000000000000e-02, 6.329046211334584671e-01)), infsup (1.580016903983283205e+00, 1.600000000000000000e+01))); %! assert (isequal (pown (infsup (6.250000000000000000e-02, 6.329046211334584671e-01), -1), infsup (1.580016903983283205e+00, 1.600000000000000000e+01))); %! assert (isequal (infsup (6.250000000000000000e-02, 6.329046211334584671e-01) .^ -1, infsup (1.580016903983283205e+00, 1.600000000000000000e+01))); %! assert (isequal (power (infsup (6.250000000000000000e-02, 6.329046211334584671e-01), -1), infsup (1.580016903983283205e+00, 1.600000000000000000e+01))); %! assert (isequal (infsup (6.250000000000000000e-02, 6.329046211334584671e-01) ^ -1, infsup (1.580016903983283205e+00, 1.600000000000000000e+01))); %! assert (isequal (mpower (infsup (6.250000000000000000e-02, 6.329046211334584671e-01), -1), infsup (1.580016903983283205e+00, 1.600000000000000000e+01))); %!test %! assert (isequal (1 ./ infsup (2.026869327694375278e-01, +64.0), infsup (0.015625, 4.933717168326436031e+00))); %! assert (isequal (rdivide (1, infsup (2.026869327694375278e-01, +64.0)), infsup (0.015625, 4.933717168326436031e+00))); %! assert (isequal (pown (infsup (2.026869327694375278e-01, +64.0), -1), infsup (0.015625, 4.933717168326436031e+00))); %! assert (isequal (infsup (2.026869327694375278e-01, +64.0) .^ -1, infsup (0.015625, 4.933717168326436031e+00))); %! assert (isequal (power (infsup (2.026869327694375278e-01, +64.0), -1), infsup (0.015625, 4.933717168326436031e+00))); %! assert (isequal (infsup (2.026869327694375278e-01, +64.0) ^ -1, infsup (0.015625, 4.933717168326436031e+00))); %! assert (isequal (mpower (infsup (2.026869327694375278e-01, +64.0), -1), infsup (0.015625, 4.933717168326436031e+00))); %!test %! assert (isequal (1 ./ infsup (-6.816974503452348788e-01, -1.950973066082791751e-01), infsup (-5.125647387884359141e+00, -1.466926419474747556e+00))); %! assert (isequal (rdivide (1, infsup (-6.816974503452348788e-01, -1.950973066082791751e-01)), infsup (-5.125647387884359141e+00, -1.466926419474747556e+00))); %! assert (isequal (pown (infsup (-6.816974503452348788e-01, -1.950973066082791751e-01), -1), infsup (-5.125647387884359141e+00, -1.466926419474747556e+00))); %! assert (isequal (infsup (-6.816974503452348788e-01, -1.950973066082791751e-01) .^ -1, infsup (-5.125647387884359141e+00, -1.466926419474747556e+00))); %! assert (isequal (power (infsup (-6.816974503452348788e-01, -1.950973066082791751e-01), -1), infsup (-5.125647387884359141e+00, -1.466926419474747556e+00))); %! assert (isequal (infsup (-6.816974503452348788e-01, -1.950973066082791751e-01) ^ -1, infsup (-5.125647387884359141e+00, -1.466926419474747556e+00))); %! assert (isequal (mpower (infsup (-6.816974503452348788e-01, -1.950973066082791751e-01), -1), infsup (-5.125647387884359141e+00, -1.466926419474747556e+00))); ## mpfi_is_neg %!# special values %!test %! assert (precedes (infsup (-inf, -8.0), infsup (0.0, 0.0))); %!test %! assert (precedes (infsup (-inf, 0.0), infsup (0.0, 0.0))); %!test %! assert (isequal (precedes (infsup (-inf, 5.0), infsup (0.0, 0.0)), false)); %!test %! assert (isequal (precedes (infsup (-inf, inf), infsup (0.0, 0.0)), false)); %!test %! assert (precedes (infsup (-8.0, 0.0), infsup (0.0, 0.0))); %!test %! assert (precedes (infsup (0.0, 0.0), infsup (0.0, 0.0))); %!test %! assert (isequal (precedes (infsup (0.0, 5.0), infsup (0.0, 0.0)), false)); %!test %! assert (isequal (precedes (infsup (0.0, inf), infsup (0.0, 0.0)), false)); %!test %! assert (isequal (precedes (infsup (5.0, inf), infsup (0.0, 0.0)), false)); %!# regular values %!test %! assert (precedes (infsup (-34.0, -17.0), infsup (0.0, 0.0))); %!test %! assert (precedes (infsup (-8.0, -1.0), infsup (0.0, 0.0))); %!test %! assert (isequal (precedes (infsup (-34.0, 17.0), infsup (0.0, 0.0)), false)); %!test %! assert (isequal (precedes (infsup (-3.141592653589793116e+00, 3.141592653589793560e+00), infsup (0.0, 0.0)), false)); %!test %! assert (isequal (precedes (infsup (3.141592653589793116e+00, 3.141592653589793560e+00), infsup (0.0, 0.0)), false)); %!test %! assert (isequal (precedes (infsup (+8.0, 5.070602400912906347e+30), infsup (0.0, 0.0)), false)); %!test %! assert (isequal (precedes (infsup (9.999999999999998890e-01, 2.0), infsup (0.0, 0.0)), false)); ## mpfi_is_nonneg %!# special values %!test %! assert (isequal (le (infsup (0.0, 0.0), infsup (-inf, -8.0)), false)); %! assert (isequal (infsup (0.0, 0.0) <= infsup (-inf, -8.0), false)); %!test %! assert (isequal (le (infsup (0.0, 0.0), infsup (-inf, 0.0)), false)); %! assert (isequal (infsup (0.0, 0.0) <= infsup (-inf, 0.0), false)); %!test %! assert (isequal (le (infsup (0.0, 0.0), infsup (-inf, 5.0)), false)); %! assert (isequal (infsup (0.0, 0.0) <= infsup (-inf, 5.0), false)); %!test %! assert (isequal (le (infsup (0.0, 0.0), infsup (-inf, inf)), false)); %! assert (isequal (infsup (0.0, 0.0) <= infsup (-inf, inf), false)); %!test %! assert (isequal (le (infsup (0.0, 0.0), infsup (-8.0, 0.0)), false)); %! assert (isequal (infsup (0.0, 0.0) <= infsup (-8.0, 0.0), false)); %!test %! assert (le (infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (infsup (0.0, 0.0) <= infsup (0.0, 0.0)); %!test %! assert (le (infsup (0.0, 0.0), infsup (0.0, 5.0))); %! assert (infsup (0.0, 0.0) <= infsup (0.0, 5.0)); %!test %! assert (le (infsup (0.0, 0.0), infsup (0.0, inf))); %! assert (infsup (0.0, 0.0) <= infsup (0.0, inf)); %!test %! assert (le (infsup (0.0, 0.0), infsup (5.0, inf))); %! assert (infsup (0.0, 0.0) <= infsup (5.0, inf)); %!# regular values %!test %! assert (isequal (le (infsup (0.0, 0.0), infsup (-34.0, -17.0)), false)); %! assert (isequal (infsup (0.0, 0.0) <= infsup (-34.0, -17.0), false)); %!test %! assert (isequal (le (infsup (0.0, 0.0), infsup (-8.0, -1.0)), false)); %! assert (isequal (infsup (0.0, 0.0) <= infsup (-8.0, -1.0), false)); %!test %! assert (isequal (le (infsup (0.0, 0.0), infsup (-34.0, 17.0)), false)); %! assert (isequal (infsup (0.0, 0.0) <= infsup (-34.0, 17.0), false)); %!test %! assert (isequal (le (infsup (0.0, 0.0), infsup (-3.141592653589793116e+00, 3.141592653589793560e+00)), false)); %! assert (isequal (infsup (0.0, 0.0) <= infsup (-3.141592653589793116e+00, 3.141592653589793560e+00), false)); %!test %! assert (le (infsup (0.0, 0.0), infsup (3.141592653589793116e+00, 3.141592653589793560e+00))); %! assert (infsup (0.0, 0.0) <= infsup (3.141592653589793116e+00, 3.141592653589793560e+00)); %!test %! assert (le (infsup (0.0, 0.0), infsup (+8.0, 5.070602400912906347e+30))); %! assert (infsup (0.0, 0.0) <= infsup (+8.0, 5.070602400912906347e+30)); %!test %! assert (le (infsup (0.0, 0.0), infsup (9.999999999999998890e-01, 2.0))); %! assert (infsup (0.0, 0.0) <= infsup (9.999999999999998890e-01, 2.0)); ## mpfi_is_nonpos %!# special values %!test %! assert (le (infsup (-inf, -8.0), infsup (0.0, 0.0))); %! assert (infsup (-inf, -8.0) <= infsup (0.0, 0.0)); %!test %! assert (le (infsup (-inf, 0.0), infsup (0.0, 0.0))); %! assert (infsup (-inf, 0.0) <= infsup (0.0, 0.0)); %!test %! assert (isequal (le (infsup (-inf, 5.0), infsup (0.0, 0.0)), false)); %! assert (isequal (infsup (-inf, 5.0) <= infsup (0.0, 0.0), false)); %!test %! assert (isequal (le (infsup (-inf, inf), infsup (0.0, 0.0)), false)); %! assert (isequal (infsup (-inf, inf) <= infsup (0.0, 0.0), false)); %!test %! assert (le (infsup (-8.0, 0.0), infsup (0.0, 0.0))); %! assert (infsup (-8.0, 0.0) <= infsup (0.0, 0.0)); %!test %! assert (le (infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (infsup (0.0, 0.0) <= infsup (0.0, 0.0)); %!test %! assert (isequal (le (infsup (0.0, 5.0), infsup (0.0, 0.0)), false)); %! assert (isequal (infsup (0.0, 5.0) <= infsup (0.0, 0.0), false)); %!test %! assert (isequal (le (infsup (0.0, inf), infsup (0.0, 0.0)), false)); %! assert (isequal (infsup (0.0, inf) <= infsup (0.0, 0.0), false)); %!test %! assert (isequal (le (infsup (5.0, inf), infsup (0.0, 0.0)), false)); %! assert (isequal (infsup (5.0, inf) <= infsup (0.0, 0.0), false)); %!# regular values %!test %! assert (le (infsup (-34.0, -17.0), infsup (0.0, 0.0))); %! assert (infsup (-34.0, -17.0) <= infsup (0.0, 0.0)); %!test %! assert (le (infsup (-8.0, -1.0), infsup (0.0, 0.0))); %! assert (infsup (-8.0, -1.0) <= infsup (0.0, 0.0)); %!test %! assert (isequal (le (infsup (-34.0, 17.0), infsup (0.0, 0.0)), false)); %! assert (isequal (infsup (-34.0, 17.0) <= infsup (0.0, 0.0), false)); %!test %! assert (isequal (le (infsup (-3.141592653589793116e+00, 3.141592653589793560e+00), infsup (0.0, 0.0)), false)); %! assert (isequal (infsup (-3.141592653589793116e+00, 3.141592653589793560e+00) <= infsup (0.0, 0.0), false)); %!test %! assert (isequal (le (infsup (3.141592653589793116e+00, 3.141592653589793560e+00), infsup (0.0, 0.0)), false)); %! assert (isequal (infsup (3.141592653589793116e+00, 3.141592653589793560e+00) <= infsup (0.0, 0.0), false)); %!test %! assert (isequal (le (infsup (8.0, 5.070602400912906347e+30), infsup (0.0, 0.0)), false)); %! assert (isequal (infsup (8.0, 5.070602400912906347e+30) <= infsup (0.0, 0.0), false)); %!test %! assert (isequal (le (infsup (9.999999999999998890e-01, 2.0), infsup (0.0, 0.0)), false)); %! assert (isequal (infsup (9.999999999999998890e-01, 2.0) <= infsup (0.0, 0.0), false)); ## mpfi_is_pos %!# special values %!test %! assert (isequal (precedes (infsup (0.0, 0.0), infsup (-inf, -8.0)), false)); %!test %! assert (isequal (precedes (infsup (0.0, 0.0), infsup (-inf, 0.0)), false)); %!test %! assert (isequal (precedes (infsup (0.0, 0.0), infsup (-inf, 5.0)), false)); %!test %! assert (isequal (precedes (infsup (0.0, 0.0), infsup (-inf, inf)), false)); %!test %! assert (isequal (precedes (infsup (0.0, 0.0), infsup (-8.0, 0.0)), false)); %!test %! assert (precedes (infsup (0.0, 0.0), infsup (0.0, 0.0))); %!test %! assert (precedes (infsup (0.0, 0.0), infsup (0.0, 5.0))); %!test %! assert (precedes (infsup (0.0, 0.0), infsup (0.0, inf))); %!test %! assert (precedes (infsup (0.0, 0.0), infsup (5.0, inf))); %!# regular values %!test %! assert (isequal (precedes (infsup (0.0, 0.0), infsup (-34.0, -17.0)), false)); %!test %! assert (isequal (precedes (infsup (0.0, 0.0), infsup (-8.0, -1.0)), false)); %!test %! assert (isequal (precedes (infsup (0.0, 0.0), infsup (-34.0, 17.0)), false)); %!test %! assert (isequal (precedes (infsup (0.0, 0.0), infsup (-3.141592653589793116e+00, 3.141592653589793560e+00)), false)); %!test %! assert (precedes (infsup (0.0, 0.0), infsup (3.141592653589793116e+00, 3.141592653589793560e+00))); %!test %! assert (precedes (infsup (0.0, 0.0), infsup (+8.0, 5.070602400912906347e+30))); %!test %! assert (precedes (infsup (0.0, 0.0), infsup (9.999999999999998890e-01, 2.0))); ## mpfi_is_strictly_neg %!# special values %!test %! assert (strictprecedes (infsup (-inf, -8.0), infsup (0.0, 0.0))); %!test %! assert (isequal (strictprecedes (infsup (-inf, 0.0), infsup (0.0, 0.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (-inf, 5.0), infsup (0.0, 0.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (-inf, inf), infsup (0.0, 0.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (-8.0, 0.0), infsup (0.0, 0.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (0.0, 0.0), infsup (0.0, 0.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (0.0, 5.0), infsup (0.0, 0.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (0.0, inf), infsup (0.0, 0.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (5.0, inf), infsup (0.0, 0.0)), false)); %!# regular values %!test %! assert (strictprecedes (infsup (-34.0, -17.0), infsup (0.0, 0.0))); %!test %! assert (strictprecedes (infsup (-8.0, -1.0), infsup (0.0, 0.0))); %!test %! assert (isequal (strictprecedes (infsup (-34.0, 17.0), infsup (0.0, 0.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (-3.141592653589793116e+00, 3.141592653589793560e+00), infsup (0.0, 0.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (3.141592653589793116e+00, 3.141592653589793560e+00), infsup (0.0, 0.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (+8.0, 5.070602400912906347e+30), infsup (0.0, 0.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (9.999999999999998890e-01, 2.0), infsup (0.0, 0.0)), false)); ## mpfi_is_strictly_pos %!# special values %!test %! assert (isequal (strictprecedes (infsup (0.0, 0.0), infsup (-inf, -8.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (0.0, 0.0), infsup (-inf, 0.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (0.0, 0.0), infsup (-inf, 5.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (0.0, 0.0), infsup (-inf, inf)), false)); %!test %! assert (isequal (strictprecedes (infsup (0.0, 0.0), infsup (-8.0, 0.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (0.0, 0.0), infsup (0.0, 0.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (0.0, 0.0), infsup (0.0, 5.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (0.0, 0.0), infsup (0.0, inf)), false)); %!test %! assert (strictprecedes (infsup (0.0, 0.0), infsup (5.0, inf))); %!# regular values %!test %! assert (isequal (strictprecedes (infsup (0.0, 0.0), infsup (-34.0, -17.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (0.0, 0.0), infsup (-8.0, -1.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (0.0, 0.0), infsup (-34.0, 17.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (0.0, 0.0), infsup (-3.141592653589793116e+00, 3.141592653589793560e+00)), false)); %!test %! assert (strictprecedes (infsup (0.0, 0.0), infsup (3.141592653589793116e+00, 3.141592653589793560e+00))); %!test %! assert (strictprecedes (infsup (0.0, 0.0), infsup (+8.0, 5.070602400912906347e+30))); %!test %! assert (strictprecedes (infsup (0.0, 0.0), infsup (9.999999999999998890e-01, 2.0))); ## mpfi_log %!# special values %!test %! assert (isequal (log (infsup (0.0, +1.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (log (infsup (0.0, inf)), infsup (-inf, inf))); %!# regular values %!test %! assert (isequal (log (infsup (+1.0, +1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (log (infsup (6.245333006274822998e+10, 3.502953474593552856e+11)), infsup (2.485768539575924052e+01, 2.658204248547260207e+01))); %!test %! assert (isequal (log (infsup (7.112834182118892290e-01, +1.0)), infsup (-3.406843094616900380e-01, 0.0))); %!test %! assert (isequal (log (infsup (+1.0, 1.164158665593125820e+09)), infsup (0.0, 2.087526448761322229e+01))); %!test %! assert (isequal (log (infsup (2.045368051078361511e+10, 6.649390526214926758e+11)), infsup (2.374142867931890777e+01, 2.722296122320888756e+01))); ## mpfi_log1p %!# special values %!test %! assert (isequal (log1p (infsup (-1.0, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (log1p (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (log1p (infsup (0.0, 1.0)), infsup (0.0, 6.931471805599453972e-01))); %!test %! assert (isequal (log1p (infsup (0.0, inf)), infsup (0.0, inf))); %!# regular values %!test %! assert (isequal (log1p (infsup (-7.112834182118892290e-01, 0.0)), infsup (-1.242309757910986745e+00, 0.0))); %!test %! assert (isequal (log1p (infsup (0.0, 1.164158665593125820e+09)), infsup (0.0, 2.087526448847221161e+01))); %!test %! assert (isequal (log1p (infsup (2.045368051078361511e+10, 6.649390526214926758e+11)), infsup (2.374142867936779666e+01, 2.722296122321039036e+01))); ## mpfi_log2 %!# special values %!test %! assert (isequal (log2 (infsup (0.0, +1.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (log2 (infsup (0.0, inf)), infsup (-inf, inf))); %!# regular values %!test %! assert (isequal (log2 (infsup (1.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (log2 (infsup (7.112834182118892290e-01, 1.0)), infsup (-4.915035637690611248e-01, 0.0))); %!test %! assert (isequal (log2 (infsup (1.0, 1.164158665593125820e+09)), infsup (0.0, 3.011664055352508385e+01))); %!test %! assert (isequal (log2 (infsup (2.045368051078361511e+10, 6.649390526214926758e+11)), infsup (3.425164141927239569e+01, 3.927443115503601234e+01))); ## mpfi_log10 %!# special values %!test %! assert (isequal (log10 (infsup (0.0, 1.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (log10 (infsup (0.0, inf)), infsup (-inf, inf))); %!# regular values %!test %! assert (isequal (log10 (infsup (1.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (log10 (infsup (6.245333006274822998e+10, 3.502953474593552856e+11)), infsup (1.079555560026529015e+01, 1.154443436915855159e+01))); %!test %! assert (isequal (log10 (infsup (7.112834182118892290e-01, 1.0)), infsup (-1.479573156702317926e-01, 0.0))); %!test %! assert (isequal (log10 (infsup (100.0, 1.164158665593125820e+09)), infsup (2.0, 9.066012175241336735e+00))); %!test %! assert (isequal (log10 (infsup (2.045368051078361511e+10, 6.649390526214926758e+11)), infsup (1.031077146792780930e+01, 1.182278184030581869e+01))); ## mpfi_mag %!# special values %!test %! assert (isequal (mag (infsup (-inf, -8.0)), inf)); %!test %! assert (isequal (mag (infsup (-inf, 0.0)), inf)); %!test %! assert (isequal (mag (infsup (-inf, 5.0)), inf)); %!test %! assert (isequal (mag (infsup (-inf, inf)), inf)); %!test %! assert (isequal (mag (infsup (-inf, 0.0)), inf)); %!test %! assert (isequal (mag (infsup (-8.0, 0.0)), +8)); %!test %! assert (isequal (mag (infsup (0.0, 0.0)), +0)); %!test %! assert (isequal (mag (infsup (0.0, 5.0)), +5)); %!test %! assert (isequal (mag (infsup (0.0, inf)), inf)); %!# regular values %!test %! assert (isequal (mag (infsup (-34.0, -17.0)), 34)); ## mpfi_mid %!# special values %!test %! assert (isequal (mid (infsup (-8.0, 0.0)), -4)); %!test %! assert (isequal (mid (infsup (0.0, 0.0)), +0)); %!test %! assert (isequal (mid (infsup (0.0, 5.0)), +2.5)); %!# regular values %!test %! assert (isequal (mid (infsup (-34.0, -17.0)), -2.550000000000000000e+01)); %!test %! assert (isequal (mid (infsup (-34.0, 17.0)), -8.5)); %!test %! assert (isequal (mid (infsup (0.0, 8.006399337547525000e+13)), 4.003199668773762500e+13)); %!test %! assert (isequal (mid (infsup (3.141592653589793116e+00, 3.141592653589793560e+00)), 3.141592653589793116e+00)); %!test %! assert (isequal (mid (infsup (-3.141592653589793560e+00, -3.141592653589793116e+00)), -3.141592653589793116e+00)); %!test %! assert (isequal (mid (infsup (-4.0, -9.999999999999986677e-01)), -2.499999999999999112e+00)); %!test %! assert (isequal (mid (infsup (-8.0, -9.999999999999977796e-01)), -4.499999999999999112e+00)); %!test %! assert (isequal (mid (infsup (-9.999999999999998890e-01, 2.0)), 0.5)); ## mpfi_mig %!# special values %!test %! assert (isequal (mig (infsup (-inf, -8.0)), 8)); %!test %! assert (isequal (mig (infsup (-inf, 0.0)), +0)); %!test %! assert (isequal (mig (infsup (-inf, 5.0)), +0)); %!test %! assert (isequal (mig (infsup (-inf, inf)), +0)); %!test %! assert (isequal (mig (infsup (-inf, 0.0)), +0)); %!test %! assert (isequal (mig (infsup (-8.0, 0.0)), +0)); %!test %! assert (isequal (mig (infsup (0.0, 0.0)), +0)); %!test %! assert (isequal (mig (infsup (0.0, 5.0)), +0)); %!test %! assert (isequal (mig (infsup (0.0, inf)), +0)); %!# regular values %!test %! assert (isequal (mig (infsup (-34.0, -17.0)), 17)); ## mpfi_mul %!# special values %!test %! assert (isequal (infsup (-inf, -7.0) .* infsup (-1.0, +8.0), infsup (-inf, inf))); %! assert (isequal (times (infsup (-inf, -7.0), infsup (-1.0, +8.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 0.0) .* infsup (+8.0, inf), infsup (-inf, 0.0))); %! assert (isequal (times (infsup (-inf, 0.0), infsup (+8.0, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-inf, +8.0) .* infsup (0.0, +8.0), infsup (-inf, +64.0))); %! assert (isequal (times (infsup (-inf, +8.0), infsup (0.0, +8.0)), infsup (-inf, +64.0))); %!test %! assert (isequal (infsup (-inf, inf) .* infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-inf, inf), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-inf, inf) .* infsup (0.0, +8.0), infsup (-inf, inf))); %! assert (isequal (times (infsup (-inf, inf), infsup (0.0, +8.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, 0.0) .* infsup (-inf, -7.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (0.0, 0.0), infsup (-inf, -7.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, +8.0) .* infsup (-7.0, 0.0), infsup (-56.0, 0.0))); %! assert (isequal (times (infsup (0.0, +8.0), infsup (-7.0, 0.0)), infsup (-56.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) .* infsup (0.0, +8.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (0.0, 0.0), infsup (0.0, +8.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, inf) .* infsup (0.0, +8.0), infsup (0.0, inf))); %! assert (isequal (times (infsup (0.0, inf), infsup (0.0, +8.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (0.0, 0.0) .* infsup (+8.0, inf), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (0.0, 0.0), infsup (+8.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) .* infsup (-inf, inf), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (0.0, 0.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, +8.0) .* infsup (-7.0, +8.0), infsup (-56.0, +64.0))); %! assert (isequal (times (infsup (0.0, +8.0), infsup (-7.0, +8.0)), infsup (-56.0, +64.0))); %!test %! assert (isequal (infsup (0.0, 0.0) .* infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (0.0, 0.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, inf) .* infsup (0.0, +8.0), infsup (0.0, inf))); %! assert (isequal (times (infsup (0.0, inf), infsup (0.0, +8.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-3.0, +7.0) .* infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-3.0, +7.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!# regular values %!test %! assert (isequal (infsup (-1.300000000000000000e+01, -9.000000000000000000e+00) .* infsup (-4.000000000000000000e+00, -2.000000000000000000e+00), infsup (1.800000000000000000e+01, 5.200000000000000000e+01))); %! assert (isequal (times (infsup (-1.300000000000000000e+01, -9.000000000000000000e+00), infsup (-4.000000000000000000e+00, -2.000000000000000000e+00)), infsup (1.800000000000000000e+01, 5.200000000000000000e+01))); %!test %! assert (isequal (infsup (-1.300000000000000000e+01, -8.713145944805367193e-01) .* infsup (-4.000000000000000000e+00, -4.005481558786871954e-02), infsup (3.490034540093651244e-02, 5.200000000000000000e+01))); %! assert (isequal (times (infsup (-1.300000000000000000e+01, -8.713145944805367193e-01), infsup (-4.000000000000000000e+00, -4.005481558786871954e-02)), infsup (3.490034540093651244e-02, 5.200000000000000000e+01))); %!test %! assert (isequal (infsup (-8.844699037058322277e-01, -5.086643052155234157e-01) .* infsup (-3.468109146783053820e-01, -2.002700255759105596e-01), infsup (1.018702134150656358e-01, 3.067438163096523618e-01))); %! assert (isequal (times (infsup (-8.844699037058322277e-01, -5.086643052155234157e-01), infsup (-3.468109146783053820e-01, -2.002700255759105596e-01)), infsup (1.018702134150656358e-01, 3.067438163096523618e-01))); %!test %! assert (isequal (infsup (-5.500000000000000000e+01, -7.000000000000000000e+00) .* infsup (-1.000000000000000000e+00, 3.400000000000000000e+01), infsup (-1.870000000000000000e+03, 5.500000000000000000e+01))); %! assert (isequal (times (infsup (-5.500000000000000000e+01, -7.000000000000000000e+00), infsup (-1.000000000000000000e+00, 3.400000000000000000e+01)), infsup (-1.870000000000000000e+03, 5.500000000000000000e+01))); %!test %! assert (isequal (infsup (-8.765250686386196755e-01, -1.992187500000000000e-01) .* infsup (-1.000000000000000000e+00, 1.466715900391711624e+00), infsup (-1.285613255264199895e+00, 8.765250686386196755e-01))); %! assert (isequal (times (infsup (-8.765250686386196755e-01, -1.992187500000000000e-01), infsup (-1.000000000000000000e+00, 1.466715900391711624e+00)), infsup (-1.285613255264199895e+00, 8.765250686386196755e-01))); %!test %! assert (isequal (infsup (-2.870801872541201760e+01, -1.992187500000000000e-01) .* infsup (-1.393992103870862920e+00, 1.000000000000000000e+00), infsup (-2.870801872541201760e+01, 4.001875142100123384e+01))); %! assert (isequal (times (infsup (-2.870801872541201760e+01, -1.992187500000000000e-01), infsup (-1.393992103870862920e+00, 1.000000000000000000e+00)), infsup (-2.870801872541201760e+01, 4.001875142100123384e+01))); %!test %! assert (isequal (infsup (-2.870801872541201760e+01, -1.992187500000000000e-01) .* infsup (-1.393992103870862920e+00, 3.071280064782253660e+01), infsup (-8.817036561075358350e+02, 4.001875142100123384e+01))); %! assert (isequal (times (infsup (-2.870801872541201760e+01, -1.992187500000000000e-01), infsup (-1.393992103870862920e+00, 3.071280064782253660e+01)), infsup (-8.817036561075358350e+02, 4.001875142100123384e+01))); %!test %! assert (isequal (infsup (-7.818749353000000000e+10, -1.000000000000000000e+00) .* infsup (1.000000000000000000e+00, 1.600000000000000000e+01), infsup (-1.250999896480000000e+12, -1.000000000000000000e+00))); %! assert (isequal (times (infsup (-7.818749353000000000e+10, -1.000000000000000000e+00), infsup (1.000000000000000000e+00, 1.600000000000000000e+01)), infsup (-1.250999896480000000e+12, -1.000000000000000000e+00))); %!test %! assert (isequal (infsup (-7.139662043699290805e-01, -5.000000000000000000e-01) .* infsup (2.000000000000000000e+00, 2.046605023486218755e+00), infsup (-1.461206820462885192e+00, -1.000000000000000000e+00))); %! assert (isequal (times (infsup (-7.139662043699290805e-01, -5.000000000000000000e-01), infsup (2.000000000000000000e+00, 2.046605023486218755e+00)), infsup (-1.461206820462885192e+00, -1.000000000000000000e+00))); %!test %! assert (isequal (infsup (-4.000000000000000000e+00, -4.018386156188277769e-02) .* infsup (7.388390272892536581e-01, 4.000000000000000000e+00), infsup (-1.600000000000000000e+01, -2.968940518910749907e-02))); %! assert (isequal (times (infsup (-4.000000000000000000e+00, -4.018386156188277769e-02), infsup (7.388390272892536581e-01, 4.000000000000000000e+00)), infsup (-1.600000000000000000e+01, -2.968940518910749907e-02))); %!test %! assert (isequal (infsup (-7.139662043699290805e-01, -4.018386156188277769e-02) .* infsup (7.388390272892536581e-01, 2.046605023486218755e+00), infsup (-1.461206820462885192e+00, -2.968940518910749907e-02))); %! assert (isequal (times (infsup (-7.139662043699290805e-01, -4.018386156188277769e-02), infsup (7.388390272892536581e-01, 2.046605023486218755e+00)), infsup (-1.461206820462885192e+00, -2.968940518910749907e-02))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, 1.700000000000000000e+01) .* infsup (-7.000000000000000000e+00, -4.000000000000000000e+00), infsup (-1.190000000000000000e+02, 7.000000000000000000e+00))); %! assert (isequal (times (infsup (-1.000000000000000000e+00, 1.700000000000000000e+01), infsup (-7.000000000000000000e+00, -4.000000000000000000e+00)), infsup (-1.190000000000000000e+02, 7.000000000000000000e+00))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, 9.244364494737422611e-01) .* infsup (-2.231538914439750165e+00, -6.250000000000000000e-02), infsup (-2.062915910927172192e+00, 2.231538914439750165e+00))); %! assert (isequal (times (infsup (-1.000000000000000000e+00, 9.244364494737422611e-01), infsup (-2.231538914439750165e+00, -6.250000000000000000e-02)), infsup (-2.062915910927172192e+00, 2.231538914439750165e+00))); %!test %! assert (isequal (infsup (-2.850258554165375813e+02, 1.000000000000000000e+00) .* infsup (-2.231538914439750165e+00, -6.250000000000000000e-02), infsup (-2.231538914439750165e+00, 6.360462879834815340e+02))); %! assert (isequal (times (infsup (-2.850258554165375813e+02, 1.000000000000000000e+00), infsup (-2.231538914439750165e+00, -6.250000000000000000e-02)), infsup (-2.231538914439750165e+00, 6.360462879834815340e+02))); %!test %! assert (isequal (infsup (-9.244364494737422611e-01, 2.850258554165375813e+02) .* infsup (-2.231538914439750165e+00, -6.250000000000000000e-02), infsup (-6.360462879834815340e+02, 2.062915910927172192e+00))); %! assert (isequal (times (infsup (-9.244364494737422611e-01, 2.850258554165375813e+02), infsup (-2.231538914439750165e+00, -6.250000000000000000e-02)), infsup (-6.360462879834815340e+02, 2.062915910927172192e+00))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, 1.600000000000000000e+01) .* infsup (-2.000000000000000000e+00, 3.000000000000000000e+00), infsup (-3.200000000000000000e+01, 4.800000000000000000e+01))); %! assert (isequal (times (infsup (-1.000000000000000000e+00, 1.600000000000000000e+01), infsup (-2.000000000000000000e+00, 3.000000000000000000e+00)), infsup (-3.200000000000000000e+01, 4.800000000000000000e+01))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, 1.784754876621973685e-01) .* infsup (-1.513663759394287545e-01, 3.906250000000000000e-03), infsup (-2.701518776144904571e-02, 1.513663759394287545e-01))); %! assert (isequal (times (infsup (-1.000000000000000000e+00, 1.784754876621973685e-01), infsup (-1.513663759394287545e-01, 3.906250000000000000e-03)), infsup (-2.701518776144904571e-02, 1.513663759394287545e-01))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, 4.301929436060967227e-01) .* infsup (-6.250000000000000000e-02, 1.555662705168874727e+00), infsup (-1.555662705168874727e+00, 6.692351183948216375e-01))); %! assert (isequal (times (infsup (-1.000000000000000000e+00, 4.301929436060967227e-01), infsup (-6.250000000000000000e-02, 1.555662705168874727e+00)), infsup (-1.555662705168874727e+00, 6.692351183948216375e-01))); %!test %! assert (isequal (infsup (-1.085456484137515831e+00, 3.906250000000000000e-03) .* infsup (-2.468696855614667118e+00, 5.137992619868292365e-01), infsup (-5.577067404686740781e-01, 2.679663009296837206e+00))); %! assert (isequal (times (infsup (-1.085456484137515831e+00, 3.906250000000000000e-03), infsup (-2.468696855614667118e+00, 5.137992619868292365e-01)), infsup (-5.577067404686740781e-01, 2.679663009296837206e+00))); %!test %! assert (isequal (infsup (-7.000000000000000000e+00, 7.000000000000000000e+00) .* infsup (1.900000000000000000e+01, 3.600000000000000000e+01), infsup (-2.520000000000000000e+02, 2.520000000000000000e+02))); %! assert (isequal (times (infsup (-7.000000000000000000e+00, 7.000000000000000000e+00), infsup (1.900000000000000000e+01, 3.600000000000000000e+01)), infsup (-2.520000000000000000e+02, 2.520000000000000000e+02))); %!test %! assert (isequal (infsup (-6.563586907006095927e-01, 1.600000000000000000e+01) .* infsup (2.000000000000000000e+00, 2.201187625175617946e+00), infsup (-1.444768627646652925e+00, 3.521900200280988713e+01))); %! assert (isequal (times (infsup (-6.563586907006095927e-01, 1.600000000000000000e+01), infsup (2.000000000000000000e+00, 2.201187625175617946e+00)), infsup (-1.444768627646652925e+00, 3.521900200280988713e+01))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, 1.565098315200050605e+00) .* infsup (1.110223024625156540e-16, 1.266329204122035978e+00), infsup (-1.266329204122035978e+00, 1.981929703860019654e+00))); %! assert (isequal (times (infsup (-1.000000000000000000e+00, 1.565098315200050605e+00), infsup (1.110223024625156540e-16, 1.266329204122035978e+00)), infsup (-1.266329204122035978e+00, 1.981929703860019654e+00))); %!test %! assert (isequal (infsup (-1.765834301520441407e+00, 1.557480558189380915e+00) .* infsup (2.000000000000000000e+00, 3.269798648808647012e+00), infsup (-5.773922613131500903e+00, 5.092647824713375293e+00))); %! assert (isequal (times (infsup (-1.765834301520441407e+00, 1.557480558189380915e+00), infsup (2.000000000000000000e+00, 3.269798648808647012e+00)), infsup (-5.773922613131500903e+00, 5.092647824713375293e+00))); %!test %! assert (isequal (infsup (1.200000000000000000e+01, 4.500000000000000000e+01) .* infsup (-1.657000000000000000e+03, -2.290000000000000000e+02), infsup (-7.456500000000000000e+04, -2.748000000000000000e+03))); %! assert (isequal (times (infsup (1.200000000000000000e+01, 4.500000000000000000e+01), infsup (-1.657000000000000000e+03, -2.290000000000000000e+02)), infsup (-7.456500000000000000e+04, -2.748000000000000000e+03))); %!test %! assert (isequal (infsup (1.200000000000000000e+01, 1.120812365223437610e+03) .* infsup (-2.525625077842174805e+12, -2.290000000000000000e+02), infsup (-2.830751817163917000e+15, -2.748000000000000000e+03))); %! assert (isequal (times (infsup (1.200000000000000000e+01, 1.120812365223437610e+03), infsup (-2.525625077842174805e+12, -2.290000000000000000e+02)), infsup (-2.830751817163917000e+15, -2.748000000000000000e+03))); %!test %! assert (isequal (infsup (1.122244233241161915e+01, 4.500000000000000000e+01) .* infsup (-1.657000000000000000e+03, -1.027908085677155725e+01), infsup (-7.456500000000000000e+04, -1.153563921453150130e+02))); %! assert (isequal (times (infsup (1.122244233241161915e+01, 4.500000000000000000e+01), infsup (-1.657000000000000000e+03, -1.027908085677155725e+01)), infsup (-7.456500000000000000e+04, -1.153563921453150130e+02))); %!test %! assert (isequal (infsup (9.395050761055534494e-01, 1.073814051130034741e+01) .* infsup (-5.795963639761951391e+00, -9.930631723906067562e-03), infsup (-6.223787196215162965e+01, -9.329878913544592187e-03))); %! assert (isequal (times (infsup (9.395050761055534494e-01, 1.073814051130034741e+01), infsup (-5.795963639761951391e+00, -9.930631723906067562e-03)), infsup (-6.223787196215162965e+01, -9.329878913544592187e-03))); %!test %! assert (isequal (infsup (1.000000000000000000e+00, 1.200000000000000000e+01) .* infsup (-2.290000000000000000e+02, 1.000000000000000000e+00), infsup (-2.748000000000000000e+03, 1.200000000000000000e+01))); %! assert (isequal (times (infsup (1.000000000000000000e+00, 1.200000000000000000e+01), infsup (-2.290000000000000000e+02, 1.000000000000000000e+00)), infsup (-2.748000000000000000e+03, 1.200000000000000000e+01))); %!test %! assert (isequal (infsup (6.461498003318411065e-14, 1.922432961588749656e+00) .* infsup (-6.663688717732502154e-01, 4.294967296000000000e+09), infsup (-1.281049483673603273e+00, 8.256786698776103973e+09))); %! assert (isequal (times (infsup (6.461498003318411065e-14, 1.922432961588749656e+00), infsup (-6.663688717732502154e-01, 4.294967296000000000e+09)), infsup (-1.281049483673603273e+00, 8.256786698776103973e+09))); %!test %! assert (isequal (infsup (3.000000000000000000e+00, 7.171544261033011125e+00) .* infsup (-1.000000000000000000e+00, 6.663688717732502154e-01), infsup (-7.171544261033011125e+00, 4.778893858096495251e+00))); %! assert (isequal (times (infsup (3.000000000000000000e+00, 7.171544261033011125e+00), infsup (-1.000000000000000000e+00, 6.663688717732502154e-01)), infsup (-7.171544261033011125e+00, 4.778893858096495251e+00))); %!test %! assert (isequal (infsup (1.875000000000000000e-01, 6.663688717732502154e-01) .* infsup (-1.922432961588749656e+00, 7.171544261033011125e+00), infsup (-1.281049483673603273e+00, 4.778893858096495251e+00))); %! assert (isequal (times (infsup (1.875000000000000000e-01, 6.663688717732502154e-01), infsup (-1.922432961588749656e+00, 7.171544261033011125e+00)), infsup (-1.281049483673603273e+00, 4.778893858096495251e+00))); %!test %! assert (isequal (infsup (3.000000000000000000e+00, 7.000000000000000000e+00) .* infsup (5.000000000000000000e+00, 1.100000000000000000e+01), infsup (1.500000000000000000e+01, 7.700000000000000000e+01))); %! assert (isequal (times (infsup (3.000000000000000000e+00, 7.000000000000000000e+00), infsup (5.000000000000000000e+00, 1.100000000000000000e+01)), infsup (1.500000000000000000e+01, 7.700000000000000000e+01))); %!test %! assert (isequal (infsup (2.282104623262744436e+00, 7.000000000000000000e+00) .* infsup (3.444510241015958041e+00, 1.100000000000000000e+01), infsup (7.860732745898387108e+00, 7.700000000000000000e+01))); %! assert (isequal (times (infsup (2.282104623262744436e+00, 7.000000000000000000e+00), infsup (3.444510241015958041e+00, 1.100000000000000000e+01)), infsup (7.860732745898387108e+00, 7.700000000000000000e+01))); %!test %! assert (isequal (infsup (3.000000000000000000e+00, 3.444510241015958041e+00) .* infsup (1.490116119384765625e-07, 2.282104623262744436e+00), infsup (4.470348358154296875e-07, 7.860732745898387996e+00))); %! assert (isequal (times (infsup (3.000000000000000000e+00, 3.444510241015958041e+00), infsup (1.490116119384765625e-07, 2.282104623262744436e+00)), infsup (4.470348358154296875e-07, 7.860732745898387996e+00))); %!test %! assert (isequal (infsup (1.916281209173078537e-01, 2.282104623262744436e+00) .* infsup (7.650281798863103333e-01, 2.619105358145846552e+00), infsup (1.466009125604018082e-01, 5.977072446636863212e+00))); %! assert (isequal (times (infsup (1.916281209173078537e-01, 2.282104623262744436e+00), infsup (7.650281798863103333e-01, 2.619105358145846552e+00)), infsup (1.466009125604018082e-01, 5.977072446636863212e+00))); ## mpfi_mul_d %!# special values %!test %! assert (isequal (infsup (-inf, -7.0) .* infsup (-2.300000000000000000e+01, -2.300000000000000000e+01), infsup (1.610000000000000000e+02, inf))); %! assert (isequal (times (infsup (-inf, -7.0), infsup (-2.300000000000000000e+01, -2.300000000000000000e+01)), infsup (1.610000000000000000e+02, inf))); %!test %! assert (isequal (infsup (-inf, -7.0) .* infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-inf, -7.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-inf, -7.0) .* infsup (4.000000000000000286e-17, 4.000000000000000286e-17), infsup (-inf, -2.800000000000000139e-16))); %! assert (isequal (times (infsup (-inf, -7.0), infsup (4.000000000000000286e-17, 4.000000000000000286e-17)), infsup (-inf, -2.800000000000000139e-16))); %!test %! assert (isequal (infsup (-inf, 0.0) .* infsup (-8.000000000000000572e-17, -8.000000000000000572e-17), infsup (0.0, inf))); %! assert (isequal (times (infsup (-inf, 0.0), infsup (-8.000000000000000572e-17, -8.000000000000000572e-17)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-inf, 0.0) .* infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-inf, 0.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-inf, 0.0) .* infsup (8.000000000000000572e-17, 8.000000000000000572e-17), infsup (-inf, 0.0))); %! assert (isequal (times (infsup (-inf, 0.0), infsup (8.000000000000000572e-17, 8.000000000000000572e-17)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-inf, 8.0) .* infsup (-1.600000000000000000e+18, -1.600000000000000000e+18), infsup (-1.280000000000000000e+19, inf))); %! assert (isequal (times (infsup (-inf, 8.0), infsup (-1.600000000000000000e+18, -1.600000000000000000e+18)), infsup (-1.280000000000000000e+19, inf))); %!test %! assert (isequal (infsup (-inf, 8.0) .* infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-inf, 8.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-inf, 8.0) .* infsup (1.600000000000000000e+18, 1.600000000000000000e+18), infsup (-inf, 1.280000000000000000e+19))); %! assert (isequal (times (infsup (-inf, 8.0), infsup (1.600000000000000000e+18, 1.600000000000000000e+18)), infsup (-inf, 1.280000000000000000e+19))); %!test %! assert (isequal (infsup (-inf, inf) .* infsup (-1.600000000000000114e-16, -1.600000000000000114e-16), infsup (-inf, inf))); %! assert (isequal (times (infsup (-inf, inf), infsup (-1.600000000000000114e-16, -1.600000000000000114e-16)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) .* infsup (0.0e-17, 0.0e-17), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-inf, inf), infsup (0.0e-17, 0.0e-17)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-inf, inf) .* infsup (1.600000000000000114e-16, 1.600000000000000114e-16), infsup (-inf, inf))); %! assert (isequal (times (infsup (-inf, inf), infsup (1.600000000000000114e-16, 1.600000000000000114e-16)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, 0.0) .* infsup (-1.000000000000000072e-17, -1.000000000000000072e-17), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (0.0, 0.0), infsup (-1.000000000000000072e-17, -1.000000000000000072e-17)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) .* infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (0.0, 0.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) .* infsup (1.000000000000000072e-17, 1.000000000000000072e-17), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (0.0, 0.0), infsup (1.000000000000000072e-17, 1.000000000000000072e-17)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 7.0) .* infsup (-3.000000000000000061e-17, -3.000000000000000061e-17), infsup (-2.100000000000000104e-16, 0.0))); %! assert (isequal (times (infsup (0.0, 7.0), infsup (-3.000000000000000061e-17, -3.000000000000000061e-17)), infsup (-2.100000000000000104e-16, 0.0))); %!test %! assert (isequal (infsup (0.0, 8.0) .* infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (0.0, 8.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 9.0) .* infsup (4.800000000000000097e-16, 4.800000000000000097e-16), infsup (0.0, 4.320000000000000777e-15))); %! assert (isequal (times (infsup (0.0, 9.0), infsup (4.800000000000000097e-16, 4.800000000000000097e-16)), infsup (0.0, 4.320000000000000777e-15))); %!test %! assert (isequal (infsup (0.0, inf) .* infsup (-7.000000000000000347e-17, -7.000000000000000347e-17), infsup (-inf, 0.0))); %! assert (isequal (times (infsup (0.0, inf), infsup (-7.000000000000000347e-17, -7.000000000000000347e-17)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (0.0, inf) .* infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (0.0, inf), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, inf) .* infsup (6.999999999999999114e-17, 6.999999999999999114e-17), infsup (0.0, inf))); %! assert (isequal (times (infsup (0.0, inf), infsup (6.999999999999999114e-17, 6.999999999999999114e-17)), infsup (0.0, inf))); %!# regular values %!test %! assert (isequal (infsup (-2.421182400000000000e+07, -2.823443157514333837e-22) .* infsup (-1.5, -1.5), infsup (4.235164736271500755e-22, 3.631773600000000000e+07))); %! assert (isequal (times (infsup (-2.421182400000000000e+07, -2.823443157514333837e-22), infsup (-1.5, -1.5)), infsup (4.235164736271500755e-22, 3.631773600000000000e+07))); %!test %! assert (isequal (infsup (-3.002399751580330000e+15, 1.250419591445233750e+128) .* infsup (-1.5, -1.5), infsup (-1.875629387167850624e+128, 4.503599627370495000e+15))); %! assert (isequal (times (infsup (-3.002399751580330000e+15, 1.250419591445233750e+128), infsup (-1.5, -1.5)), infsup (-1.875629387167850624e+128, 4.503599627370495000e+15))); %!test %! assert (isequal (infsup (4.503599627370512000e+15, 1.122162325663649028e+211) .* infsup (-2.125, -2.125), infsup (-2.384594942035254185e+211, -9.570149208162338000e+15))); %! assert (isequal (times (infsup (4.503599627370512000e+15, 1.122162325663649028e+211), infsup (-2.125, -2.125)), infsup (-2.384594942035254185e+211, -9.570149208162338000e+15))); %!test %! assert (isequal (infsup (-2.421182400000000000e+07, -2.823443157514333837e-22) .* infsup (1.5, 1.5), infsup (-3.631773600000000000e+07, -4.235164736271500755e-22))); %! assert (isequal (times (infsup (-2.421182400000000000e+07, -2.823443157514333837e-22), infsup (1.5, 1.5)), infsup (-3.631773600000000000e+07, -4.235164736271500755e-22))); %!test %! assert (isequal (infsup (-3.002399751580330000e+15, 1.250419591445233750e+128) .* infsup (1.5, 1.5), infsup (-4.503599627370495000e+15, 1.875629387167850624e+128))); %! assert (isequal (times (infsup (-3.002399751580330000e+15, 1.250419591445233750e+128), infsup (1.5, 1.5)), infsup (-4.503599627370495000e+15, 1.875629387167850624e+128))); %!test %! assert (isequal (infsup (4.503599627370512000e+15, 1.122162325663649028e+211) .* infsup (2.125, 2.125), infsup (9.570149208162338000e+15, 2.384594942035254185e+211))); %! assert (isequal (times (infsup (4.503599627370512000e+15, 1.122162325663649028e+211), infsup (2.125, 2.125)), infsup (9.570149208162338000e+15, 2.384594942035254185e+211))); %!test %! assert (isequal (infsup (-1.663823876104126464e+18, -4.503599627370497000e+15) .* infsup (-1.5, -1.5), infsup (6.755399441055745000e+15, 2.495735814156189696e+18))); %! assert (isequal (times (infsup (-1.663823876104126464e+18, -4.503599627370497000e+15), infsup (-1.5, -1.5)), infsup (6.755399441055745000e+15, 2.495735814156189696e+18))); %!test %! assert (isequal (infsup (-3.002399751580330000e+15, 4.503599627370497000e+15) .* infsup (-1.5, -1.5), infsup (-6.755399441055746000e+15, 4.503599627370495000e+15))); %! assert (isequal (times (infsup (-3.002399751580330000e+15, 4.503599627370497000e+15), infsup (-1.5, -1.5)), infsup (-6.755399441055746000e+15, 4.503599627370495000e+15))); %!test %! assert (isequal (infsup (4.503599627370512000e+15, 4.803839602528529000e+15) .* infsup (-2.125, -2.125), infsup (-1.020815915537312600e+16, -9.570149208162338000e+15))); %! assert (isequal (times (infsup (4.503599627370512000e+15, 4.803839602528529000e+15), infsup (-2.125, -2.125)), infsup (-1.020815915537312600e+16, -9.570149208162338000e+15))); %!test %! assert (isequal (infsup (-4.503599627370497000e+15, -2.823443157514333837e-22) .* infsup (1.5, 1.5), infsup (-6.755399441055746000e+15, -4.235164736271500755e-22))); %! assert (isequal (times (infsup (-4.503599627370497000e+15, -2.823443157514333837e-22), infsup (1.5, 1.5)), infsup (-6.755399441055746000e+15, -4.235164736271500755e-22))); %!test %! assert (isequal (infsup (-3.002399751580331000e+15, 1.250419591445233750e+128) .* infsup (1.5, 1.5), infsup (-4.503599627370497000e+15, 1.875629387167850624e+128))); %! assert (isequal (times (infsup (-3.002399751580331000e+15, 1.250419591445233750e+128), infsup (1.5, 1.5)), infsup (-4.503599627370497000e+15, 1.875629387167850624e+128))); %!test %! assert (isequal (infsup (4.503599627370497000e+15, 1.122162325663649028e+211) .* infsup (2.125, 2.125), infsup (9.570149208162306000e+15, 2.384594942035254185e+211))); %! assert (isequal (times (infsup (4.503599627370497000e+15, 1.122162325663649028e+211), infsup (2.125, 2.125)), infsup (9.570149208162306000e+15, 2.384594942035254185e+211))); %!test %! assert (isequal (infsup (-4.909806652584305000e+15, -2.823443157514333837e-22) .* infsup (-1.5, -1.5), infsup (4.235164736271500755e-22, 7.364709978876458000e+15))); %! assert (isequal (times (infsup (-4.909806652584305000e+15, -2.823443157514333837e-22), infsup (-1.5, -1.5)), infsup (4.235164736271500755e-22, 7.364709978876458000e+15))); %!test %! assert (isequal (infsup (-4.503599627370497000e+15, 1.250419591445233750e+128) .* infsup (-1.5, -1.5), infsup (-1.875629387167850624e+128, 6.755399441055746000e+15))); %! assert (isequal (times (infsup (-4.503599627370497000e+15, 1.250419591445233750e+128), infsup (-1.5, -1.5)), infsup (-1.875629387167850624e+128, 6.755399441055746000e+15))); %!test %! assert (isequal (infsup (4.503599627370497000e+15, 1.122162325663649028e+211) .* infsup (-2.125, -2.125), infsup (-2.384594942035254185e+211, -9.570149208162306000e+15))); %! assert (isequal (times (infsup (4.503599627370497000e+15, 1.122162325663649028e+211), infsup (-2.125, -2.125)), infsup (-2.384594942035254185e+211, -9.570149208162306000e+15))); %!test %! assert (isequal (infsup (-2.421182400000000000e+07, -7.058607893785835532e-22) .* infsup (1.5, 1.5), infsup (-3.631773600000000000e+07, -1.058791184067875236e-21))); %! assert (isequal (times (infsup (-2.421182400000000000e+07, -7.058607893785835532e-22), infsup (1.5, 1.5)), infsup (-3.631773600000000000e+07, -1.058791184067875236e-21))); %!test %! assert (isequal (infsup (-3.002399751580330000e+15, 4.909806652584305000e+15) .* infsup (1.5, 1.5), infsup (-4.503599627370495000e+15, 7.364709978876458000e+15))); %! assert (isequal (times (infsup (-3.002399751580330000e+15, 4.909806652584305000e+15), infsup (1.5, 1.5)), infsup (-4.503599627370495000e+15, 7.364709978876458000e+15))); %!test %! assert (isequal (infsup (4.503599627370512000e+15, 6.905519428634761000e+15) .* infsup (2.125, 2.125), infsup (9.570149208162338000e+15, 1.467422878584886800e+16))); %! assert (isequal (times (infsup (4.503599627370512000e+15, 6.905519428634761000e+15), infsup (2.125, 2.125)), infsup (9.570149208162338000e+15, 1.467422878584886800e+16))); %!test %! assert (isequal (infsup (-4.909806652584305000e+15, -4.503599627370497000e+15) .* infsup (-1.5, -1.5), infsup (6.755399441055745000e+15, 7.364709978876458000e+15))); %! assert (isequal (times (infsup (-4.909806652584305000e+15, -4.503599627370497000e+15), infsup (-1.5, -1.5)), infsup (6.755399441055745000e+15, 7.364709978876458000e+15))); %!test %! assert (isequal (infsup (-4.503599627370497000e+15, 4.503599627370497000e+15) .* infsup (-1.5, -1.5), infsup (-6.755399441055746000e+15, 6.755399441055746000e+15))); %! assert (isequal (times (infsup (-4.503599627370497000e+15, 4.503599627370497000e+15), infsup (-1.5, -1.5)), infsup (-6.755399441055746000e+15, 6.755399441055746000e+15))); %!test %! assert (isequal (infsup (4.503599627370497000e+15, 4.803839602528529000e+15) .* infsup (-2.125, -2.125), infsup (-1.020815915537312600e+16, -9.570149208162306000e+15))); %! assert (isequal (times (infsup (4.503599627370497000e+15, 4.803839602528529000e+15), infsup (-2.125, -2.125)), infsup (-1.020815915537312600e+16, -9.570149208162306000e+15))); %!test %! assert (isequal (infsup (-4.503599627370497000e+15, -7.058607893785835532e-22) .* infsup (1.5, 1.5), infsup (-6.755399441055746000e+15, -1.058791184067875236e-21))); %! assert (isequal (times (infsup (-4.503599627370497000e+15, -7.058607893785835532e-22), infsup (1.5, 1.5)), infsup (-6.755399441055746000e+15, -1.058791184067875236e-21))); %!test %! assert (isequal (infsup (-3.002399751580331000e+15, 4.909806652584305000e+15) .* infsup (1.5, 1.5), infsup (-4.503599627370497000e+15, 7.364709978876458000e+15))); %! assert (isequal (times (infsup (-3.002399751580331000e+15, 4.909806652584305000e+15), infsup (1.5, 1.5)), infsup (-4.503599627370497000e+15, 7.364709978876458000e+15))); %!test %! assert (isequal (infsup (4.503599627370497000e+15, 6.905519428634761000e+15) .* infsup (2.125, 2.125), infsup (9.570149208162306000e+15, 1.467422878584886800e+16))); %! assert (isequal (times (infsup (4.503599627370497000e+15, 6.905519428634761000e+15), infsup (2.125, 2.125)), infsup (9.570149208162306000e+15, 1.467422878584886800e+16))); ## mpfi_neg %!# special values %!test %! assert (isequal (-infsup (-inf, -7.0), infsup (+7.0, inf))); %! assert (isequal (uminus (infsup (-inf, -7.0)), infsup (+7.0, inf))); %!test %! assert (isequal (-infsup (-inf, 0.0), infsup (0.0, inf))); %! assert (isequal (uminus (infsup (-inf, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (-infsup (-inf, +8.0), infsup (-8.0, inf))); %! assert (isequal (uminus (infsup (-inf, +8.0)), infsup (-8.0, inf))); %!test %! assert (isequal (-infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (uminus (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (-infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (uminus (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (-infsup (0.0, +8.0), infsup (-8.0, 0.0))); %! assert (isequal (uminus (infsup (0.0, +8.0)), infsup (-8.0, 0.0))); %!test %! assert (isequal (-infsup (0.0, inf), infsup (-inf, 0.0))); %! assert (isequal (uminus (infsup (0.0, inf)), infsup (-inf, 0.0))); %!# regular values %!test %! assert (isequal (-infsup (7.456540443420410156e+04, 7.456540467834472656e+04), infsup (-7.456540467834472656e+04, -7.456540443420410156e+04))); %! assert (isequal (uminus (infsup (7.456540443420410156e+04, 7.456540467834472656e+04)), infsup (-7.456540467834472656e+04, -7.456540443420410156e+04))); ## mpfi_put_d %!# special values %!test %! assert (isequal (union (infsup (0.0, 0.0), infsup (-8.0, -8.0)), infsup (-8.0, 0.0))); %!test %! assert (isequal (union (infsup (0.0, 0.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (union (infsup (+5.0, +5.0), infsup (0.0, 0.0)), infsup (0.0, +5.0))); ## mpfi_sec %!# special values %!test %! assert (isequal (sec (infsup (-inf, -7.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-inf, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-inf, 8.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-8.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-3.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-1.0, 0.0)), infsup (1.0, 1.850815717680925676e+00))); %!test %! assert (isequal (sec (infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (sec (infsup (0.0, +1.0)), infsup (1.0, 1.850815717680925676e+00))); %!test %! assert (isequal (sec (infsup (0.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (0.0, 8.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (0.0, inf)), infsup (-inf, inf))); %!# regular values %!test %! assert (isequal (sec (infsup (-6.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-6.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-6.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-6.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-6.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-6.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-6.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-6.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-6.0, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-6.0, -2.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-6.0, -3.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-6.0, -4.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-6.0, -5.0)), infsup (1.041481926595107632e+00, 3.525320085816088689e+00))); %!test %! assert (isequal (sec (infsup (-6.0, -6.0)), infsup (1.041481926595107632e+00, 1.041481926595107854e+00))); %!test %! assert (isequal (sec (infsup (-5.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-5.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-5.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-5.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-5.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-5.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-5.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-5.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-5.0, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-5.0, -2.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-5.0, -3.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-5.0, -4.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-5.0, -5.0)), infsup (3.525320085816088245e+00, 3.525320085816088689e+00))); %!test %! assert (isequal (sec (infsup (-4.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-4.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-4.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-4.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-4.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-4.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-4.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-4.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-4.0, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-4.0, -2.0)), infsup (-2.402997961722381337e+00, -1.0))); %!test %! assert (isequal (sec (infsup (-4.0, -3.0)), infsup (-1.529885656466397625e+00, -1.0))); %!test %! assert (isequal (sec (infsup (-4.0, -4.0)), infsup (-1.529885656466397625e+00, -1.529885656466397403e+00))); %!test %! assert (isequal (sec (infsup (-3.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-3.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-3.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-3.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-3.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-3.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-3.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-3.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-3.0, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-3.0, -2.0)), infsup (-2.402997961722381337e+00, -1.010108665907993641e+00))); %!test %! assert (isequal (sec (infsup (-3.0, -3.0)), infsup (-1.010108665907993863e+00, -1.010108665907993641e+00))); %!test %! assert (isequal (sec (infsup (-2.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-2.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-2.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-2.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-2.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-2.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-2.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-2.0, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-2.0, -2.0)), infsup (-2.402997961722381337e+00, -2.402997961722380893e+00))); %!test %! assert (isequal (sec (infsup (-1.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-1.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-1.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-1.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-1.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-1.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (-1.0, 1.0)), infsup (1.0, 1.850815717680925676e+00))); %!test %! assert (isequal (sec (infsup (-1.0, 0.0)), infsup (1.0, 1.850815717680925676e+00))); %!test %! assert (isequal (sec (infsup (-1.0, -1.0)), infsup (1.850815717680925454e+00, 1.850815717680925676e+00))); %!test %! assert (isequal (sec (infsup (1.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (1.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (1.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (1.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (1.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (1.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (1.0, 1.0)), infsup (1.850815717680925454e+00, 1.850815717680925676e+00))); %!test %! assert (isequal (sec (infsup (2.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (2.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (2.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (2.0, 4.0)), infsup (-2.402997961722381337e+00, -1.0))); %!test %! assert (isequal (sec (infsup (2.0, 3.0)), infsup (-2.402997961722381337e+00, -1.010108665907993641e+00))); %!test %! assert (isequal (sec (infsup (2.0, 2.0)), infsup (-2.402997961722381337e+00, -2.402997961722380893e+00))); %!test %! assert (isequal (sec (infsup (3.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (3.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (3.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (3.0, 4.0)), infsup (-1.529885656466397625e+00, -1.0))); %!test %! assert (isequal (sec (infsup (3.0, 3.0)), infsup (-1.010108665907993863e+00, -1.010108665907993641e+00))); %!test %! assert (isequal (sec (infsup (4.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (4.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (4.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (sec (infsup (4.0, 4.0)), infsup (-1.529885656466397625e+00, -1.529885656466397403e+00))); %!test %! assert (isequal (sec (infsup (5.0, 7.0)), infsup (1.0, 3.525320085816088689e+00))); %!test %! assert (isequal (sec (infsup (5.0, 6.0)), infsup (1.041481926595107632e+00, 3.525320085816088689e+00))); %!test %! assert (isequal (sec (infsup (5.0, 5.0)), infsup (3.525320085816088245e+00, 3.525320085816088689e+00))); %!test %! assert (isequal (sec (infsup (6.0, 7.0)), infsup (1.0, 1.326431900473705072e+00))); %!test %! assert (isequal (sec (infsup (6.0, 6.0)), infsup (1.041481926595107632e+00, 1.041481926595107854e+00))); %!test %! assert (isequal (sec (infsup (7.0, 7.0)), infsup (1.326431900473704850e+00, 1.326431900473705072e+00))); ## mpfi_sech %!# special values %!test %! assert (isequal (sech (infsup (-inf, -7.0)), infsup (0.0, 1.823762414598208018e-03))); %!test %! assert (isequal (sech (infsup (-inf, 0.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (sech (infsup (-inf, +8.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (sech (infsup (-inf, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (sech (infsup (-1.0, 0.0)), infsup (6.480542736638853496e-01, 1.0))); %!test %! assert (isequal (sech (infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (sech (infsup (0.0, +1.0)), infsup (6.480542736638853496e-01, 1.0))); %!test %! assert (isequal (sech (infsup (0.0, +8.0)), infsup (6.709251803023412583e-04, 1.0))); %!test %! assert (isequal (sech (infsup (0.0, inf)), infsup (0.0, 1.0))); %!# regular values %!test %! assert (isequal (sech (infsup (-0.125, 0.0)), infsup (9.922380414751257316e-01, 1.0))); %!test %! assert (isequal (sech (infsup (0.0, 5.000000000000001110e-01)), infsup (8.868188839700738013e-01, 1.0))); %!test %! assert (isequal (sech (infsup (-4.5, -0.625)), infsup (2.221525149664967461e-02, 8.321172681599560139e-01))); %!test %! assert (isequal (sech (infsup (1.0, 3.0)), infsup (9.932792741943320680e-02, 6.480542736638854606e-01))); %!test %! assert (isequal (sech (infsup (17.0, 7.090895657128239691e+02)), infsup (2.225073858507384681e-308, 8.279875437570320428e-08))); ## mpfi_sin %!# special values %!test %! assert (isequal (sin (infsup (-inf, -7.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-inf, 0.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-inf, +8.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-inf, inf)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-1.0, 0.0)), infsup (-8.414709848078966159e-01, 0.0))); %!test %! assert (isequal (sin (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (sin (infsup (0.0, +1.0)), infsup (0.0, 8.414709848078966159e-01))); %!test %! assert (isequal (sin (infsup (0.0, +8.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (0.0, inf)), infsup (-1.0, 1.0))); %!# regular values %!test %! assert (isequal (sin (infsup (0.125, 17.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (1.570796326794896558e+00, 1.570796326794896780e+00)), infsup (9.999999999999998890e-01, 1.0))); %!test %! assert (isequal (sin (infsup (-2.0, -0.5)), infsup (-1.0, -4.794255386042029499e-01))); %!test %! assert (isequal (sin (infsup (-4.5, 0.625)), infsup (-1.0, 9.775301176650971202e-01))); %!test %! assert (isequal (sin (infsup (-1.0, -0.25)), infsup (-8.414709848078966159e-01, -2.474039592545229094e-01))); %!test %! assert (isequal (sin (infsup (-0.5, 0.5)), infsup (-4.794255386042030054e-01, 4.794255386042030054e-01))); %!test %! assert (isequal (sin (infsup (8.538038601028318546e+24, 8.538038601028318546e+24)), infsup (2.177252852343107281e-01, 2.177252852343107559e-01))); %!test %! assert (isequal (sin (infsup (-7.0, 7.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-7.0, 6.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-7.0, 5.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-7.0, 4.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-7.0, 3.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-7.0, 2.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-7.0, 1.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-7.0, 0.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-7.0, -1.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-7.0, -2.0)), infsup (-9.092974268256817094e-01, 1.0))); %!test %! assert (isequal (sin (infsup (-7.0, -3.0)), infsup (-6.569865987187891720e-01, 1.0))); %!test %! assert (isequal (sin (infsup (-7.0, -4.0)), infsup (-6.569865987187891720e-01, 1.0))); %!test %! assert (isequal (sin (infsup (-7.0, -5.0)), infsup (-6.569865987187891720e-01, 9.589242746631385650e-01))); %!test %! assert (isequal (sin (infsup (-7.0, -6.0)), infsup (-6.569865987187891720e-01, 2.794154981989259157e-01))); %!test %! assert (isequal (sin (infsup (-7.0, -7.0)), infsup (-6.569865987187891720e-01, -6.569865987187890610e-01))); %!test %! assert (isequal (sin (infsup (-6.0, 7.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-6.0, 6.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-6.0, 5.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-6.0, 4.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-6.0, 3.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-6.0, 2.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-6.0, 1.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-6.0, 0.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-6.0, -1.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-6.0, -2.0)), infsup (-9.092974268256817094e-01, 1.0))); %!test %! assert (isequal (sin (infsup (-6.0, -3.0)), infsup (-1.411200080598672413e-01, 1.0))); %!test %! assert (isequal (sin (infsup (-6.0, -4.0)), infsup (2.794154981989258602e-01, 1.0))); %!test %! assert (isequal (sin (infsup (-6.0, -5.0)), infsup (2.794154981989258602e-01, 9.589242746631385650e-01))); %!test %! assert (isequal (sin (infsup (-6.0, -6.0)), infsup (2.794154981989258602e-01, 2.794154981989259157e-01))); %!test %! assert (isequal (sin (infsup (-5.0, 7.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-5.0, 6.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-5.0, 5.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-5.0, 4.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-5.0, 3.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-5.0, 2.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-5.0, 1.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-5.0, 0.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-5.0, -1.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-5.0, -2.0)), infsup (-9.092974268256817094e-01, 1.0))); %!test %! assert (isequal (sin (infsup (-5.0, -3.0)), infsup (-1.411200080598672413e-01, 1.0))); %!test %! assert (isequal (sin (infsup (-5.0, -4.0)), infsup (7.568024953079282025e-01, 1.0))); %!test %! assert (isequal (sin (infsup (-5.0, -5.0)), infsup (9.589242746631384540e-01, 9.589242746631385650e-01))); %!test %! assert (isequal (sin (infsup (-4.0, 7.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-4.0, 6.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-4.0, 5.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-4.0, 4.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-4.0, 3.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-4.0, 2.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-4.0, 1.0)), infsup (-1.0, 8.414709848078966159e-01))); %!test %! assert (isequal (sin (infsup (-4.0, 0.0)), infsup (-1.0, 7.568024953079283135e-01))); %!test %! assert (isequal (sin (infsup (-4.0, -1.0)), infsup (-1.0, 7.568024953079283135e-01))); %!test %! assert (isequal (sin (infsup (-4.0, -2.0)), infsup (-9.092974268256817094e-01, 7.568024953079283135e-01))); %!test %! assert (isequal (sin (infsup (-4.0, -3.0)), infsup (-1.411200080598672413e-01, 7.568024953079283135e-01))); %!test %! assert (isequal (sin (infsup (-4.0, -4.0)), infsup (7.568024953079282025e-01, 7.568024953079283135e-01))); %!test %! assert (isequal (sin (infsup (-3.0, 7.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-3.0, 6.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-3.0, 5.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-3.0, 4.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-3.0, 3.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-3.0, 2.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-3.0, 1.0)), infsup (-1.0, 8.414709848078966159e-01))); %!test %! assert (isequal (sin (infsup (-3.0, 0.0)), infsup (-1.0, 0.0))); %!test %! assert (isequal (sin (infsup (-3.0, -1.0)), infsup (-1.0, -1.411200080598672135e-01))); %!test %! assert (isequal (sin (infsup (-3.0, -2.0)), infsup (-9.092974268256817094e-01, -1.411200080598672135e-01))); %!test %! assert (isequal (sin (infsup (-3.0, -3.0)), infsup (-1.411200080598672413e-01, -1.411200080598672135e-01))); %!test %! assert (isequal (sin (infsup (-2.0, 7.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-2.0, 6.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-2.0, 5.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-2.0, 4.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-2.0, 3.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-2.0, 2.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-2.0, 1.0)), infsup (-1.0, 8.414709848078966159e-01))); %!test %! assert (isequal (sin (infsup (-2.0, 0.0)), infsup (-1.0, 0.0))); %!test %! assert (isequal (sin (infsup (-2.0, -1.0)), infsup (-1.0, -8.414709848078965049e-01))); %!test %! assert (isequal (sin (infsup (-2.0, -2.0)), infsup (-9.092974268256817094e-01, -9.092974268256815984e-01))); %!test %! assert (isequal (sin (infsup (-1.0, 7.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-1.0, 6.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-1.0, 5.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-1.0, 4.0)), infsup (-8.414709848078966159e-01, 1.0))); %!test %! assert (isequal (sin (infsup (-1.0, 3.0)), infsup (-8.414709848078966159e-01, 1.0))); %!test %! assert (isequal (sin (infsup (-1.0, 2.0)), infsup (-8.414709848078966159e-01, 1.0))); %!test %! assert (isequal (sin (infsup (-1.0, 1.0)), infsup (-8.414709848078966159e-01, 8.414709848078966159e-01))); %!test %! assert (isequal (sin (infsup (-1.0, 0.0)), infsup (-8.414709848078966159e-01, 0.0))); %!test %! assert (isequal (sin (infsup (-1.0, -1.0)), infsup (-8.414709848078966159e-01, -8.414709848078965049e-01))); %!test %! assert (isequal (sin (infsup (1.0, 7.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (1.0, 6.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (1.0, 5.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (1.0, 4.0)), infsup (-7.568024953079283135e-01, 1.0))); %!test %! assert (isequal (sin (infsup (1.0, 3.0)), infsup (1.411200080598672135e-01, 1.0))); %!test %! assert (isequal (sin (infsup (1.0, 2.0)), infsup (8.414709848078965049e-01, 1.0))); %!test %! assert (isequal (sin (infsup (1.0, 1.0)), infsup (8.414709848078965049e-01, 8.414709848078966159e-01))); %!test %! assert (isequal (sin (infsup (2.0, 7.0)), infsup (-1.0, 9.092974268256817094e-01))); %!test %! assert (isequal (sin (infsup (2.0, 6.0)), infsup (-1.0, 9.092974268256817094e-01))); %!test %! assert (isequal (sin (infsup (2.0, 5.0)), infsup (-1.0, 9.092974268256817094e-01))); %!test %! assert (isequal (sin (infsup (2.0, 4.0)), infsup (-7.568024953079283135e-01, 9.092974268256817094e-01))); %!test %! assert (isequal (sin (infsup (2.0, 3.0)), infsup (1.411200080598672135e-01, 9.092974268256817094e-01))); %!test %! assert (isequal (sin (infsup (2.0, 2.0)), infsup (9.092974268256815984e-01, 9.092974268256817094e-01))); %!test %! assert (isequal (sin (infsup (3.0, 7.0)), infsup (-1.0, 6.569865987187891720e-01))); %!test %! assert (isequal (sin (infsup (3.0, 6.0)), infsup (-1.0, 1.411200080598672413e-01))); %!test %! assert (isequal (sin (infsup (3.0, 5.0)), infsup (-1.0, 1.411200080598672413e-01))); %!test %! assert (isequal (sin (infsup (3.0, 4.0)), infsup (-7.568024953079283135e-01, 1.411200080598672413e-01))); %!test %! assert (isequal (sin (infsup (3.0, 3.0)), infsup (1.411200080598672135e-01, 1.411200080598672413e-01))); %!test %! assert (isequal (sin (infsup (4.0, 7.0)), infsup (-1.0, 6.569865987187891720e-01))); %!test %! assert (isequal (sin (infsup (4.0, 6.0)), infsup (-1.0, -2.794154981989258602e-01))); %!test %! assert (isequal (sin (infsup (4.0, 5.0)), infsup (-1.0, -7.568024953079282025e-01))); %!test %! assert (isequal (sin (infsup (4.0, 4.0)), infsup (-7.568024953079283135e-01, -7.568024953079282025e-01))); %!test %! assert (isequal (sin (infsup (5.0, 7.0)), infsup (-9.589242746631385650e-01, 6.569865987187891720e-01))); %!test %! assert (isequal (sin (infsup (5.0, 6.0)), infsup (-9.589242746631385650e-01, -2.794154981989258602e-01))); %!test %! assert (isequal (sin (infsup (5.0, 5.0)), infsup (-9.589242746631385650e-01, -9.589242746631384540e-01))); %!test %! assert (isequal (sin (infsup (6.0, 7.0)), infsup (-2.794154981989259157e-01, 6.569865987187891720e-01))); %!test %! assert (isequal (sin (infsup (6.0, 6.0)), infsup (-2.794154981989259157e-01, -2.794154981989258602e-01))); %!test %! assert (isequal (sin (infsup (7.0, 7.0)), infsup (6.569865987187890610e-01, 6.569865987187891720e-01))); ## mpfi_sinh %!# special values %!test %! assert (isequal (sinh (infsup (-inf, -7.0)), infsup (-inf, -5.483161232732464896e+02))); %!test %! assert (isequal (sinh (infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (sinh (infsup (-inf, +8.0)), infsup (-inf, 1.490478825789550228e+03))); %!test %! assert (isequal (sinh (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (sinh (infsup (-1.0, 0.0)), infsup (-1.175201193643801600e+00, 0.0))); %!test %! assert (isequal (sinh (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (sinh (infsup (0.0, +1.0)), infsup (0.0, 1.175201193643801600e+00))); %!test %! assert (isequal (sinh (infsup (0.0, +8.0)), infsup (0.0, 1.490478825789550228e+03))); %!test %! assert (isequal (sinh (infsup (0.0, inf)), infsup (0.0, inf))); %!# regular values %!test %! assert (isequal (sinh (infsup (-0.125, 0.0)), infsup (-1.253257752411154613e-01, 0.0))); %!test %! assert (isequal (sinh (infsup (0.0, 5.000000000000001110e-01)), infsup (0.0, 5.210953054937474960e-01))); %!test %! assert (isequal (sinh (infsup (-4.5, -0.625)), infsup (-4.500301115199179236e+01, -6.664922644566160237e-01))); %!test %! assert (isequal (sinh (infsup (1.0, 3.0)), infsup (1.175201193643801378e+00, 1.001787492740990260e+01))); ## mpfi_sqr %!# special values %!test %! assert (isequal (pown (infsup (-inf, -7.0), 2), infsup (+49.0, inf))); %! assert (isequal (infsup (-inf, -7.0) .^ 2, infsup (+49.0, inf))); %! assert (isequal (power (infsup (-inf, -7.0), 2), infsup (+49.0, inf))); %! assert (isequal (infsup (-inf, -7.0) ^ 2, infsup (+49.0, inf))); %! assert (isequal (mpower (infsup (-inf, -7.0), 2), infsup (+49.0, inf))); %!test %! assert (isequal (pown (infsup (-inf, 0.0), 2), infsup (0.0, inf))); %! assert (isequal (infsup (-inf, 0.0) .^ 2, infsup (0.0, inf))); %! assert (isequal (power (infsup (-inf, 0.0), 2), infsup (0.0, inf))); %! assert (isequal (infsup (-inf, 0.0) ^ 2, infsup (0.0, inf))); %! assert (isequal (mpower (infsup (-inf, 0.0), 2), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-inf, +8.0), 2), infsup (0.0, inf))); %! assert (isequal (infsup (-inf, +8.0) .^ 2, infsup (0.0, inf))); %! assert (isequal (power (infsup (-inf, +8.0), 2), infsup (0.0, inf))); %! assert (isequal (infsup (-inf, +8.0) ^ 2, infsup (0.0, inf))); %! assert (isequal (mpower (infsup (-inf, +8.0), 2), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-inf, inf), 2), infsup (0.0, inf))); %! assert (isequal (infsup (-inf, inf) .^ 2, infsup (0.0, inf))); %! assert (isequal (power (infsup (-inf, inf), 2), infsup (0.0, inf))); %! assert (isequal (infsup (-inf, inf) ^ 2, infsup (0.0, inf))); %! assert (isequal (mpower (infsup (-inf, inf), 2), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (0.0, 0.0), 2), infsup (0.0, 0.0))); %! assert (isequal (infsup (0.0, 0.0) .^ 2, infsup (0.0, 0.0))); %! assert (isequal (power (infsup (0.0, 0.0), 2), infsup (0.0, 0.0))); %! assert (isequal (infsup (0.0, 0.0) ^ 2, infsup (0.0, 0.0))); %! assert (isequal (mpower (infsup (0.0, 0.0), 2), infsup (0.0, 0.0))); %!test %! assert (isequal (pown (infsup (0.0, +8.0), 2), infsup (0.0, +64.0))); %! assert (isequal (infsup (0.0, +8.0) .^ 2, infsup (0.0, +64.0))); %! assert (isequal (power (infsup (0.0, +8.0), 2), infsup (0.0, +64.0))); %! assert (isequal (infsup (0.0, +8.0) ^ 2, infsup (0.0, +64.0))); %! assert (isequal (mpower (infsup (0.0, +8.0), 2), infsup (0.0, +64.0))); %!test %! assert (isequal (pown (infsup (0.0, inf), 2), infsup (0.0, inf))); %! assert (isequal (infsup (0.0, inf) .^ 2, infsup (0.0, inf))); %! assert (isequal (power (infsup (0.0, inf), 2), infsup (0.0, inf))); %! assert (isequal (infsup (0.0, inf) ^ 2, infsup (0.0, inf))); %! assert (isequal (mpower (infsup (0.0, inf), 2), infsup (0.0, inf))); %!# regular values %!test %! assert (isequal (pown (infsup (5.242813527584075928e-01, 1.009848281860351562e+03), 2), infsup (2.748709368501858208e-01, 1.019793552376304055e+06))); %! assert (isequal (infsup (5.242813527584075928e-01, 1.009848281860351562e+03) .^ 2, infsup (2.748709368501858208e-01, 1.019793552376304055e+06))); %! assert (isequal (power (infsup (5.242813527584075928e-01, 1.009848281860351562e+03), 2), infsup (2.748709368501858208e-01, 1.019793552376304055e+06))); %! assert (isequal (infsup (5.242813527584075928e-01, 1.009848281860351562e+03) ^ 2, infsup (2.748709368501858208e-01, 1.019793552376304055e+06))); %! assert (isequal (mpower (infsup (5.242813527584075928e-01, 1.009848281860351562e+03), 2), infsup (2.748709368501858208e-01, 1.019793552376304055e+06))); %!test %! assert (isequal (pown (infsup (1.020801660558309578e+02, 1.193046000000000000e+06), 2), infsup (1.042036030198602202e+04, 1.423358758116000000e+12))); %! assert (isequal (infsup (1.020801660558309578e+02, 1.193046000000000000e+06) .^ 2, infsup (1.042036030198602202e+04, 1.423358758116000000e+12))); %! assert (isequal (power (infsup (1.020801660558309578e+02, 1.193046000000000000e+06), 2), infsup (1.042036030198602202e+04, 1.423358758116000000e+12))); %! assert (isequal (infsup (1.020801660558309578e+02, 1.193046000000000000e+06) ^ 2, infsup (1.042036030198602202e+04, 1.423358758116000000e+12))); %! assert (isequal (mpower (infsup (1.020801660558309578e+02, 1.193046000000000000e+06), 2), infsup (1.042036030198602202e+04, 1.423358758116000000e+12))); %!test %! assert (isequal (pown (infsup (-1.392367054308168983e+00, 1.000000000000000000e+00), 2), infsup (0.0, 1.938686013922807705e+00))); %! assert (isequal (infsup (-1.392367054308168983e+00, 1.000000000000000000e+00) .^ 2, infsup (0.0, 1.938686013922807705e+00))); %! assert (isequal (power (infsup (-1.392367054308168983e+00, 1.000000000000000000e+00), 2), infsup (0.0, 1.938686013922807705e+00))); %! assert (isequal (infsup (-1.392367054308168983e+00, 1.000000000000000000e+00) ^ 2, infsup (0.0, 1.938686013922807705e+00))); %! assert (isequal (mpower (infsup (-1.392367054308168983e+00, 1.000000000000000000e+00), 2), infsup (0.0, 1.938686013922807705e+00))); %!test %! assert (isequal (pown (infsup (1.418084280671316311e+00, 2.688493217609218444e+00), 2), infsup (2.010963027087084409e+00, 7.227995781130768904e+00))); %! assert (isequal (infsup (1.418084280671316311e+00, 2.688493217609218444e+00) .^ 2, infsup (2.010963027087084409e+00, 7.227995781130768904e+00))); %! assert (isequal (power (infsup (1.418084280671316311e+00, 2.688493217609218444e+00), 2), infsup (2.010963027087084409e+00, 7.227995781130768904e+00))); %! assert (isequal (infsup (1.418084280671316311e+00, 2.688493217609218444e+00) ^ 2, infsup (2.010963027087084409e+00, 7.227995781130768904e+00))); %! assert (isequal (mpower (infsup (1.418084280671316311e+00, 2.688493217609218444e+00), 2), infsup (2.010963027087084409e+00, 7.227995781130768904e+00))); ## mpfi_sqrt %!# special values %!test %! assert (isequal (realsqrt (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (realsqrt (infsup (0.0, +9.0)), infsup (0.0, +3.0))); %!test %! assert (isequal (realsqrt (infsup (0.0, inf)), infsup (0.0, inf))); %!# regular values %!test %! assert (isequal (realsqrt (infsup (4.368100000000000000e+04, 1.423358758116000000e+12)), infsup (2.090000000000000000e+02, 1.193046000000000000e+06))); %!test %! assert (isequal (realsqrt (infsup (8.929886572570981951e-01, 4.368100000000000000e+04)), infsup (9.449807708398610950e-01, 2.090000000000000000e+02))); %!test %! assert (isequal (realsqrt (infsup (6.665191650390625000e-01, 1.047677010367332295e+00)), infsup (8.164062500000000000e-01, 1.023560946093261537e+00))); %!test %! assert (isequal (realsqrt (infsup (8.929886572570981951e-01, 1.047677010367332295e+00)), infsup (9.449807708398610950e-01, 1.023560946093261537e+00))); ## mpfi_sub %!# special values %!test %! assert (isequal (infsup (-inf, -7.0) - infsup (-1.0, +8.0), infsup (-inf, -6.0))); %! assert (isequal (minus (infsup (-inf, -7.0), infsup (-1.0, +8.0)), infsup (-inf, -6.0))); %!test %! assert (isequal (infsup (-inf, 0.0) - infsup (+8.0, inf), infsup (-inf, -8.0))); %! assert (isequal (minus (infsup (-inf, 0.0), infsup (+8.0, inf)), infsup (-inf, -8.0))); %!test %! assert (isequal (infsup (-inf, +8.0) - infsup (0.0, +8.0), infsup (-inf, +8.0))); %! assert (isequal (minus (infsup (-inf, +8.0), infsup (0.0, +8.0)), infsup (-inf, +8.0))); %!test %! assert (isequal (infsup (-inf, inf) - infsup (0.0, +8.0), infsup (-inf, inf))); %! assert (isequal (minus (infsup (-inf, inf), infsup (0.0, +8.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, 0.0) - infsup (-inf, -7.0), infsup (+7.0, inf))); %! assert (isequal (minus (infsup (0.0, 0.0), infsup (-inf, -7.0)), infsup (+7.0, inf))); %!test %! assert (isequal (infsup (0.0, +8.0) - infsup (-7.0, 0.0), infsup (0.0, +15.0))); %! assert (isequal (minus (infsup (0.0, +8.0), infsup (-7.0, 0.0)), infsup (0.0, +15.0))); %!test %! assert (isequal (infsup (0.0, 0.0) - infsup (0.0, +8.0), infsup (-8.0, 0.0))); %! assert (isequal (minus (infsup (0.0, 0.0), infsup (0.0, +8.0)), infsup (-8.0, 0.0))); %!test %! assert (isequal (infsup (0.0, inf) - infsup (0.0, +8.0), infsup (-8.0, inf))); %! assert (isequal (minus (infsup (0.0, inf), infsup (0.0, +8.0)), infsup (-8.0, inf))); %!test %! assert (isequal (infsup (0.0, 0.0) - infsup (+8.0, inf), infsup (-inf, -8.0))); %! assert (isequal (minus (infsup (0.0, 0.0), infsup (+8.0, inf)), infsup (-inf, -8.0))); %!test %! assert (isequal (infsup (0.0, 0.0) - infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (minus (infsup (0.0, 0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, +8.0) - infsup (-7.0, +8.0), infsup (-8.0, +15.0))); %! assert (isequal (minus (infsup (0.0, +8.0), infsup (-7.0, +8.0)), infsup (-8.0, +15.0))); %!test %! assert (isequal (infsup (0.0, 0.0) - infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (minus (infsup (0.0, 0.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, inf) - infsup (0.0, +8.0), infsup (-8.0, inf))); %! assert (isequal (minus (infsup (0.0, inf), infsup (0.0, +8.0)), infsup (-8.0, inf))); %!# regular values %!test %! assert (isequal (infsup (-5.0, 59.0) - infsup (17.0, 81.0), infsup (-86.0, 42.0))); %! assert (isequal (minus (infsup (-5.0, 59.0), infsup (17.0, 81.0)), infsup (-86.0, 42.0))); %!test %! assert (isequal (infsup (-4.909093465297726553e-91, 3.202558470389760000e+14) - infsup (-1.264629250000000000e+08, 4.547473508864641190e-13), infsup (-4.547473508864642199e-13, 3.202559735019010000e+14))); %! assert (isequal (minus (infsup (-4.909093465297726553e-91, 3.202558470389760000e+14), infsup (-1.264629250000000000e+08, 4.547473508864641190e-13)), infsup (-4.547473508864642199e-13, 3.202559735019010000e+14))); %!test %! assert (isequal (infsup (-4.0, 7.0) - infsup (-3e300, 2.443359172835548401e+09), infsup (-2.443359176835548401e+09, 3.000000000000000752e+300))); %! assert (isequal (minus (infsup (-4.0, 7.0), infsup (-3e300, 2.443359172835548401e+09)), infsup (-2.443359176835548401e+09, 3.000000000000000752e+300))); %!test %! assert (isequal (infsup (-7.205869356633318400e+16, 1.152921504606846976e+18) - infsup (-3e300, 2.814792717434890000e+14), infsup (-7.234017283807668800e+16, 3.000000000000000752e+300))); %! assert (isequal (minus (infsup (-7.205869356633318400e+16, 1.152921504606846976e+18), infsup (-3e300, 2.814792717434890000e+14)), infsup (-7.234017283807668800e+16, 3.000000000000000752e+300))); %!test %! assert (isequal (infsup (-5.0, 1.0) - infsup (1.0, 1.180591620717411303e+21), infsup (-1.180591620717411566e+21, 0.0))); %! assert (isequal (minus (infsup (-5.0, 1.0), infsup (1.0, 1.180591620717411303e+21)), infsup (-1.180591620717411566e+21, 0.0))); %!test %! assert (isequal (infsup (5.0, 1.180591620717411303e+21) - infsup (3.0, 5.0), infsup (0.0, 1.180591620717411303e+21))); %! assert (isequal (minus (infsup (5.0, 1.180591620717411303e+21), infsup (3.0, 5.0)), infsup (0.0, 1.180591620717411303e+21))); ## mpfi_sub_d %!# special values %!test %! assert (isequal (infsup (-inf, -7.0) - infsup (-4.000000000000000286e-17, -4.000000000000000286e-17), infsup (-inf, -6.999999999999999112e+00))); %! assert (isequal (minus (infsup (-inf, -7.0), infsup (-4.000000000000000286e-17, -4.000000000000000286e-17)), infsup (-inf, -6.999999999999999112e+00))); %!test %! assert (isequal (infsup (-inf, -7.0) - infsup (0.0, 0.0), infsup (-inf, -7.0))); %! assert (isequal (minus (infsup (-inf, -7.0), infsup (0.0, 0.0)), infsup (-inf, -7.0))); %!test %! assert (isequal (infsup (-inf, -7.0) - infsup (4.000000000000000286e-17, 4.000000000000000286e-17), infsup (-inf, -7.0))); %! assert (isequal (minus (infsup (-inf, -7.0), infsup (4.000000000000000286e-17, 4.000000000000000286e-17)), infsup (-inf, -7.0))); %!test %! assert (isequal (infsup (-inf, 0.0) - infsup (-8.000000000000000572e-17, -8.000000000000000572e-17), infsup (-inf, 8.000000000000000572e-17))); %! assert (isequal (minus (infsup (-inf, 0.0), infsup (-8.000000000000000572e-17, -8.000000000000000572e-17)), infsup (-inf, 8.000000000000000572e-17))); %!test %! assert (isequal (infsup (-inf, 0.0) - infsup (0.0, 0.0), infsup (-inf, 0.0))); %! assert (isequal (minus (infsup (-inf, 0.0), infsup (0.0, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-inf, 0.0) - infsup (8.000000000000000572e-17, 8.000000000000000572e-17), infsup (-inf, -8.0e-17))); %! assert (isequal (minus (infsup (-inf, 0.0), infsup (8.000000000000000572e-17, 8.000000000000000572e-17)), infsup (-inf, -8.0e-17))); %!test %! assert (isequal (infsup (-inf, 8.0) - infsup (-1.600000000000000000e+18, -1.600000000000000000e+18), infsup (-inf, 1.600000000000000256e+18))); %! assert (isequal (minus (infsup (-inf, 8.0), infsup (-1.600000000000000000e+18, -1.600000000000000000e+18)), infsup (-inf, 1.600000000000000256e+18))); %!test %! assert (isequal (infsup (-inf, 8.0) - infsup (0.0, 0.0), infsup (-inf, 8.0))); %! assert (isequal (minus (infsup (-inf, 8.0), infsup (0.0, 0.0)), infsup (-inf, 8.0))); %!test %! assert (isequal (infsup (-inf, 8.0) - infsup (1.600000000000000000e+18, 1.600000000000000000e+18), infsup (-inf, -1.599999999999999744e+18))); %! assert (isequal (minus (infsup (-inf, 8.0), infsup (1.600000000000000000e+18, 1.600000000000000000e+18)), infsup (-inf, -1.599999999999999744e+18))); %!test %! assert (isequal (infsup (-inf, inf) - infsup (-1.600000000000000114e-16, -1.600000000000000114e-16), infsup (-inf, inf))); %! assert (isequal (minus (infsup (-inf, inf), infsup (-1.600000000000000114e-16, -1.600000000000000114e-16)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) - infsup (0.0e-17, 0.0e-17), infsup (-inf, inf))); %! assert (isequal (minus (infsup (-inf, inf), infsup (0.0e-17, 0.0e-17)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) - infsup (1.600000000000000114e-16, 1.600000000000000114e-16), infsup (-inf, inf))); %! assert (isequal (minus (infsup (-inf, inf), infsup (1.600000000000000114e-16, 1.600000000000000114e-16)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, 0.0) - infsup (-1.000000000000000072e-17, -1.000000000000000072e-17), infsup (1.000000000000000072e-17, 1.000000000000000072e-17))); %! assert (isequal (minus (infsup (0.0, 0.0), infsup (-1.000000000000000072e-17, -1.000000000000000072e-17)), infsup (1.000000000000000072e-17, 1.000000000000000072e-17))); %!test %! assert (isequal (infsup (0.0, 0.0) - infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (minus (infsup (0.0, 0.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) - infsup (1.000000000000000072e-17, 1.000000000000000072e-17), infsup (-1.000000000000000072e-17, -1.000000000000000072e-17))); %! assert (isequal (minus (infsup (0.0, 0.0), infsup (1.000000000000000072e-17, 1.000000000000000072e-17)), infsup (-1.000000000000000072e-17, -1.000000000000000072e-17))); %!test %! assert (isequal (infsup (0.0, 8.0) - infsup (-3.000000000000000061e-17, -3.000000000000000061e-17), infsup (3.000000000000000061e-17, 8.000000000000001776e+00))); %! assert (isequal (minus (infsup (0.0, 8.0), infsup (-3.000000000000000061e-17, -3.000000000000000061e-17)), infsup (3.000000000000000061e-17, 8.000000000000001776e+00))); %!test %! assert (isequal (infsup (0.0, 8.0) - infsup (0.0, 0.0), infsup (0.0, 8.0))); %! assert (isequal (minus (infsup (0.0, 8.0), infsup (0.0, 0.0)), infsup (0.0, 8.0))); %!test %! assert (isequal (infsup (0.0, 8.0) - infsup (3.000000000000000061e-17, 3.000000000000000061e-17), infsup (-3.000000000000000061e-17, 8.0))); %! assert (isequal (minus (infsup (0.0, 8.0), infsup (3.000000000000000061e-17, 3.000000000000000061e-17)), infsup (-3.000000000000000061e-17, 8.0))); %!test %! assert (isequal (infsup (0.0, inf) - infsup (-7.000000000000000347e-17, -7.000000000000000347e-17), infsup (7.000000000000000347e-17, inf))); %! assert (isequal (minus (infsup (0.0, inf), infsup (-7.000000000000000347e-17, -7.000000000000000347e-17)), infsup (7.000000000000000347e-17, inf))); %!test %! assert (isequal (infsup (0.0, inf) - infsup (0.0, 0.0), infsup (0.0, inf))); %! assert (isequal (minus (infsup (0.0, inf), infsup (0.0, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (0.0, inf) - infsup (6.999999999999999114e-17, 6.999999999999999114e-17), infsup (-6.999999999999999114e-17, inf))); %! assert (isequal (minus (infsup (0.0, inf), infsup (6.999999999999999114e-17, 6.999999999999999114e-17)), infsup (-6.999999999999999114e-17, inf))); %!# regular values %!test %! assert (isequal (infsup (-32.0, -17.0) - infsup (3.141592653589793116e+01, 3.141592653589793116e+01), infsup (-6.341592653589793116e+01, -4.841592653589793116e+01))); %! assert (isequal (minus (infsup (-32.0, -17.0), infsup (3.141592653589793116e+01, 3.141592653589793116e+01)), infsup (-6.341592653589793116e+01, -4.841592653589793116e+01))); %!test %! assert (isequal (infsup (-3.141592653589793116e+01, -17.0) - infsup (-3.141592653589793116e+01, -3.141592653589793116e+01), infsup (0.0, 1.441592653589793116e+01))); %! assert (isequal (minus (infsup (-3.141592653589793116e+01, -17.0), infsup (-3.141592653589793116e+01, -3.141592653589793116e+01)), infsup (0.0, 1.441592653589793116e+01))); %!test %! assert (isequal (infsup (-32.0, -1.570796326794896558e+01) - infsup (-1.570796326794896558e+01, -1.570796326794896558e+01), infsup (-1.629203673205103442e+01, 0.0))); %! assert (isequal (minus (infsup (-32.0, -1.570796326794896558e+01), infsup (-1.570796326794896558e+01, -1.570796326794896558e+01)), infsup (-1.629203673205103442e+01, 0.0))); %!test %! assert (isequal (infsup (1.820444444444444443e+01, 3.202559735019019375e+14) - infsup (-3.5, -3.5), infsup (2.170444444444444443e+01, 3.202559735019054375e+14))); %! assert (isequal (minus (infsup (1.820444444444444443e+01, 3.202559735019019375e+14), infsup (-3.5, -3.5)), infsup (2.170444444444444443e+01, 3.202559735019054375e+14))); %!test %! assert (isequal (infsup (7.111111111111111105e-02, 3.202559735019019375e+14) - infsup (-3.5, -3.5), infsup (3.571111111111110681e+00, 3.202559735019054375e+14))); %! assert (isequal (minus (infsup (7.111111111111111105e-02, 3.202559735019019375e+14), infsup (-3.5, -3.5)), infsup (3.571111111111110681e+00, 3.202559735019054375e+14))); %!test %! assert (isequal (infsup (-2.550000000000000000e+02, 1.137777777777777777e+00) - infsup (-256.5, -256.5), infsup (1.500000000000000000e+00, 2.576377777777777851e+02))); %! assert (isequal (minus (infsup (-2.550000000000000000e+02, 1.137777777777777777e+00), infsup (-256.5, -256.5)), infsup (1.500000000000000000e+00, 2.576377777777777851e+02))); %!test %! assert (isequal (infsup (-1.999999999999999778e+00, -2.713328551617526225e-166) - infsup (-4097.5, -4097.5), infsup (4.095500000000000000e+03, 4.097500000000000000e+03))); %! assert (isequal (minus (infsup (-1.999999999999999778e+00, -2.713328551617526225e-166), infsup (-4097.5, -4097.5)), infsup (4.095500000000000000e+03, 4.097500000000000000e+03))); %!test %! assert (isequal (infsup (1.820444444444444443e+01, 3.202559735019019375e+14) - infsup (3.5, 3.5), infsup (1.470444444444444443e+01, 3.202559735018984375e+14))); %! assert (isequal (minus (infsup (1.820444444444444443e+01, 3.202559735019019375e+14), infsup (3.5, 3.5)), infsup (1.470444444444444443e+01, 3.202559735018984375e+14))); %!test %! assert (isequal (infsup (7.111111111111111105e-02, 3.202559735019019375e+14) - infsup (3.5, 3.5), infsup (-3.428888888888889319e+00, 3.202559735018984375e+14))); %! assert (isequal (minus (infsup (7.111111111111111105e-02, 3.202559735019019375e+14), infsup (3.5, 3.5)), infsup (-3.428888888888889319e+00, 3.202559735018984375e+14))); %!test %! assert (isequal (infsup (-2.550000000000000000e+02, 1.137777777777777777e+00) - infsup (256.5, 256.5), infsup (-5.115000000000000000e+02, -2.553622222222222149e+02))); %! assert (isequal (minus (infsup (-2.550000000000000000e+02, 1.137777777777777777e+00), infsup (256.5, 256.5)), infsup (-5.115000000000000000e+02, -2.553622222222222149e+02))); %!test %! assert (isequal (infsup (-1.999999999999999778e+00, -2.713328551617526225e-166) - infsup (4097.5, 4097.5), infsup (-4.099500000000000000e+03, -4.097500000000000000e+03))); %! assert (isequal (minus (infsup (-1.999999999999999778e+00, -2.713328551617526225e-166), infsup (4097.5, 4097.5)), infsup (-4.099500000000000000e+03, -4.097500000000000000e+03))); ## mpfi_tan %!# special values %!test %! assert (isequal (tan (infsup (-inf, -7.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-inf, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-inf, +8.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-1.0, 0.0)), infsup (-1.557407724654902292e+00, 0.0))); %!test %! assert (isequal (tan (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (tan (infsup (0.0, +1.0)), infsup (0.0, 1.557407724654902292e+00))); %!test %! assert (isequal (tan (infsup (0.0, +8.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (0.0, inf)), infsup (-inf, inf))); %!# regular values %!test %! assert (isequal (tan (infsup (0.125, 17.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (1.570796326794896558e+00, 1.570796326794896780e+00)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-2.0, -0.5)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-4.5, 0.625)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-1.0, -0.25)), infsup (-1.557407724654902292e+00, -2.553419212210362166e-01))); %!test %! assert (isequal (tan (infsup (-0.5, 0.5)), infsup (-5.463024898437905952e-01, 5.463024898437905952e-01))); %!test %! assert (isequal (tan (infsup (8.538038601028318546e+24, 8.538038601028318546e+24)), infsup (-2.230768789827465293e-01, -2.230768789827465015e-01))); %!test %! assert (isequal (tan (infsup (-7.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-7.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-7.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-7.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-7.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-7.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-7.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-7.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-7.0, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-7.0, -2.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-7.0, -3.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-7.0, -4.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-7.0, -5.0)), infsup (-8.714479827243187815e-01, 3.380515006246585852e+00))); %!test %! assert (isequal (tan (infsup (-7.0, -6.0)), infsup (-8.714479827243187815e-01, 2.910061913847492021e-01))); %!test %! assert (isequal (tan (infsup (-7.0, -7.0)), infsup (-8.714479827243187815e-01, -8.714479827243186705e-01))); %!test %! assert (isequal (tan (infsup (-6.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-6.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-6.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-6.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-6.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-6.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-6.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-6.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-6.0, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-6.0, -2.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-6.0, -3.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-6.0, -4.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-6.0, -5.0)), infsup (2.910061913847491466e-01, 3.380515006246585852e+00))); %!test %! assert (isequal (tan (infsup (-6.0, -6.0)), infsup (2.910061913847491466e-01, 2.910061913847492021e-01))); %!test %! assert (isequal (tan (infsup (-5.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-5.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-5.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-5.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-5.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-5.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-5.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-5.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-5.0, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-5.0, -2.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-5.0, -3.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-5.0, -4.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-5.0, -5.0)), infsup (3.380515006246585408e+00, 3.380515006246585852e+00))); %!test %! assert (isequal (tan (infsup (-4.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-4.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-4.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-4.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-4.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-4.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-4.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-4.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-4.0, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-4.0, -2.0)), infsup (-1.157821282349577707e+00, 2.185039863261519333e+00))); %!test %! assert (isequal (tan (infsup (-4.0, -3.0)), infsup (-1.157821282349577707e+00, 1.425465430742778317e-01))); %!test %! assert (isequal (tan (infsup (-4.0, -4.0)), infsup (-1.157821282349577707e+00, -1.157821282349577485e+00))); %!test %! assert (isequal (tan (infsup (-3.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-3.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-3.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-3.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-3.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-3.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-3.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-3.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-3.0, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-3.0, -2.0)), infsup (1.425465430742778039e-01, 2.185039863261519333e+00))); %!test %! assert (isequal (tan (infsup (-3.0, -3.0)), infsup (1.425465430742778039e-01, 1.425465430742778317e-01))); %!test %! assert (isequal (tan (infsup (-2.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-2.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-2.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-2.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-2.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-2.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-2.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-2.0, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-2.0, -2.0)), infsup (2.185039863261518889e+00, 2.185039863261519333e+00))); %!test %! assert (isequal (tan (infsup (-1.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-1.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-1.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-1.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-1.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-1.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-1.0, 1.0)), infsup (-1.557407724654902292e+00, 1.557407724654902292e+00))); %!test %! assert (isequal (tan (infsup (-1.0, 0.0)), infsup (-1.557407724654902292e+00, 0.0))); %!test %! assert (isequal (tan (infsup (-1.0, -1.0)), infsup (-1.557407724654902292e+00, -1.557407724654902070e+00))); %!test %! assert (isequal (tan (infsup (1.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (1.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (1.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (1.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (1.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (1.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (1.0, 1.0)), infsup (1.557407724654902070e+00, 1.557407724654902292e+00))); %!test %! assert (isequal (tan (infsup (2.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (2.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (2.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (2.0, 4.0)), infsup (-2.185039863261519333e+00, 1.157821282349577707e+00))); %!test %! assert (isequal (tan (infsup (2.0, 3.0)), infsup (-2.185039863261519333e+00, -1.425465430742778039e-01))); %!test %! assert (isequal (tan (infsup (2.0, 2.0)), infsup (-2.185039863261519333e+00, -2.185039863261518889e+00))); %!test %! assert (isequal (tan (infsup (3.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (3.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (3.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (3.0, 4.0)), infsup (-1.425465430742778317e-01, 1.157821282349577707e+00))); %!test %! assert (isequal (tan (infsup (3.0, 3.0)), infsup (-1.425465430742778317e-01, -1.425465430742778039e-01))); %!test %! assert (isequal (tan (infsup (4.0, 7.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (4.0, 6.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (4.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (4.0, 4.0)), infsup (1.157821282349577485e+00, 1.157821282349577707e+00))); %!test %! assert (isequal (tan (infsup (5.0, 7.0)), infsup (-3.380515006246585852e+00, 8.714479827243187815e-01))); %!test %! assert (isequal (tan (infsup (5.0, 6.0)), infsup (-3.380515006246585852e+00, -2.910061913847491466e-01))); %!test %! assert (isequal (tan (infsup (5.0, 5.0)), infsup (-3.380515006246585852e+00, -3.380515006246585408e+00))); %!test %! assert (isequal (tan (infsup (6.0, 7.0)), infsup (-2.910061913847492021e-01, 8.714479827243187815e-01))); %!test %! assert (isequal (tan (infsup (6.0, 6.0)), infsup (-2.910061913847492021e-01, -2.910061913847491466e-01))); %!test %! assert (isequal (tan (infsup (7.0, 7.0)), infsup (8.714479827243186705e-01, 8.714479827243187815e-01))); ## mpfi_tanh %!# special values %!test %! assert (isequal (tanh (infsup (-inf, -7.0)), infsup (-1.0, -9.999983369439445768e-01))); %!test %! assert (isequal (tanh (infsup (-inf, 0.0)), infsup (-1.0, 0.0))); %!test %! assert (isequal (tanh (infsup (-inf, 8.0)), infsup (-1.0, 9.999997749296759553e-01))); %!test %! assert (isequal (tanh (infsup (-inf, inf)), infsup (-1.0, +1.0))); %!test %! assert (isequal (tanh (infsup (-1.0, 0.0)), infsup (-7.615941559557649621e-01, 0.0))); %!test %! assert (isequal (tanh (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (tanh (infsup (0.0, 1.0)), infsup (0.0, 7.615941559557649621e-01))); %!test %! assert (isequal (tanh (infsup (0.0, 8.0)), infsup (0.0, 9.999997749296759553e-01))); %!test %! assert (isequal (tanh (infsup (0.0, inf)), infsup (0.0, +1.0))); %!# regular values %!test %! assert (isequal (tanh (infsup (-0.125, 0.0)), infsup (-1.243530017715962083e-01, 0.0))); %!test %! assert (isequal (tanh (infsup (0.0, 5.000000000000001110e-01)), infsup (0.0, 4.621171572600098476e-01))); %!test %! assert (isequal (tanh (infsup (-4.5, -0.625)), infsup (-9.997532108480275959e-01, -5.545997223493822625e-01))); %!test %! assert (isequal (tanh (infsup (1.0, 3.0)), infsup (7.615941559557648510e-01, 9.950547536867304643e-01))); %!test %! assert (isequal (tanh (infsup (17.0, 18.0)), infsup (9.999999999999965583e-01, 9.999999999999995559e-01))); ## mpfi_union %!# special values %!test %! assert (isequal (union (infsup (-inf, -7.0), infsup (-1.0, +8.0)), infsup (-inf, +8.0))); %!test %! assert (isequal (union (infsup (-inf, 0.0), infsup (+8.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (union (infsup (-inf, +8.0), infsup (0.0, +8.0)), infsup (-inf, +8.0))); %!test %! assert (isequal (union (infsup (-inf, inf), infsup (0.0, +8.0)), infsup (-inf, inf))); %!test %! assert (isequal (union (infsup (0.0, 0.0), infsup (-inf, -7.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (union (infsup (0.0, +8.0), infsup (-7.0, 0.0)), infsup (-7.0, +8.0))); %!test %! assert (isequal (union (infsup (0.0, 0.0), infsup (0.0, +8.0)), infsup (0.0, +8.0))); %!test %! assert (isequal (union (infsup (0.0, inf), infsup (0.0, +8.0)), infsup (0.0, inf))); %!test %! assert (isequal (union (infsup (0.0, 0.0), infsup (+8.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (union (infsup (0.0, 0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (union (infsup (0.0, +8.0), infsup (-7.0, +8.0)), infsup (-7.0, +8.0))); %!test %! assert (isequal (union (infsup (0.0, 0.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (union (infsup (0.0, inf), infsup (0.0, +8.0)), infsup (0.0, inf))); %!# regular values %!test %! assert (isequal (union (infsup (1.800000000000000000e+01, 1.440000000000000000e+02), infsup (-1.300000000000000000e+01, 5.200000000000000000e+01)), infsup (-1.300000000000000000e+01, 1.440000000000000000e+02))); interval-1.4.1/inst/test/libieeep1788_tests_set.tst0000644000175000017500000001314012657476046021636 0ustar oliveroliver## DO NOT EDIT! Generated automatically from test/libieeep1788_tests_set.itl ## by the Interval Testing Framework for IEEE 1788. ## https://github.com/nehmeier/ITF1788/tree/635bff73cc64ff8aab0ff2031ee8a53980be0115 ## ## Copyright 2013-2015 Marco Nehmeier (nehmeier@informatik.uni-wuerzburg.de) ## Copyright 2015-2016 Oliver Heimlich ## ## Original author: Marco Nehmeier (unit tests in libieeep1788, ## original license: Apache License 2.0) ## Converted into portable ITL format by Oliver Heimlich with minor corrections. ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## %!#Test library imports %!#Arithmetic library imports pkg load interval %!#Preamble try; error ("__FILE__"); catch test (lasterror.stack.file, "quiet", stdout); end_try_catch; %!function assert_warn (observed_value, expected_value) %! if (not (isequal (observed_value, expected_value))) %! observed_expression = regexprep (argn(1, :), '\s+$', ''); %! expected_expression = regexprep (argn(2, :), '\s+$', ''); %! observed_as_char = disp (observed_value)(1 : end - 1); %! expected_as_char = disp(expected_value)(1 : end - 1); %! warning ([observed_expression, " != ", expected_expression, ... %! "\n ", observed_as_char, " != ", expected_as_char]); %! endif %!endfunction ## minimal_intersection_test %!test %! assert (isequal (intersect (infsup (1.0, 3.0), infsup (2.1, 4.0)), infsup (2.1, 3.0))); %!test %! assert (isequal (intersect (infsup (1.0, 3.0), infsup (3.0, 4.0)), infsup (3.0, 3.0))); %!test %! assert (isequal (intersect (infsup (1.0, 3.0), infsup), infsup)); %!test %! assert (isequal (intersect (infsup (-inf, inf), infsup), infsup)); %!test %! assert (isequal (intersect (infsup (1.0, 3.0), infsup (-inf, inf)), infsup (1.0, 3.0))); ## minimal_intersection_dec_test %!test %! assert (isequal (intersect (infsupdec (1.0, 3.0, "com"), infsupdec (2.1, 4.0, "com")), infsupdec (2.1, 3.0, "trv"))); %! assert (isequal (decorationpart (intersect (infsupdec (1.0, 3.0, "com"), infsupdec (2.1, 4.0, "com"))){1}, decorationpart (infsupdec (2.1, 3.0, "trv")){1})); %!test %! assert (isequal (intersect (infsupdec (1.0, 3.0, "dac"), infsupdec (3.0, 4.0, "def")), infsupdec (3.0, 3.0, "trv"))); %! assert (isequal (decorationpart (intersect (infsupdec (1.0, 3.0, "dac"), infsupdec (3.0, 4.0, "def"))){1}, decorationpart (infsupdec (3.0, 3.0, "trv")){1})); %!test %! assert (isequal (intersect (infsupdec (1.0, 3.0, "def"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (intersect (infsupdec (1.0, 3.0, "def"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (intersect (infsupdec (entire, "def"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (intersect (infsupdec (entire, "def"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (intersect (infsupdec (1.0, 3.0, "dac"), infsupdec (entire, "def")), infsupdec (1.0, 3.0, "trv"))); %! assert (isequal (decorationpart (intersect (infsupdec (1.0, 3.0, "dac"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (1.0, 3.0, "trv")){1})); ## minimal_convexHull_test %!test %! assert (isequal (union (infsup (1.0, 3.0), infsup (2.1, 4.0)), infsup (1.0, 4.0))); %!test %! assert (isequal (union (infsup (1.0, 1.0), infsup (2.1, 4.0)), infsup (1.0, 4.0))); %!test %! assert (isequal (union (infsup (1.0, 3.0), infsup), infsup (1.0, 3.0))); %!test %! assert (isequal (union (infsup, infsup), infsup)); %!test %! assert (isequal (union (infsup (1.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); ## minimal_convexHull_dec_test %!test %! assert (isequal (union (infsupdec (1.0, 3.0, "trv"), infsupdec (2.1, 4.0, "trv")), infsupdec (1.0, 4.0, "trv"))); %! assert (isequal (decorationpart (union (infsupdec (1.0, 3.0, "trv"), infsupdec (2.1, 4.0, "trv"))){1}, decorationpart (infsupdec (1.0, 4.0, "trv")){1})); %!test %! assert (isequal (union (infsupdec (1.0, 1.0, "trv"), infsupdec (2.1, 4.0, "trv")), infsupdec (1.0, 4.0, "trv"))); %! assert (isequal (decorationpart (union (infsupdec (1.0, 1.0, "trv"), infsupdec (2.1, 4.0, "trv"))){1}, decorationpart (infsupdec (1.0, 4.0, "trv")){1})); %!test %! assert (isequal (union (infsupdec (1.0, 3.0, "trv"), infsupdec (empty, "trv")), infsupdec (1.0, 3.0, "trv"))); %! assert (isequal (decorationpart (union (infsupdec (1.0, 3.0, "trv"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (1.0, 3.0, "trv")){1})); %!test %! assert (isequal (union (infsupdec (empty, "trv"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (union (infsupdec (empty, "trv"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (union (infsupdec (1.0, 3.0, "trv"), infsupdec (entire, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (union (infsupdec (1.0, 3.0, "trv"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); interval-1.4.1/inst/test/c-xsc.tst0000644000175000017500000005232012657476046016453 0ustar oliveroliver## DO NOT EDIT! Generated automatically from test/c-xsc.itl ## by the Interval Testing Framework for IEEE 1788. ## https://github.com/nehmeier/ITF1788/tree/635bff73cc64ff8aab0ff2031ee8a53980be0115 ## ## Copyright 1990-2000 Institut fuer Angewandte Mathematik, ## Universitaet Karlsruhe, Germany ## 2000-2014 Wiss. Rechnen/Softwaretechnologie ## Universitaet Wuppertal, Germany ## Copyright 2015-2016 Oliver Heimlich ## ## Origin: unit tests in C-XSC version 2.5.4, Original license: LGPLv2+ ## Converted into portable ITL format by Oliver Heimlich. ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## %!#Test library imports %!#Arithmetic library imports pkg load interval %!#Preamble try; error ("__FILE__"); catch test (lasterror.stack.file, "quiet", stdout); end_try_catch; %!function assert_warn (observed_value, expected_value) %! if (not (isequal (observed_value, expected_value))) %! observed_expression = regexprep (argn(1, :), '\s+$', ''); %! expected_expression = regexprep (argn(2, :), '\s+$', ''); %! observed_as_char = disp (observed_value)(1 : end - 1); %! expected_as_char = disp(expected_value)(1 : end - 1); %! warning ([observed_expression, " != ", expected_expression, ... %! "\n ", observed_as_char, " != ", expected_as_char]); %! endif %!endfunction ## cxsc.intervaladdsub %!# Tests A+B, B+A, A-B, B-A, -A, +A %!test %! assert (isequal (infsup (10.0, 20.0) + infsup (13.0, 17.0), infsup (23.0, 37.0))); %! assert (isequal (plus (infsup (10.0, 20.0), infsup (13.0, 17.0)), infsup (23.0, 37.0))); %!test %! assert (isequal (infsup (13.0, 17.0) + infsup (10.0, 20.0), infsup (23.0, 37.0))); %! assert (isequal (plus (infsup (13.0, 17.0), infsup (10.0, 20.0)), infsup (23.0, 37.0))); %!test %! assert (isequal (infsup (10.0, 20.0) - infsup (13.0, 16.0), infsup (-6.0, 7.0))); %! assert (isequal (minus (infsup (10.0, 20.0), infsup (13.0, 16.0)), infsup (-6.0, 7.0))); %!test %! assert (isequal (infsup (13.0, 16.0) - infsup (10.0, 20.0), infsup (-7.0, 6.0))); %! assert (isequal (minus (infsup (13.0, 16.0), infsup (10.0, 20.0)), infsup (-7.0, 6.0))); %!test %! assert (isequal (-infsup (10.0, 20.0), infsup (-20.0, -10.0))); %! assert (isequal (uminus (infsup (10.0, 20.0)), infsup (-20.0, -10.0))); %!test %! assert (isequal (+infsup (10.0, 20.0), infsup (10.0, 20.0))); %! assert (isequal (uplus (infsup (10.0, 20.0)), infsup (10.0, 20.0))); ## cxsc.intervalmuldiv %!# Tests A*B, B*A, A/B, B/A %!test %! assert (isequal (infsup (1.0, 2.0) .* infsup (3.0, 4.0), infsup (3.0, 8.0))); %! assert (isequal (times (infsup (1.0, 2.0), infsup (3.0, 4.0)), infsup (3.0, 8.0))); %!test %! assert (isequal (infsup (-1.0, 2.0) .* infsup (3.0, 4.0), infsup (-4.0, 8.0))); %! assert (isequal (times (infsup (-1.0, 2.0), infsup (3.0, 4.0)), infsup (-4.0, 8.0))); %!test %! assert (isequal (infsup (-2.0, 1.0) .* infsup (3.0, 4.0), infsup (-8.0, 4.0))); %! assert (isequal (times (infsup (-2.0, 1.0), infsup (3.0, 4.0)), infsup (-8.0, 4.0))); %!test %! assert (isequal (infsup (-2.0, -1.0) .* infsup (3.0, 4.0), infsup (-8.0, -3.0))); %! assert (isequal (times (infsup (-2.0, -1.0), infsup (3.0, 4.0)), infsup (-8.0, -3.0))); %!test %! assert (isequal (infsup (1.0, 2.0) .* infsup (-3.0, 4.0), infsup (-6.0, 8.0))); %! assert (isequal (times (infsup (1.0, 2.0), infsup (-3.0, 4.0)), infsup (-6.0, 8.0))); %!test %! assert (isequal (infsup (-1.0, 2.0) .* infsup (-3.0, 4.0), infsup (-6.0, 8.0))); %! assert (isequal (times (infsup (-1.0, 2.0), infsup (-3.0, 4.0)), infsup (-6.0, 8.0))); %!test %! assert (isequal (infsup (-2.0, 1.0) .* infsup (-3.0, 4.0), infsup (-8.0, 6.0))); %! assert (isequal (times (infsup (-2.0, 1.0), infsup (-3.0, 4.0)), infsup (-8.0, 6.0))); %!test %! assert (isequal (infsup (-2.0, -1.0) .* infsup (-3.0, 4.0), infsup (-8.0, 6.0))); %! assert (isequal (times (infsup (-2.0, -1.0), infsup (-3.0, 4.0)), infsup (-8.0, 6.0))); %!test %! assert (isequal (infsup (1.0, 2.0) .* infsup (-4.0, 3.0), infsup (-8.0, 6.0))); %! assert (isequal (times (infsup (1.0, 2.0), infsup (-4.0, 3.0)), infsup (-8.0, 6.0))); %!test %! assert (isequal (infsup (-1.0, 2.0) .* infsup (-4.0, 3.0), infsup (-8.0, 6.0))); %! assert (isequal (times (infsup (-1.0, 2.0), infsup (-4.0, 3.0)), infsup (-8.0, 6.0))); %!test %! assert (isequal (infsup (-2.0, 1.0) .* infsup (-4.0, 3.0), infsup (-6.0, 8.0))); %! assert (isequal (times (infsup (-2.0, 1.0), infsup (-4.0, 3.0)), infsup (-6.0, 8.0))); %!test %! assert (isequal (infsup (-2.0, -1.0) .* infsup (-4.0, 3.0), infsup (-6.0, 8.0))); %! assert (isequal (times (infsup (-2.0, -1.0), infsup (-4.0, 3.0)), infsup (-6.0, 8.0))); %!test %! assert (isequal (infsup (1.0, 2.0) .* infsup (-4.0, -3.0), infsup (-8.0, -3.0))); %! assert (isequal (times (infsup (1.0, 2.0), infsup (-4.0, -3.0)), infsup (-8.0, -3.0))); %!test %! assert (isequal (infsup (-1.0, 2.0) .* infsup (-4.0, -3.0), infsup (-8.0, 4.0))); %! assert (isequal (times (infsup (-1.0, 2.0), infsup (-4.0, -3.0)), infsup (-8.0, 4.0))); %!test %! assert (isequal (infsup (-2.0, -1.0) .* infsup (-4.0, -3.0), infsup (3.0, 8.0))); %! assert (isequal (times (infsup (-2.0, -1.0), infsup (-4.0, -3.0)), infsup (3.0, 8.0))); %!test %! assert (isequal (infsup (1.0, 2.0) ./ infsup (4.0, 8.0), infsup (0.125, 0.5))); %! assert (isequal (rdivide (infsup (1.0, 2.0), infsup (4.0, 8.0)), infsup (0.125, 0.5))); %!test %! assert (isequal (infsup (-1.0, 2.0) ./ infsup (4.0, 8.0), infsup (-0.25, 0.5))); %! assert (isequal (rdivide (infsup (-1.0, 2.0), infsup (4.0, 8.0)), infsup (-0.25, 0.5))); %!test %! assert (isequal (infsup (-2.0, 1.0) ./ infsup (4.0, 8.0), infsup (-0.5, 0.25))); %! assert (isequal (rdivide (infsup (-2.0, 1.0), infsup (4.0, 8.0)), infsup (-0.5, 0.25))); %!test %! assert (isequal (infsup (-2.0, -1.0) ./ infsup (4.0, 8.0), infsup (-0.5, -0.125))); %! assert (isequal (rdivide (infsup (-2.0, -1.0), infsup (4.0, 8.0)), infsup (-0.5, -0.125))); %!test %! assert (isequal (infsup (1.0, 2.0) ./ infsup (-4.0, 8.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (1.0, 2.0), infsup (-4.0, 8.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-1.0, 2.0) ./ infsup (-4.0, 8.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-1.0, 2.0), infsup (-4.0, 8.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-2.0, 1.0) ./ infsup (-4.0, 8.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-2.0, 1.0), infsup (-4.0, 8.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-2.0, -1.0) ./ infsup (-4.0, 8.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-2.0, -1.0), infsup (-4.0, 8.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (1.0, 2.0) ./ infsup (-8.0, 4.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (1.0, 2.0), infsup (-8.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-1.0, 2.0) ./ infsup (-8.0, 4.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-1.0, 2.0), infsup (-8.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-2.0, 1.0) ./ infsup (-8.0, 4.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-2.0, 1.0), infsup (-8.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-2.0, -1.0) ./ infsup (-8.0, 4.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-2.0, -1.0), infsup (-8.0, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (1.0, 2.0) ./ infsup (-8.0, -4.0), infsup (-0.5, -0.125))); %! assert (isequal (rdivide (infsup (1.0, 2.0), infsup (-8.0, -4.0)), infsup (-0.5, -0.125))); %!test %! assert (isequal (infsup (-1.0, 2.0) ./ infsup (-8.0, -4.0), infsup (-0.5, 0.25))); %! assert (isequal (rdivide (infsup (-1.0, 2.0), infsup (-8.0, -4.0)), infsup (-0.5, 0.25))); %!test %! assert (isequal (infsup (-2.0, 1.0) ./ infsup (-8.0, -4.0), infsup (-0.25, 0.5))); %! assert (isequal (rdivide (infsup (-2.0, 1.0), infsup (-8.0, -4.0)), infsup (-0.25, 0.5))); %!test %! assert (isequal (infsup (-2.0, -1.0) ./ infsup (-8.0, -4.0), infsup (0.125, 0.5))); %! assert (isequal (rdivide (infsup (-2.0, -1.0), infsup (-8.0, -4.0)), infsup (0.125, 0.5))); ## cxsc.intervalsetops %!# Tests A|B, B|A, A&B, B&A %!test %! assert (isequal (union (infsup (-2.0, 2.0), infsup (-4.0, -3.0)), infsup (-4.0, 2.0))); %!test %! assert (isequal (union (infsup (-2.0, 2.0), infsup (-4.0, -1.0)), infsup (-4.0, 2.0))); %!test %! assert (isequal (union (infsup (-2.0, 2.0), infsup (-4.0, 4.0)), infsup (-4.0, 4.0))); %!test %! assert (isequal (union (infsup (-2.0, 2.0), infsup (-1.0, 1.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (union (infsup (-2.0, 2.0), infsup (1.0, 4.0)), infsup (-2.0, 4.0))); %!test %! assert (isequal (union (infsup (-2.0, 2.0), infsup (3.0, 4.0)), infsup (-2.0, 4.0))); %!test %! assert (isequal (union (infsup (-4.0, -3.0), infsup (-2.0, 2.0)), infsup (-4.0, 2.0))); %!test %! assert (isequal (union (infsup (-4.0, -1.0), infsup (-2.0, 2.0)), infsup (-4.0, 2.0))); %!test %! assert (isequal (union (infsup (-4.0, 4.0), infsup (-2.0, 2.0)), infsup (-4.0, 4.0))); %!test %! assert (isequal (union (infsup (-1.0, 1.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (union (infsup (1.0, 4.0), infsup (-2.0, 2.0)), infsup (-2.0, 4.0))); %!test %! assert (isequal (union (infsup (3.0, 4.0), infsup (-2.0, 2.0)), infsup (-2.0, 4.0))); %!test %! assert (isequal (intersect (infsup (-2.0, 2.0), infsup (-4.0, -3.0)), infsup)); %!test %! assert (isequal (intersect (infsup (-2.0, 2.0), infsup (-4.0, -1.0)), infsup (-2.0, -1.0))); %!test %! assert (isequal (intersect (infsup (-2.0, 2.0), infsup (-4.0, 4.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (intersect (infsup (-2.0, 2.0), infsup (-1.0, 1.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (intersect (infsup (-2.0, 2.0), infsup (1.0, 4.0)), infsup (1.0, 2.0))); %!test %! assert (isequal (intersect (infsup (-2.0, 2.0), infsup (3.0, 4.0)), infsup)); %!test %! assert (isequal (intersect (infsup (-4.0, -3.0), infsup (-2.0, 2.0)), infsup)); %!test %! assert (isequal (intersect (infsup (-4.0, -1.0), infsup (-2.0, 2.0)), infsup (-2.0, -1.0))); %!test %! assert (isequal (intersect (infsup (-4.0, 4.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (intersect (infsup (-1.0, 1.0), infsup (-2.0, 2.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (intersect (infsup (1.0, 4.0), infsup (-2.0, 2.0)), infsup (1.0, 2.0))); %!test %! assert (isequal (intersect (infsup (3.0, 4.0), infsup (-2.0, 2.0)), infsup)); ## cxsc.intervalmixsetops %!# Tests A|B, B|A, A&B, B&A, B is scalar-type %!test %! assert (isequal (union (infsup (-2.0, 2.0), infsup (-4.0, -4.0)), infsup (-4.0, 2.0))); %!test %! assert (isequal (union (infsup (-2.0, 2.0), infsup (1.0, 1.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (union (infsup (-2.0, 2.0), infsup (4.0, 4.0)), infsup (-2.0, 4.0))); %!test %! assert (isequal (union (infsup (-4.0, -4.0), infsup (-2.0, 2.0)), infsup (-4.0, 2.0))); %!test %! assert (isequal (union (infsup (1.0, 1.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (union (infsup (4.0, 4.0), infsup (-2.0, 2.0)), infsup (-2.0, 4.0))); %!test %! assert (isequal (intersect (infsup (-2.0, 2.0), infsup (-4.0, -4.0)), infsup)); %!test %! assert (isequal (intersect (infsup (-2.0, 2.0), infsup (1.0, 1.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (intersect (infsup (-2.0, 2.0), infsup (4.0, 4.0)), infsup)); %!test %! assert (isequal (intersect (infsup (-4.0, -4.0), infsup (-2.0, 2.0)), infsup)); %!test %! assert (isequal (intersect (infsup (1.0, 1.0), infsup (-2.0, 2.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (intersect (infsup (4.0, 4.0), infsup (-2.0, 2.0)), infsup)); ## cxsc.scalarmixsetops %!# Tests A|B, B|A, A and B are scalar-type %!test %! assert (isequal (union (infsup (-2.0, -2.0), infsup (-4.0, -4.0)), infsup (-4.0, -2.0))); %!test %! assert (isequal (union (infsup (-2.0, -2.0), infsup (-2.0, -2.0)), infsup (-2.0, -2.0))); %!test %! assert (isequal (union (infsup (-2.0, -2.0), infsup (2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (union (infsup (-4.0, -4.0), infsup (-2.0, -2.0)), infsup (-4.0, -2.0))); %!test %! assert (isequal (union (infsup (-2.0, -2.0), infsup (-2.0, -2.0)), infsup (-2.0, -2.0))); %!test %! assert (isequal (union (infsup (2.0, 2.0), infsup (-2.0, -2.0)), infsup (-2.0, 2.0))); ## cxsc.intervalsetcompops %!# Tests AB, A<=B, A>=B, A==B %!test %! assert (isequal (interior (infsup (-1.0, 2.0), infsup (-1.0, 2.0)), false)); %!test %! assert (interior (infsup (-2.0, 1.0), infsup (-3.0, 2.0))); %!test %! assert (isequal (interior (infsup (-2.0, 2.0), infsup (-1.0, 1.0)), false)); %!test %! assert (isequal (interior (infsup (-2.0, 2.0), infsup (-1.0, 2.0)), false)); %!test %! assert (isequal (interior (infsup (-2.0, 2.0), infsup (-2.0, 1.0)), false)); %!test %! assert (isequal (interior (infsup (-2.0, 2.0), infsup (-2.0, 3.0)), false)); %!test %! assert (isequal (interior (infsup (-2.0, 2.0), infsup (-3.0, 2.0)), false)); %!test %! assert (isequal (interior (infsup (-1.0, 2.0), infsup (-1.0, 2.0)), false)); %!test %! assert (isequal (interior (infsup (-3.0, 2.0), infsup (-2.0, 1.0)), false)); %!test %! assert (interior (infsup (-1.0, 1.0), infsup (-2.0, 2.0))); %!test %! assert (isequal (interior (infsup (-1.0, 2.0), infsup (-2.0, 2.0)), false)); %!test %! assert (isequal (interior (infsup (-2.0, 1.0), infsup (-2.0, 2.0)), false)); %!test %! assert (isequal (interior (infsup (-2.0, 3.0), infsup (-2.0, 2.0)), false)); %!test %! assert (isequal (interior (infsup (-3.0, 2.0), infsup (-2.0, 2.0)), false)); %!test %! assert (subset (infsup (-1.0, 2.0), infsup (-1.0, 2.0))); %!test %! assert (subset (infsup (-2.0, 1.0), infsup (-3.0, 2.0))); %!test %! assert (isequal (subset (infsup (-2.0, 2.0), infsup (-1.0, 1.0)), false)); %!test %! assert (isequal (subset (infsup (-2.0, 2.0), infsup (-1.0, 2.0)), false)); %!test %! assert (isequal (subset (infsup (-2.0, 2.0), infsup (-2.0, 1.0)), false)); %!test %! assert (subset (infsup (-2.0, 2.0), infsup (-2.0, 3.0))); %!test %! assert (subset (infsup (-2.0, 2.0), infsup (-3.0, 2.0))); %!test %! assert (isequal (subset (infsup (-3.0, 2.0), infsup (-2.0, 1.0)), false)); %!test %! assert (subset (infsup (-1.0, 1.0), infsup (-2.0, 2.0))); %!test %! assert (subset (infsup (-1.0, 2.0), infsup (-2.0, 2.0))); %!test %! assert (subset (infsup (-2.0, 1.0), infsup (-2.0, 2.0))); %!test %! assert (isequal (subset (infsup (-2.0, 3.0), infsup (-2.0, 2.0)), false)); %!test %! assert (isequal (subset (infsup (-3.0, 2.0), infsup (-2.0, 2.0)), false)); %!test %! assert (eq (infsup (-1.0, 2.0), infsup (-1.0, 2.0))); %! assert (infsup (-1.0, 2.0) == infsup (-1.0, 2.0)); %!test %! assert (isequal (eq (infsup (-2.0, 1.0), infsup (-3.0, 2.0)), false)); %! assert (isequal (infsup (-2.0, 1.0) == infsup (-3.0, 2.0), false)); %!test %! assert (isequal (eq (infsup (-2.0, 2.0), infsup (-1.0, 1.0)), false)); %! assert (isequal (infsup (-2.0, 2.0) == infsup (-1.0, 1.0), false)); %!test %! assert (isequal (eq (infsup (-2.0, 2.0), infsup (-1.0, 2.0)), false)); %! assert (isequal (infsup (-2.0, 2.0) == infsup (-1.0, 2.0), false)); %!test %! assert (isequal (eq (infsup (-2.0, 2.0), infsup (-2.0, 1.0)), false)); %! assert (isequal (infsup (-2.0, 2.0) == infsup (-2.0, 1.0), false)); %!test %! assert (isequal (eq (infsup (-2.0, 2.0), infsup (-2.0, 3.0)), false)); %! assert (isequal (infsup (-2.0, 2.0) == infsup (-2.0, 3.0), false)); %!test %! assert (isequal (eq (infsup (-2.0, 2.0), infsup (-3.0, 2.0)), false)); %! assert (isequal (infsup (-2.0, 2.0) == infsup (-3.0, 2.0), false)); ## cxsc.intervalscalarsetcompops %!# Tests AB, A<=B, A>=B, A==B, BA, B<=A, B>=A, B==A, where B is scalar %!test %! assert (isequal (interior (infsup (-1.0, 2.0), infsup (-2.0, -2.0)), false)); %!test %! assert (isequal (interior (infsup (-2.0, 2.0), infsup (-2.0, -2.0)), false)); %!test %! assert (isequal (interior (infsup (-2.0, 2.0), infsup (0.0, 0.0)), false)); %!test %! assert (isequal (interior (infsup (-2.0, 2.0), infsup (2.0, 2.0)), false)); %!test %! assert (isequal (interior (infsup (-2.0, 2.0), infsup (3.0, 3.0)), false)); %!test %! assert (isequal (interior (infsup (-1.0, -1.0), infsup (1.0, 1.0)), false)); %!test %! assert (isequal (interior (infsup (-1.0, -1.0), infsup (-1.0, -1.0)), false)); %!test %! assert (isequal (interior (infsup (-2.0, -2.0), infsup (-1.0, 2.0)), false)); %!test %! assert (isequal (interior (infsup (-2.0, -2.0), infsup (-2.0, 2.0)), false)); %!test %! assert (interior (infsup (0.0, 0.0), infsup (-2.0, 2.0))); %!test %! assert (isequal (interior (infsup (2.0, 2.0), infsup (-2.0, 2.0)), false)); %!test %! assert (isequal (interior (infsup (3.0, 3.0), infsup (-2.0, 2.0)), false)); %!test %! assert (isequal (interior (infsup (1.0, 1.0), infsup (-1.0, -1.0)), false)); %!test %! assert (isequal (interior (infsup (-1.0, -1.0), infsup (-1.0, -1.0)), false)); %!test %! assert (isequal (subset (infsup (-1.0, 2.0), infsup (-2.0, -2.0)), false)); %!test %! assert (isequal (subset (infsup (-2.0, 2.0), infsup (-2.0, -2.0)), false)); %!test %! assert (isequal (subset (infsup (-2.0, 2.0), infsup (0.0, 0.0)), false)); %!test %! assert (isequal (subset (infsup (-2.0, 2.0), infsup (2.0, 2.0)), false)); %!test %! assert (isequal (subset (infsup (-2.0, 2.0), infsup (3.0, 3.0)), false)); %!test %! assert (isequal (subset (infsup (-1.0, -1.0), infsup (1.0, 1.0)), false)); %!test %! assert (subset (infsup (-1.0, -1.0), infsup (-1.0, -1.0))); %!test %! assert (isequal (subset (infsup (-2.0, -2.0), infsup (-1.0, 2.0)), false)); %!test %! assert (subset (infsup (-2.0, -2.0), infsup (-2.0, 2.0))); %!test %! assert (subset (infsup (0.0, 0.0), infsup (-2.0, 2.0))); %!test %! assert (subset (infsup (2.0, 2.0), infsup (-2.0, 2.0))); %!test %! assert (isequal (subset (infsup (3.0, 3.0), infsup (-2.0, 2.0)), false)); %!test %! assert (isequal (subset (infsup (1.0, 1.0), infsup (-1.0, -1.0)), false)); %!test %! assert (subset (infsup (-1.0, -1.0), infsup (-1.0, -1.0))); %!test %! assert (isequal (eq (infsup (-1.0, 2.0), infsup (-2.0, -2.0)), false)); %! assert (isequal (infsup (-1.0, 2.0) == infsup (-2.0, -2.0), false)); %!test %! assert (isequal (eq (infsup (-2.0, 2.0), infsup (-2.0, -2.0)), false)); %! assert (isequal (infsup (-2.0, 2.0) == infsup (-2.0, -2.0), false)); %!test %! assert (isequal (eq (infsup (-2.0, 2.0), infsup (0.0, 0.0)), false)); %! assert (isequal (infsup (-2.0, 2.0) == infsup (0.0, 0.0), false)); %!test %! assert (isequal (eq (infsup (-2.0, 2.0), infsup (2.0, 2.0)), false)); %! assert (isequal (infsup (-2.0, 2.0) == infsup (2.0, 2.0), false)); %!test %! assert (isequal (eq (infsup (-2.0, 2.0), infsup (3.0, 3.0)), false)); %! assert (isequal (infsup (-2.0, 2.0) == infsup (3.0, 3.0), false)); %!test %! assert (isequal (eq (infsup (-1.0, -1.0), infsup (1.0, 1.0)), false)); %! assert (isequal (infsup (-1.0, -1.0) == infsup (1.0, 1.0), false)); %!test %! assert (eq (infsup (-1.0, -1.0), infsup (-1.0, -1.0))); %! assert (infsup (-1.0, -1.0) == infsup (-1.0, -1.0)); ## cxsc.intervalstdfunc %!test %! assert (isequal (pown (infsup (11.0, 11.0), 2), infsup (121.0, 121.0))); %! assert (isequal (infsup (11.0, 11.0) .^ 2, infsup (121.0, 121.0))); %! assert (isequal (power (infsup (11.0, 11.0), 2), infsup (121.0, 121.0))); %! assert (isequal (infsup (11.0, 11.0) ^ 2, infsup (121.0, 121.0))); %! assert (isequal (mpower (infsup (11.0, 11.0), 2), infsup (121.0, 121.0))); %!test %! assert (isequal (pown (infsup (0.0, 0.0), 2), infsup (0.0, 0.0))); %! assert (isequal (infsup (0.0, 0.0) .^ 2, infsup (0.0, 0.0))); %! assert (isequal (power (infsup (0.0, 0.0), 2), infsup (0.0, 0.0))); %! assert (isequal (infsup (0.0, 0.0) ^ 2, infsup (0.0, 0.0))); %! assert (isequal (mpower (infsup (0.0, 0.0), 2), infsup (0.0, 0.0))); %!test %! assert (isequal (pown (infsup (-9.0, -9.0), 2), infsup (81.0, 81.0))); %! assert (isequal (infsup (-9.0, -9.0) .^ 2, infsup (81.0, 81.0))); %! assert (isequal (power (infsup (-9.0, -9.0), 2), infsup (81.0, 81.0))); %! assert (isequal (infsup (-9.0, -9.0) ^ 2, infsup (81.0, 81.0))); %! assert (isequal (mpower (infsup (-9.0, -9.0), 2), infsup (81.0, 81.0))); %!test %! assert (isequal (realsqrt (infsup (121.0, 121.0)), infsup (11.0, 11.0))); %!test %! assert (isequal (realsqrt (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (realsqrt (infsup (81.0, 81.0)), infsup (9.0, 9.0))); %!test %! assert (isequal (nthroot (infsup (27.0, 27.0), 3), infsup (3.0, 3.0))); %!test %! assert (isequal (nthroot (infsup (0.0, 0.0), 4), infsup (0.0, 0.0))); %!test %! assert (isequal (nthroot (infsup (1024.0, 1024.0), 10), infsup (2.0, 2.0))); %!test %! assert (isequal (pow (infsup (2.0, 2.0), infsup (2.0, 2.0)), infsup (4.0, 4.0))); %!test %! assert (isequal (pow (infsup (4.0, 4.0), infsup (5.0, 5.0)), infsup (1024.0, 1024.0))); %!# Negativ geht noch nicht %!test %! assert (isequal (pow (infsup (2.0, 2.0), infsup (3.0, 3.0)), infsup (8.0, 8.0))); interval-1.4.1/inst/test/libieeep1788_tests_rev.tst0000644000175000017500000044300612657476047021650 0ustar oliveroliver## DO NOT EDIT! Generated automatically from test/libieeep1788_tests_rev.itl ## by the Interval Testing Framework for IEEE 1788. ## https://github.com/nehmeier/ITF1788/tree/635bff73cc64ff8aab0ff2031ee8a53980be0115 ## ## Copyright 2013-2015 Marco Nehmeier (nehmeier@informatik.uni-wuerzburg.de) ## Copyright 2015-2016 Oliver Heimlich ## ## Original author: Marco Nehmeier (unit tests in libieeep1788, ## original license: Apache License 2.0) ## Converted into portable ITL format by Oliver Heimlich with minor corrections. ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## %!#Test library imports %!#Arithmetic library imports pkg load interval %!#Preamble try; error ("__FILE__"); catch test (lasterror.stack.file, "quiet", stdout); end_try_catch; %!function assert_warn (observed_value, expected_value) %! if (not (isequal (observed_value, expected_value))) %! observed_expression = regexprep (argn(1, :), '\s+$', ''); %! expected_expression = regexprep (argn(2, :), '\s+$', ''); %! observed_as_char = disp (observed_value)(1 : end - 1); %! expected_as_char = disp(expected_value)(1 : end - 1); %! warning ([observed_expression, " != ", expected_expression, ... %! "\n ", observed_as_char, " != ", expected_as_char]); %! endif %!endfunction ## minimal_sqrRev_test %!test %! assert (isequal (sqrrev (infsup), infsup)); %!test %! assert (isequal (sqrrev (infsup (-10.0, -1.0)), infsup)); %!test %! assert (isequal (sqrrev (infsup (0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (sqrrev (infsup (0.0, 1.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sqrrev (infsup (-0.5, 1.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sqrrev (infsup (-1000.0, 1.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sqrrev (infsup (0.0, 25.0)), infsup (-5.0, 5.0))); %!test %! assert (isequal (sqrrev (infsup (-1.0, 25.0)), infsup (-5.0, 5.0))); %!test %! assert (isequal (sqrrev (infsup (1.000000000000000021e-02, 1.000000000000000194e-02)), infsup (-1.000000000000000194e-01, 1.000000000000000194e-01))); %!test %! assert (isequal (sqrrev (infsup (0.0, 3.999999999999986233e+00)), infsup (-1.999999999999996669e+00, 1.999999999999996669e+00))); ## minimal_sqrRevBin_test %!test %! assert (isequal (sqrrev (infsup, infsup (-5.0, 1.0)), infsup)); %!test %! assert (isequal (sqrrev (infsup (-10.0, -1.0), infsup (-5.0, 1.0)), infsup)); %!test %! assert (isequal (sqrrev (infsup (0.0, inf), infsup (-5.0, 1.0)), infsup (-5.0, 1.0))); %!test %! assert (isequal (sqrrev (infsup (0.0, 1.0), infsup (-0.1, 1.0)), infsup (-0.1, 1.0))); %!test %! assert (isequal (sqrrev (infsup (-0.5, 1.0), infsup (-0.1, 1.0)), infsup (-0.1, 1.0))); %!test %! assert (isequal (sqrrev (infsup (-1000.0, 1.0), infsup (-0.1, 1.0)), infsup (-0.1, 1.0))); %!test %! assert (isequal (sqrrev (infsup (0.0, 25.0), infsup (-4.1, 6.0)), infsup (-4.1, 5.0))); %!test %! assert (isequal (sqrrev (infsup (-1.0, 25.0), infsup (-4.1, 7.0)), infsup (-4.1, 5.0))); %!test %! assert (isequal (sqrrev (infsup (1.0, 25.0), infsup (0.0, 7.0)), infsup (1.0, 5.0))); %!test %! assert (isequal (sqrrev (infsup (1.000000000000000021e-02, 1.000000000000000194e-02), infsup (-0.1, inf)), infsup (-0.1, 1.000000000000000194e-01))); %!test %! assert (isequal (sqrrev (infsup (0.0, 3.999999999999986233e+00), infsup (-0.1, inf)), infsup (-0.1, 1.999999999999996669e+00))); ## minimal_sqrRev_dec_test %!test %! assert (isequal (sqrrev (infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (sqrrev (infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (sqrrev (infsupdec (-10.0, -1.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (sqrrev (infsupdec (-10.0, -1.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (sqrrev (infsupdec (0.0, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (sqrrev (infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (sqrrev (infsupdec (0.0, 1.0, "def")), infsupdec (-1.0, 1.0, "trv"))); %! assert (isequal (decorationpart (sqrrev (infsupdec (0.0, 1.0, "def"))){1}, decorationpart (infsupdec (-1.0, 1.0, "trv")){1})); %!test %! assert (isequal (sqrrev (infsupdec (-0.5, 1.0, "dac")), infsupdec (-1.0, 1.0, "trv"))); %! assert (isequal (decorationpart (sqrrev (infsupdec (-0.5, 1.0, "dac"))){1}, decorationpart (infsupdec (-1.0, 1.0, "trv")){1})); %!test %! assert (isequal (sqrrev (infsupdec (-1000.0, 1.0, "com")), infsupdec (-1.0, 1.0, "trv"))); %! assert (isequal (decorationpart (sqrrev (infsupdec (-1000.0, 1.0, "com"))){1}, decorationpart (infsupdec (-1.0, 1.0, "trv")){1})); %!test %! assert (isequal (sqrrev (infsupdec (0.0, 25.0, "def")), infsupdec (-5.0, 5.0, "trv"))); %! assert (isequal (decorationpart (sqrrev (infsupdec (0.0, 25.0, "def"))){1}, decorationpart (infsupdec (-5.0, 5.0, "trv")){1})); %!test %! assert (isequal (sqrrev (infsupdec (-1.0, 25.0, "dac")), infsupdec (-5.0, 5.0, "trv"))); %! assert (isequal (decorationpart (sqrrev (infsupdec (-1.0, 25.0, "dac"))){1}, decorationpart (infsupdec (-5.0, 5.0, "trv")){1})); %!test %! assert (isequal (sqrrev (infsupdec (1.000000000000000021e-02, 1.000000000000000194e-02, "com")), infsupdec (-1.000000000000000194e-01, 1.000000000000000194e-01, "trv"))); %! assert (isequal (decorationpart (sqrrev (infsupdec (1.000000000000000021e-02, 1.000000000000000194e-02, "com"))){1}, decorationpart (infsupdec (-1.000000000000000194e-01, 1.000000000000000194e-01, "trv")){1})); %!test %! assert (isequal (sqrrev (infsupdec (0.0, 3.999999999999986233e+00, "def")), infsupdec (-1.999999999999996669e+00, 1.999999999999996669e+00, "trv"))); %! assert (isequal (decorationpart (sqrrev (infsupdec (0.0, 3.999999999999986233e+00, "def"))){1}, decorationpart (infsupdec (-1.999999999999996669e+00, 1.999999999999996669e+00, "trv")){1})); ## minimal_sqrRev_dec_bin_test %!test %! assert (isequal (sqrrev (infsupdec (empty, "trv"), infsupdec (-5.0, 1.0, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (sqrrev (infsupdec (empty, "trv"), infsupdec (-5.0, 1.0, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (sqrrev (infsupdec (-10.0, -1.0, "com"), infsupdec (-5.0, 1.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (sqrrev (infsupdec (-10.0, -1.0, "com"), infsupdec (-5.0, 1.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (sqrrev (infsupdec (0.0, inf, "def"), infsupdec (-5.0, 1.0, "dac")), infsupdec (-5.0, 1.0, "trv"))); %! assert (isequal (decorationpart (sqrrev (infsupdec (0.0, inf, "def"), infsupdec (-5.0, 1.0, "dac"))){1}, decorationpart (infsupdec (-5.0, 1.0, "trv")){1})); %!test %! assert (isequal (sqrrev (infsupdec (0.0, 1.0, "dac"), infsupdec (-0.1, 1.0, "def")), infsupdec (-0.1, 1.0, "trv"))); %! assert (isequal (decorationpart (sqrrev (infsupdec (0.0, 1.0, "dac"), infsupdec (-0.1, 1.0, "def"))){1}, decorationpart (infsupdec (-0.1, 1.0, "trv")){1})); %!test %! assert (isequal (sqrrev (infsupdec (-0.5, 1.0, "def"), infsupdec (-0.1, 1.0, "dac")), infsupdec (-0.1, 1.0, "trv"))); %! assert (isequal (decorationpart (sqrrev (infsupdec (-0.5, 1.0, "def"), infsupdec (-0.1, 1.0, "dac"))){1}, decorationpart (infsupdec (-0.1, 1.0, "trv")){1})); %!test %! assert (isequal (sqrrev (infsupdec (-1000.0, 1.0, "com"), infsupdec (-0.1, 1.0, "def")), infsupdec (-0.1, 1.0, "trv"))); %! assert (isequal (decorationpart (sqrrev (infsupdec (-1000.0, 1.0, "com"), infsupdec (-0.1, 1.0, "def"))){1}, decorationpart (infsupdec (-0.1, 1.0, "trv")){1})); %!test %! assert (isequal (sqrrev (infsupdec (0.0, 25.0, "def"), infsupdec (-4.1, 6.0, "com")), infsupdec (-4.1, 5.0, "trv"))); %! assert (isequal (decorationpart (sqrrev (infsupdec (0.0, 25.0, "def"), infsupdec (-4.1, 6.0, "com"))){1}, decorationpart (infsupdec (-4.1, 5.0, "trv")){1})); %!test %! assert (isequal (sqrrev (infsupdec (-1.0, 25.0, "dac"), infsupdec (-4.1, 7.0, "def")), infsupdec (-4.1, 5.0, "trv"))); %! assert (isequal (decorationpart (sqrrev (infsupdec (-1.0, 25.0, "dac"), infsupdec (-4.1, 7.0, "def"))){1}, decorationpart (infsupdec (-4.1, 5.0, "trv")){1})); %!test %! assert (isequal (sqrrev (infsupdec (1.0, 25.0, "dac"), infsupdec (0.0, 7.0, "def")), infsupdec (1.0, 5.0, "trv"))); %! assert (isequal (decorationpart (sqrrev (infsupdec (1.0, 25.0, "dac"), infsupdec (0.0, 7.0, "def"))){1}, decorationpart (infsupdec (1.0, 5.0, "trv")){1})); %!test %! assert (isequal (sqrrev (infsupdec (1.000000000000000021e-02, 1.000000000000000194e-02, "def"), infsupdec (-0.1, inf, "dac")), infsupdec (-0.1, 1.000000000000000194e-01, "trv"))); %! assert (isequal (decorationpart (sqrrev (infsupdec (1.000000000000000021e-02, 1.000000000000000194e-02, "def"), infsupdec (-0.1, inf, "dac"))){1}, decorationpart (infsupdec (-0.1, 1.000000000000000194e-01, "trv")){1})); %!test %! assert (isequal (sqrrev (infsupdec (0.0, 3.999999999999986233e+00, "dac"), infsupdec (-0.1, inf, "dac")), infsupdec (-0.1, 1.999999999999996669e+00, "trv"))); %! assert (isequal (decorationpart (sqrrev (infsupdec (0.0, 3.999999999999986233e+00, "dac"), infsupdec (-0.1, inf, "dac"))){1}, decorationpart (infsupdec (-0.1, 1.999999999999996669e+00, "trv")){1})); ## minimal_absRev_test %!test %! assert (isequal (absrev (infsup), infsup)); %!test %! assert (isequal (absrev (infsup (-1.1, -0.4)), infsup)); %!test %! assert (isequal (absrev (infsup (0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (absrev (infsup (1.1, 2.1)), infsup (-2.1, 2.1))); %!test %! assert (isequal (absrev (infsup (-1.1, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (absrev (infsup (-1.1, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (absrev (infsup (-1.9, 0.2)), infsup (-0.2, 0.2))); %!test %! assert (isequal (absrev (infsup (0.0, 0.2)), infsup (-0.2, 0.2))); %!test %! assert (isequal (absrev (infsup (-1.5, inf)), infsup (-inf, inf))); ## minimal_absRevBin_test %!test %! assert (isequal (absrev (infsup, infsup (-1.1, 5.0)), infsup)); %!test %! assert (isequal (absrev (infsup (-1.1, -0.4), infsup (-1.1, 5.0)), infsup)); %!test %! assert (isequal (absrev (infsup (0.0, inf), infsup (-1.1, 5.0)), infsup (-1.1, 5.0))); %!test %! assert (isequal (absrev (infsup (1.1, 2.1), infsup (-1.0, 5.0)), infsup (1.1, 2.1))); %!test %! assert (isequal (absrev (infsup (-1.1, 2.0), infsup (-1.1, 5.0)), infsup (-1.1, 2.0))); %!test %! assert (isequal (absrev (infsup (-1.1, 0.0), infsup (-1.1, 5.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (absrev (infsup (-1.9, 0.2), infsup (-1.1, 5.0)), infsup (-0.2, 0.2))); ## minimal_absRev_dec_test %!test %! assert (isequal (absrev (infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (absrev (infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (absrev (infsupdec (-1.1, -0.4, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (absrev (infsupdec (-1.1, -0.4, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (absrev (infsupdec (0.0, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (absrev (infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (absrev (infsupdec (1.1, 2.1, "com")), infsupdec (-2.1, 2.1, "trv"))); %! assert (isequal (decorationpart (absrev (infsupdec (1.1, 2.1, "com"))){1}, decorationpart (infsupdec (-2.1, 2.1, "trv")){1})); %!test %! assert (isequal (absrev (infsupdec (-1.1, 2.0, "def")), infsupdec (-2.0, 2.0, "trv"))); %! assert (isequal (decorationpart (absrev (infsupdec (-1.1, 2.0, "def"))){1}, decorationpart (infsupdec (-2.0, 2.0, "trv")){1})); %!test %! assert (isequal (absrev (infsupdec (-1.1, 0.0, "dac")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (absrev (infsupdec (-1.1, 0.0, "dac"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (absrev (infsupdec (-1.9, 0.2, "com")), infsupdec (-0.2, 0.2, "trv"))); %! assert (isequal (decorationpart (absrev (infsupdec (-1.9, 0.2, "com"))){1}, decorationpart (infsupdec (-0.2, 0.2, "trv")){1})); %!test %! assert (isequal (absrev (infsupdec (0.0, 0.2, "def")), infsupdec (-0.2, 0.2, "trv"))); %! assert (isequal (decorationpart (absrev (infsupdec (0.0, 0.2, "def"))){1}, decorationpart (infsupdec (-0.2, 0.2, "trv")){1})); %!test %! assert (isequal (absrev (infsupdec (-1.5, inf, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (absrev (infsupdec (-1.5, inf, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); ## minimal_absRev_dec_bin_test %!test %! assert (isequal (absrev (infsupdec (empty, "trv"), infsupdec (-1.1, 5.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (absrev (infsupdec (empty, "trv"), infsupdec (-1.1, 5.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (absrev (infsupdec (-1.1, -0.4, "dac"), infsupdec (-1.1, 5.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (absrev (infsupdec (-1.1, -0.4, "dac"), infsupdec (-1.1, 5.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (absrev (infsupdec (0.0, inf, "def"), infsupdec (-1.1, 5.0, "def")), infsupdec (-1.1, 5.0, "trv"))); %! assert (isequal (decorationpart (absrev (infsupdec (0.0, inf, "def"), infsupdec (-1.1, 5.0, "def"))){1}, decorationpart (infsupdec (-1.1, 5.0, "trv")){1})); %!test %! assert (isequal (absrev (infsupdec (1.1, 2.1, "dac"), infsupdec (-1.0, 5.0, "def")), infsupdec (1.1, 2.1, "trv"))); %! assert (isequal (decorationpart (absrev (infsupdec (1.1, 2.1, "dac"), infsupdec (-1.0, 5.0, "def"))){1}, decorationpart (infsupdec (1.1, 2.1, "trv")){1})); %!test %! assert (isequal (absrev (infsupdec (-1.1, 2.0, "com"), infsupdec (-1.1, 5.0, "def")), infsupdec (-1.1, 2.0, "trv"))); %! assert (isequal (decorationpart (absrev (infsupdec (-1.1, 2.0, "com"), infsupdec (-1.1, 5.0, "def"))){1}, decorationpart (infsupdec (-1.1, 2.0, "trv")){1})); %!test %! assert (isequal (absrev (infsupdec (-1.1, 0.0, "def"), infsupdec (-1.1, 5.0, "def")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (absrev (infsupdec (-1.1, 0.0, "def"), infsupdec (-1.1, 5.0, "def"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (absrev (infsupdec (-1.9, 0.2, "dac"), infsupdec (-1.1, 5.0, "def")), infsupdec (-0.2, 0.2, "trv"))); %! assert (isequal (decorationpart (absrev (infsupdec (-1.9, 0.2, "dac"), infsupdec (-1.1, 5.0, "def"))){1}, decorationpart (infsupdec (-0.2, 0.2, "trv")){1})); ## minimal_pownRev_test %!test %! assert (isequal (pownrev (infsup, 0), infsup)); %!test %! assert (isequal (pownrev (infsup (1.0, 1.0), 0), infsup (-inf, inf))); %!test %! assert (isequal (pownrev (infsup (-1.0, 5.0), 0), infsup (-inf, inf))); %!test %! assert (isequal (pownrev (infsup (-1.0, 0.0), 0), infsup)); %!test %! assert (isequal (pownrev (infsup (-1.0, -0.0), 0), infsup)); %!test %! assert (isequal (pownrev (infsup (1.1, 10.0), 0), infsup)); %!test %! assert (isequal (pownrev (infsup, 1), infsup)); %!test %! assert (isequal (pownrev (infsup (-inf, inf), 1), infsup (-inf, inf))); %!test %! assert (isequal (pownrev (infsup (0.0, 0.0), 1), infsup (0.0, 0.0))); %!test %! assert (isequal (pownrev (infsup (-0.0, -0.0), 1), infsup (0.0, 0.0))); %!test %! assert (isequal (pownrev (infsup (13.1, 13.1), 1), infsup (13.1, 13.1))); %!test %! assert (isequal (pownrev (infsup (-7451.145, -7451.145), 1), infsup (-7451.145, -7451.145))); %!test %! assert (isequal (pownrev (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), 1), infsup (1.797693134862315708e+308, 1.797693134862315708e+308))); %!test %! assert (isequal (pownrev (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308), 1), infsup (-1.797693134862315708e+308, -1.797693134862315708e+308))); %!test %! assert (isequal (pownrev (infsup (0.0, inf), 1), infsup (0.0, inf))); %!test %! assert (isequal (pownrev (infsup (-0.0, inf), 1), infsup (0.0, inf))); %!test %! assert (isequal (pownrev (infsup (-inf, 0.0), 1), infsup (-inf, 0.0))); %!test %! assert (isequal (pownrev (infsup (-inf, -0.0), 1), infsup (-inf, 0.0))); %!test %! assert (isequal (pownrev (infsup (-324.3, 2.5), 1), infsup (-324.3, 2.5))); %!test %! assert (isequal (pownrev (infsup (0.01, 2.33), 1), infsup (0.01, 2.33))); %!test %! assert (isequal (pownrev (infsup (-1.9, -0.33), 1), infsup (-1.9, -0.33))); %!test %! assert (isequal (pownrev (infsup, 2), infsup)); %!test %! assert (isequal (pownrev (infsup (-5.0, -1.0), 2), infsup)); %!test %! assert (isequal (pownrev (infsup (0.0, inf), 2), infsup (-inf, inf))); %!test %! assert (isequal (pownrev (infsup (-0.0, inf), 2), infsup (-inf, inf))); %!test %! assert (isequal (pownrev (infsup (0.0, 0.0), 2), infsup (0.0, 0.0))); %!test %! assert (isequal (pownrev (infsup (-0.0, -0.0), 2), infsup (0.0, 0.0))); %!test %! assert (isequal (pownrev (infsup (1.716099999999999852e+02, 1.716100000000000136e+02), 2), infsup (-1.310000000000000142e+01, 1.310000000000000142e+01))); %!test %! assert (isequal (pownrev (infsup (5.551956181102500111e+07, 5.551956181102500856e+07), 2), infsup (-7.451145000000001346e+03, 7.451145000000001346e+03))); %!test %! assert (isequal (pownrev (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), 2), infsup (-1.340780792994259710e+154, 1.340780792994259710e+154))); %!test %! assert (isequal (pownrev (infsup (0.0, 1.051704900000000198e+05), 2), infsup (-3.243000000000000682e+02, 3.243000000000000682e+02))); %!test %! assert (isequal (pownrev (infsup (-0.0, 1.051704900000000198e+05), 2), infsup (-3.243000000000000682e+02, 3.243000000000000682e+02))); %!test %! assert (isequal (pownrev (infsup (9.999999999999999124e-05, 5.428900000000000503e+00), 2), infsup (-2.330000000000000515e+00, 2.330000000000000515e+00))); %!test %! assert (isequal (pownrev (infsup (1.088999999999999968e-01, 3.609999999999999876e+00), 2), infsup (-1.900000000000000133e+00, 1.900000000000000133e+00))); %!test %! assert (isequal (pownrev (infsup, 8), infsup)); %!test %! assert (isequal (pownrev (infsup (-inf, inf), 8), infsup (-inf, inf))); %!test %! assert (isequal (pownrev (infsup (0.0, inf), 8), infsup (-inf, inf))); %!test %! assert (isequal (pownrev (infsup (-0.0, inf), 8), infsup (-inf, inf))); %!test %! assert (isequal (pownrev (infsup (0.0, 0.0), 8), infsup (0.0, 0.0))); %!test %! assert (isequal (pownrev (infsup (-0.0, -0.0), 8), infsup (0.0, 0.0))); %!test %! assert (isequal (pownrev (infsup (8.673020346900621653e+08, 8.673020346900622845e+08), 8), infsup (-1.310000000000000142e+01, 1.310000000000000142e+01))); %!test %! assert (isequal (pownrev (infsup (9.501323805961964567e+30, 9.501323805961965692e+30), 8), infsup (-7.451145000000001346e+03, 7.451145000000001346e+03))); %!test %! assert (isequal (pownrev (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), 8), infsup (-3.402823669209384635e+38, 3.402823669209384635e+38))); %!test %! assert (isequal (pownrev (infsup (0.0, 1.223420037986718843e+20), 8), infsup (-3.243000000000000682e+02, 3.243000000000000682e+02))); %!test %! assert (isequal (pownrev (infsup (-0.0, 1.223420037986718843e+20), 8), infsup (-3.243000000000000682e+02, 3.243000000000000682e+02))); %!test %! assert (isequal (pownrev (infsup (1.000000000000000102e-16, 8.686550888106663706e+02), 8), infsup (-2.330000000000000515e+00, 2.330000000000000515e+00))); %!test %! assert (isequal (pownrev (infsup (1.406408618241000491e-04, 1.698356304099999647e+02), 8), infsup (-1.900000000000000133e+00, 1.900000000000000133e+00))); %!test %! assert (isequal (pownrev (infsup, 3), infsup)); %!test %! assert (isequal (pownrev (infsup (-inf, inf), 3), infsup (-inf, inf))); %!test %! assert (isequal (pownrev (infsup (0.0, 0.0), 3), infsup (0.0, 0.0))); %!test %! assert (isequal (pownrev (infsup (-0.0, -0.0), 3), infsup (0.0, 0.0))); %!test %! assert (isequal (pownrev (infsup (2.248090999999999440e+03, 2.248090999999999894e+03), 3), infsup (1.309999999999999787e+01, 1.310000000000000142e+01))); %!test %! assert (isequal (pownrev (infsup (-4.136843053904099731e+11, -4.136843053904099121e+11), 3), infsup (-7.451145000000001346e+03, -7.451144999999999527e+03))); %!test %! assert (isequal (pownrev (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), 3), infsup (5.643803094122361304e+102, 5.643803094122362298e+102))); %!test %! assert (isequal (pownrev (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308), 3), infsup (-5.643803094122362298e+102, -5.643803094122361304e+102))); %!test %! assert (isequal (pownrev (infsup (0.0, inf), 3), infsup (0.0, inf))); %!test %! assert (isequal (pownrev (infsup (-0.0, inf), 3), infsup (0.0, inf))); %!test %! assert (isequal (pownrev (infsup (-inf, 0.0), 3), infsup (-inf, 0.0))); %!test %! assert (isequal (pownrev (infsup (-inf, -0.0), 3), infsup (-inf, 0.0))); %!test %! assert (isequal (pownrev (infsup (-3.410678990700000525e+07, 1.562500000000000000e+01), 3), infsup (-3.243000000000000682e+02, 2.500000000000000000e+00))); %!test %! assert (isequal (pownrev (infsup (9.999999999999999547e-07, 1.264933700000000272e+01), 3), infsup (9.999999999999998473e-03, 2.330000000000000515e+00))); %!test %! assert (isequal (pownrev (infsup (-6.858999999999999098e+00, -3.593700000000000366e-02), 3), infsup (-1.900000000000000133e+00, -3.299999999999999600e-01))); %!test %! assert (isequal (pownrev (infsup, 7), infsup)); %!test %! assert (isequal (pownrev (infsup (-inf, inf), 7), infsup (-inf, inf))); %!test %! assert (isequal (pownrev (infsup (0.0, 0.0), 7), infsup (0.0, 0.0))); %!test %! assert (isequal (pownrev (infsup (-0.0, -0.0), 7), infsup (0.0, 0.0))); %!test %! assert (isequal (pownrev (infsup (6.620626219008108228e+07, 6.620626219008108974e+07), 7), infsup (1.309999999999999787e+01, 1.310000000000000142e+01))); %!test %! assert (isequal (pownrev (infsup (-1.275149497957960280e+27, -1.275149497957960005e+27), 7), infsup (-7.451145000000001346e+03, -7.451144999999999527e+03))); %!test %! assert (isequal (pownrev (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), 7), infsup (1.087396515837748951e+44, 1.087396515837749149e+44))); %!test %! assert (isequal (pownrev (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308), 7), infsup (-1.087396515837749149e+44, -1.087396515837748951e+44))); %!test %! assert (isequal (pownrev (infsup (0.0, inf), 7), infsup (0.0, inf))); %!test %! assert (isequal (pownrev (infsup (-0.0, inf), 7), infsup (0.0, inf))); %!test %! assert (isequal (pownrev (infsup (-inf, 0.0), 7), infsup (-inf, 0.0))); %!test %! assert (isequal (pownrev (infsup (-inf, -0.0), 7), infsup (-inf, 0.0))); %!test %! assert (isequal (pownrev (infsup (-3.772494720896449920e+17, 6.103515625000000000e+02), 7), infsup (-3.243000000000000682e+02, 2.500000000000000000e+00))); %!test %! assert (isequal (pownrev (infsup (9.999999999999999988e-15, 3.728133428371958757e+02), 7), infsup (9.999999999999998473e-03, 2.330000000000000515e+00))); %!test %! assert (isequal (pownrev (infsup (-8.938717389999997920e+01, -4.261844297700001028e-04), 7), infsup (-1.900000000000000133e+00, -3.299999999999999600e-01))); %!test %! assert (isequal (pownrev (infsup, -2), infsup)); %!test %! assert (isequal (pownrev (infsup (0.0, inf), -2), infsup (-inf, inf))); %!test %! assert (isequal (pownrev (infsup (-0.0, inf), -2), infsup (-inf, inf))); %!test %! assert (isequal (pownrev (infsup (0.0, 0.0), -2), infsup)); %!test %! assert (isequal (pownrev (infsup (-0.0, -0.0), -2), infsup)); %!test %! assert (isequal (pownrev (infsup (-10.0, 0.0), -2), infsup)); %!test %! assert (isequal (pownrev (infsup (-10.0, -0.0), -2), infsup)); %!test %! assert (isequal (pownrev (infsup (5.827166249053085390e-03, 5.827166249053086257e-03), -2), infsup (-1.310000000000000142e+01, 1.310000000000000142e+01))); %!test %! assert (isequal (pownrev (infsup (1.801166953377180740e-08, 1.801166953377181071e-08), -2), infsup (-7.451145000000001346e+03, 7.451145000000001346e+03))); %!test %! assert (isequal (pownrev (infsup (0.000000000000000000e+00, 4.940656458412465442e-324), -2), infsup (-inf, inf))); %!test %! assert (isequal (pownrev (infsup (9.508370646556841917e-06, inf), -2), infsup (-3.243000000000000682e+02, 3.243000000000000682e+02))); %!test %! assert (isequal (pownrev (infsup (1.841993774061043421e-01, 1.000000000000000000e+04), -2), infsup (-2.330000000000000515e+00, 2.330000000000000515e+00))); %!test %! assert (isequal (pownrev (infsup (2.770083102493074989e-01, 9.182736455463727410e+00), -2), infsup (-1.900000000000000133e+00, 1.900000000000000133e+00))); %!test %! assert (isequal (pownrev (infsup, -8), infsup)); %!test %! assert (isequal (pownrev (infsup (0.0, inf), -8), infsup (-inf, inf))); %!test %! assert (isequal (pownrev (infsup (-0.0, inf), -8), infsup (-inf, inf))); %!test %! assert (isequal (pownrev (infsup (0.0, 0.0), -8), infsup)); %!test %! assert (isequal (pownrev (infsup (-0.0, -0.0), -8), infsup)); %!test %! assert (isequal (pownrev (infsup (1.153000869365374417e-09, 1.153000869365374624e-09), -8), infsup (-1.310000000000000142e+01, 1.310000000000000142e+01))); %!test %! assert (isequal (pownrev (infsup (1.052484917283328578e-31, 1.052484917283328797e-31), -8), infsup (-7.451145000000001346e+03, 7.451145000000001346e+03))); %!test %! assert (isequal (pownrev (infsup (0.000000000000000000e+00, 4.940656458412465442e-324), -8), infsup (-inf, inf))); %!test %! assert (isequal (pownrev (infsup (8.173807596331487643e-21, inf), -8), infsup (-3.243000000000000682e+02, 3.243000000000000682e+02))); %!test %! assert (isequal (pownrev (infsup (1.151204906160357110e-03, 1.000000000000000000e+16), -8), infsup (-2.330000000000000515e+00, 2.330000000000000515e+00))); %!test %! assert (isequal (pownrev (infsup (5.888045974722156024e-03, 7.110309102419345436e+03), -8), infsup (-1.900000000000000133e+00, 1.900000000000000133e+00))); %!test %! assert (isequal (pownrev (infsup, -1), infsup)); %!test %! assert (isequal (pownrev (infsup (-inf, inf), -1), infsup (-inf, inf))); %!test %! assert (isequal (pownrev (infsup (0.0, 0.0), -1), infsup)); %!test %! assert (isequal (pownrev (infsup (-0.0, -0.0), -1), infsup)); %!test %! assert (isequal (pownrev (infsup (7.633587786259540819e-02, 7.633587786259542207e-02), -1), infsup (1.309999999999999787e+01, 1.310000000000000320e+01))); %!test %! assert (isequal (pownrev (infsup (-1.342075613882161712e-04, -1.342075613882161441e-04), -1), infsup (-7.451145000000002256e+03, -7.451144999999999527e+03))); %!test %! assert (isequal (pownrev (infsup (5.562684646268003458e-309, 5.562684646268008398e-309), -1), infsup (1.797693134862314311e+308, inf))); %!test %! assert (isequal (pownrev (infsup (-5.562684646268008398e-309, -5.562684646268003458e-309), -1), infsup (-inf, -1.797693134862314311e+308))); %!test %! assert (isequal (pownrev (infsup (0.0, inf), -1), infsup (0.0, inf))); %!test %! assert (isequal (pownrev (infsup (-0.0, inf), -1), infsup (0.0, inf))); %!test %! assert (isequal (pownrev (infsup (-inf, 0.0), -1), infsup (-inf, 0.0))); %!test %! assert (isequal (pownrev (infsup (-inf, -0.0), -1), infsup (-inf, 0.0))); %!test %! assert (isequal (pownrev (infsup (4.291845493562231328e-01, 1.000000000000000000e+02), -1), infsup (9.999999999999998473e-03, 2.330000000000000515e+00))); %!test %! assert (isequal (pownrev (infsup (-3.030303030303030276e+00, -5.263157894736841813e-01), -1), infsup (-1.900000000000000133e+00, -3.299999999999999600e-01))); %!test %! assert (isequal (pownrev (infsup, -3), infsup)); %!test %! assert (isequal (pownrev (infsup (-inf, inf), -3), infsup (-inf, inf))); %!test %! assert (isequal (pownrev (infsup (0.0, 0.0), -3), infsup)); %!test %! assert (isequal (pownrev (infsup (-0.0, -0.0), -3), infsup)); %!test %! assert (isequal (pownrev (infsup (4.448218510727546177e-04, 4.448218510727546720e-04), -3), infsup (1.309999999999999787e+01, 1.310000000000000142e+01))); %!test %! assert (isequal (pownrev (infsup (-2.417302244657943502e-12, -2.417302244657943098e-12), -3), infsup (-7.451145000000001346e+03, -7.451144999999999527e+03))); %!test %! assert (isequal (pownrev (infsup (0.000000000000000000e+00, 4.940656458412465442e-324), -3), infsup (5.871356456934583070e+107, inf))); %!test %! assert (isequal (pownrev (infsup (-4.940656458412465442e-324, -0.000000000000000000e+00), -3), infsup (-inf, -5.871356456934583070e+107))); %!test %! assert (isequal (pownrev (infsup (0.0, inf), -3), infsup (0.0, inf))); %!test %! assert (isequal (pownrev (infsup (-0.0, inf), -3), infsup (0.0, inf))); %!test %! assert (isequal (pownrev (infsup (-inf, 0.0), -3), infsup (-inf, 0.0))); %!test %! assert (isequal (pownrev (infsup (-inf, -0.0), -3), infsup (-inf, 0.0))); %!test %! assert (isequal (pownrev (infsup (7.905552678373577169e-02, 1.000000000000000000e+06), -3), infsup (9.999999999999998473e-03, 2.330000000000000515e+00))); %!test %! assert (isequal (pownrev (infsup (-2.782647410746584171e+01, -1.457938474996355316e-01), -3), infsup (-1.900000000000000133e+00, -3.299999999999999600e-01))); %!test %! assert (isequal (pownrev (infsup, -7), infsup)); %!test %! assert (isequal (pownrev (infsup (-inf, inf), -7), infsup (-inf, inf))); %!test %! assert (isequal (pownrev (infsup (0.0, 0.0), -7), infsup)); %!test %! assert (isequal (pownrev (infsup (-0.0, -0.0), -7), infsup)); %!test %! assert (isequal (pownrev (infsup (1.510431138868640339e-08, 1.510431138868640670e-08), -7), infsup (1.309999999999999787e+01, 1.310000000000000142e+01))); %!test %! assert (isequal (pownrev (infsup (-7.842217728991088300e-28, -7.842217728991087403e-28), -7), infsup (-7.451145000000001346e+03, -7.451144999999999527e+03))); %!test %! assert (isequal (pownrev (infsup (0.000000000000000000e+00, 4.940656458412465442e-324), -7), infsup (1.536746355637629315e+46, inf))); %!test %! assert (isequal (pownrev (infsup (-4.940656458412465442e-324, -0.000000000000000000e+00), -7), infsup (-inf, -1.536746355637629315e+46))); %!test %! assert (isequal (pownrev (infsup (0.0, inf), -7), infsup (0.0, inf))); %!test %! assert (isequal (pownrev (infsup (-0.0, inf), -7), infsup (0.0, inf))); %!test %! assert (isequal (pownrev (infsup (-inf, 0.0), -7), infsup (-inf, 0.0))); %!test %! assert (isequal (pownrev (infsup (-inf, -0.0), -7), infsup (-inf, 0.0))); %!test %! assert (isequal (pownrev (infsup (2.682307431353632161e-03, 1.000000000000000000e+14), -7), infsup (9.999999999999998473e-03, 2.330000000000000515e+00))); %!test %! assert (isequal (pownrev (infsup (-2.346402003798384158e+03, -1.118728735197209619e-02), -7), infsup (-1.900000000000000133e+00, -3.299999999999999600e-01))); ## minimal_pownRevBin_test %!test %! assert (isequal (pownrev (infsup, infsup (1.0, 1.0), 0), infsup)); %!test %! assert (isequal (pownrev (infsup (1.0, 1.0), infsup (1.0, 1.0), 0), infsup (1.0, 1.0))); %!test %! assert (isequal (pownrev (infsup (-1.0, 5.0), infsup (-51.0, 12.0), 0), infsup (-51.0, 12.0))); %!test %! assert (isequal (pownrev (infsup (-1.0, 0.0), infsup (5.0, 10.0), 0), infsup)); %!test %! assert (isequal (pownrev (infsup (-1.0, -0.0), infsup (-1.0, 1.0), 0), infsup)); %!test %! assert (isequal (pownrev (infsup (1.1, 10.0), infsup (1.0, 41.0), 0), infsup)); %!test %! assert (isequal (pownrev (infsup, infsup (0.0, 100.1), 1), infsup)); %!test %! assert (isequal (pownrev (infsup (-inf, inf), infsup (-5.1, 10.0), 1), infsup (-5.1, 10.0))); %!test %! assert (isequal (pownrev (infsup (0.0, 0.0), infsup (-10.0, 5.1), 1), infsup (0.0, 0.0))); %!test %! assert (isequal (pownrev (infsup (-0.0, -0.0), infsup (1.0, 5.0), 1), infsup)); %!test %! assert (isequal (pownrev (infsup, infsup (5.0, 17.1), 2), infsup)); %!test %! assert (isequal (pownrev (infsup (-5.0, -1.0), infsup (5.0, 17.1), 2), infsup)); %!test %! assert (isequal (pownrev (infsup (0.0, inf), infsup (5.6, 27.544), 2), infsup (5.6, 27.544))); %!test %! assert (isequal (pownrev (infsup (0.0, 0.0), infsup (1.0, 2.0), 2), infsup)); %!test %! assert (isequal (pownrev (infsup (9.999999999999999124e-05, 5.428900000000000503e+00), infsup (1.0, inf), 2), infsup (1.0, 2.330000000000000515e+00))); %!test %! assert (isequal (pownrev (infsup (1.088999999999999968e-01, 3.609999999999999876e+00), infsup (-inf, -1.0), 2), infsup (-1.900000000000000133e+00, -1.0))); %!test %! assert (isequal (pownrev (infsup, infsup (-23.0, -1.0), 3), infsup)); %!test %! assert (isequal (pownrev (infsup (-inf, inf), infsup (-23.0, -1.0), 3), infsup (-23.0, -1.0))); %!test %! assert (isequal (pownrev (infsup (0.0, 0.0), infsup (1.0, 2.0), 3), infsup)); %!test %! assert (isequal (pownrev (infsup (9.999999999999999547e-07, 1.264933700000000272e+01), infsup (1.0, inf), 3), infsup (1.0, 2.330000000000000515e+00))); %!test %! assert (isequal (pownrev (infsup (-6.858999999999999098e+00, -3.593700000000000366e-02), infsup (-inf, -1.0), 3), infsup (-1.900000000000000133e+00, -1.0))); %!test %! assert (isequal (pownrev (infsup, infsup (-3.0, 17.3), -2), infsup)); %!test %! assert (isequal (pownrev (infsup (0.0, inf), infsup (-5.1, -0.1), -2), infsup (-5.1, -0.1))); %!test %! assert (isequal (pownrev (infsup (0.0, 0.0), infsup (27.2, 55.1), -2), infsup)); %!test %! assert (isequal (pownrev (infsup (9.508370646556841917e-06, inf), infsup (-inf, -1.797693134862315708e+308), -2), infsup)); %!test %! assert (isequal (pownrev (infsup (1.841993774061043421e-01, 1.000000000000000000e+04), infsup (1.0, inf), -2), infsup (1.0, 2.330000000000000515e+00))); %!test %! assert (isequal (pownrev (infsup (2.770083102493074989e-01, 9.182736455463727410e+00), infsup (-inf, -1.0), -2), infsup (-1.900000000000000133e+00, -1.0))); %!test %! assert (isequal (pownrev (infsup, infsup (-5.1, 55.5), -1), infsup)); %!test %! assert (isequal (pownrev (infsup (-inf, inf), infsup (-5.1, 55.5), -1), infsup (-5.1, 55.5))); %!test %! assert (isequal (pownrev (infsup (0.0, 0.0), infsup (-5.1, 55.5), -1), infsup)); %!test %! assert (isequal (pownrev (infsup (-inf, -0.0), infsup (-1.0, 1.0), -1), infsup (-1.0, 0.0))); %!test %! assert (isequal (pownrev (infsup (4.291845493562231328e-01, 1.000000000000000000e+02), infsup (-1.0, 0.0), -1), infsup)); %!test %! assert (isequal (pownrev (infsup, infsup (-5.1, 55.5), -3), infsup)); %!test %! assert (isequal (pownrev (infsup (-inf, inf), infsup (-5.1, 55.5), -3), infsup (-5.1, 55.5))); %!test %! assert (isequal (pownrev (infsup (0.0, 0.0), infsup (-5.1, 55.5), -3), infsup)); %!test %! assert (isequal (pownrev (infsup (-inf, 0.0), infsup (5.1, 55.5), -3), infsup)); %!test %! assert (isequal (pownrev (infsup (-inf, -0.0), infsup (-32.0, 1.1), -3), infsup (-32.0, 0.0))); ## minimal_pownRev_dec_test %!test %! assert (isequal (pownrev (infsupdec (empty, "trv"), 0), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (empty, "trv"), 0)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (1.0, 1.0, "com"), 0), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (1.0, 1.0, "com"), 0)){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-1.0, 5.0, "dac"), 0), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-1.0, 5.0, "dac"), 0)){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-1.0, 0.0, "def"), 0), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-1.0, 0.0, "def"), 0)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-1.0, -0.0, "dac"), 0), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-1.0, -0.0, "dac"), 0)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (1.1, 10.0, "com"), 0), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (1.1, 10.0, "com"), 0)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (empty, "trv"), 1), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (empty, "trv"), 1)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (entire, "def"), 1), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (entire, "def"), 1)){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, 0.0, "com"), 1), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, 0.0, "com"), 1)){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, -0.0, "dac"), 1), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, -0.0, "dac"), 1)){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (13.1, 13.1, "def"), 1), infsupdec (13.1, 13.1, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (13.1, 13.1, "def"), 1)){1}, decorationpart (infsupdec (13.1, 13.1, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-7451.145, -7451.145, "dac"), 1), infsupdec (-7451.145, -7451.145, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-7451.145, -7451.145, "dac"), 1)){1}, decorationpart (infsupdec (-7451.145, -7451.145, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (1.797693134862315708e+308, 1.797693134862315708e+308, "com"), 1), infsupdec (1.797693134862315708e+308, 1.797693134862315708e+308, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (1.797693134862315708e+308, 1.797693134862315708e+308, "com"), 1)){1}, decorationpart (infsupdec (1.797693134862315708e+308, 1.797693134862315708e+308, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-1.797693134862315708e+308, -1.797693134862315708e+308, "com"), 1), infsupdec (-1.797693134862315708e+308, -1.797693134862315708e+308, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-1.797693134862315708e+308, -1.797693134862315708e+308, "com"), 1)){1}, decorationpart (infsupdec (-1.797693134862315708e+308, -1.797693134862315708e+308, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, inf, "dac"), 1), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, inf, "dac"), 1)){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, inf, "dac"), 1), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, inf, "dac"), 1)){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-inf, 0.0, "def"), 1), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-inf, 0.0, "def"), 1)){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-inf, -0.0, "def"), 1), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-inf, -0.0, "def"), 1)){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-324.3, 2.5, "dac"), 1), infsupdec (-324.3, 2.5, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-324.3, 2.5, "dac"), 1)){1}, decorationpart (infsupdec (-324.3, 2.5, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.01, 2.33, "com"), 1), infsupdec (0.01, 2.33, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.01, 2.33, "com"), 1)){1}, decorationpart (infsupdec (0.01, 2.33, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-1.9, -0.33, "def"), 1), infsupdec (-1.9, -0.33, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-1.9, -0.33, "def"), 1)){1}, decorationpart (infsupdec (-1.9, -0.33, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (empty, "trv"), 2), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (empty, "trv"), 2)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, inf, "dac"), 2), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, inf, "dac"), 2)){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, inf, "def"), 2), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, inf, "def"), 2)){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, 0.0, "com"), 2), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, 0.0, "com"), 2)){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, -0.0, "dac"), 2), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, -0.0, "dac"), 2)){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (1.716099999999999852e+02, 1.716100000000000136e+02, "def"), 2), infsupdec (-1.310000000000000142e+01, 1.310000000000000142e+01, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (1.716099999999999852e+02, 1.716100000000000136e+02, "def"), 2)){1}, decorationpart (infsupdec (-1.310000000000000142e+01, 1.310000000000000142e+01, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (5.551956181102500111e+07, 5.551956181102500856e+07, "def"), 2), infsupdec (-7.451145000000001346e+03, 7.451145000000001346e+03, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (5.551956181102500111e+07, 5.551956181102500856e+07, "def"), 2)){1}, decorationpart (infsupdec (-7.451145000000001346e+03, 7.451145000000001346e+03, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (1.797693134862315708e+308, 1.797693134862315708e+308, "dac"), 2), infsupdec (-1.340780792994259710e+154, 1.340780792994259710e+154, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (1.797693134862315708e+308, 1.797693134862315708e+308, "dac"), 2)){1}, decorationpart (infsupdec (-1.340780792994259710e+154, 1.340780792994259710e+154, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, 1.051704900000000198e+05, "dac"), 2), infsupdec (-3.243000000000000682e+02, 3.243000000000000682e+02, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, 1.051704900000000198e+05, "dac"), 2)){1}, decorationpart (infsupdec (-3.243000000000000682e+02, 3.243000000000000682e+02, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, 1.051704900000000198e+05, "def"), 2), infsupdec (-3.243000000000000682e+02, 3.243000000000000682e+02, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, 1.051704900000000198e+05, "def"), 2)){1}, decorationpart (infsupdec (-3.243000000000000682e+02, 3.243000000000000682e+02, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (9.999999999999999124e-05, 5.428900000000000503e+00, "com"), 2), infsupdec (-2.330000000000000515e+00, 2.330000000000000515e+00, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (9.999999999999999124e-05, 5.428900000000000503e+00, "com"), 2)){1}, decorationpart (infsupdec (-2.330000000000000515e+00, 2.330000000000000515e+00, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (1.088999999999999968e-01, 3.609999999999999876e+00, "def"), 2), infsupdec (-1.900000000000000133e+00, 1.900000000000000133e+00, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (1.088999999999999968e-01, 3.609999999999999876e+00, "def"), 2)){1}, decorationpart (infsupdec (-1.900000000000000133e+00, 1.900000000000000133e+00, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (empty, "trv"), 8), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (empty, "trv"), 8)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (entire, "def"), 8), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (entire, "def"), 8)){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, inf, "dac"), 8), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, inf, "dac"), 8)){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, inf, "dac"), 8), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, inf, "dac"), 8)){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, 0.0, "def"), 8), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, 0.0, "def"), 8)){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, -0.0, "dac"), 8), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, -0.0, "dac"), 8)){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (8.673020346900621653e+08, 8.673020346900622845e+08, "com"), 8), infsupdec (-1.310000000000000142e+01, 1.310000000000000142e+01, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (8.673020346900621653e+08, 8.673020346900622845e+08, "com"), 8)){1}, decorationpart (infsupdec (-1.310000000000000142e+01, 1.310000000000000142e+01, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (9.501323805961964567e+30, 9.501323805961965692e+30, "dac"), 8), infsupdec (-7.451145000000001346e+03, 7.451145000000001346e+03, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (9.501323805961964567e+30, 9.501323805961965692e+30, "dac"), 8)){1}, decorationpart (infsupdec (-7.451145000000001346e+03, 7.451145000000001346e+03, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (1.797693134862315708e+308, 1.797693134862315708e+308, "def"), 8), infsupdec (-3.402823669209384635e+38, 3.402823669209384635e+38, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (1.797693134862315708e+308, 1.797693134862315708e+308, "def"), 8)){1}, decorationpart (infsupdec (-3.402823669209384635e+38, 3.402823669209384635e+38, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, 1.223420037986718843e+20, "dac"), 8), infsupdec (-3.243000000000000682e+02, 3.243000000000000682e+02, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, 1.223420037986718843e+20, "dac"), 8)){1}, decorationpart (infsupdec (-3.243000000000000682e+02, 3.243000000000000682e+02, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, 1.223420037986718843e+20, "def"), 8), infsupdec (-3.243000000000000682e+02, 3.243000000000000682e+02, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, 1.223420037986718843e+20, "def"), 8)){1}, decorationpart (infsupdec (-3.243000000000000682e+02, 3.243000000000000682e+02, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (1.000000000000000102e-16, 8.686550888106663706e+02, "com"), 8), infsupdec (-2.330000000000000515e+00, 2.330000000000000515e+00, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (1.000000000000000102e-16, 8.686550888106663706e+02, "com"), 8)){1}, decorationpart (infsupdec (-2.330000000000000515e+00, 2.330000000000000515e+00, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (1.406408618241000491e-04, 1.698356304099999647e+02, "dac"), 8), infsupdec (-1.900000000000000133e+00, 1.900000000000000133e+00, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (1.406408618241000491e-04, 1.698356304099999647e+02, "dac"), 8)){1}, decorationpart (infsupdec (-1.900000000000000133e+00, 1.900000000000000133e+00, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (empty, "trv"), 3), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (empty, "trv"), 3)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (entire, "def"), 3), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (entire, "def"), 3)){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, 0.0, "dac"), 3), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, 0.0, "dac"), 3)){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, -0.0, "def"), 3), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, -0.0, "def"), 3)){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (2.248090999999999440e+03, 2.248090999999999894e+03, "com"), 3), infsupdec (1.309999999999999787e+01, 1.310000000000000142e+01, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (2.248090999999999440e+03, 2.248090999999999894e+03, "com"), 3)){1}, decorationpart (infsupdec (1.309999999999999787e+01, 1.310000000000000142e+01, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-4.136843053904099731e+11, -4.136843053904099121e+11, "def"), 3), infsupdec (-7.451145000000001346e+03, -7.451144999999999527e+03, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-4.136843053904099731e+11, -4.136843053904099121e+11, "def"), 3)){1}, decorationpart (infsupdec (-7.451145000000001346e+03, -7.451144999999999527e+03, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (1.797693134862315708e+308, 1.797693134862315708e+308, "dac"), 3), infsupdec (5.643803094122361304e+102, 5.643803094122362298e+102, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (1.797693134862315708e+308, 1.797693134862315708e+308, "dac"), 3)){1}, decorationpart (infsupdec (5.643803094122361304e+102, 5.643803094122362298e+102, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-1.797693134862315708e+308, -1.797693134862315708e+308, "com"), 3), infsupdec (-5.643803094122362298e+102, -5.643803094122361304e+102, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-1.797693134862315708e+308, -1.797693134862315708e+308, "com"), 3)){1}, decorationpart (infsupdec (-5.643803094122362298e+102, -5.643803094122361304e+102, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, inf, "def"), 3), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, inf, "def"), 3)){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, inf, "def"), 3), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, inf, "def"), 3)){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-inf, 0.0, "dac"), 3), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-inf, 0.0, "dac"), 3)){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-inf, -0.0, "def"), 3), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-inf, -0.0, "def"), 3)){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-3.410678990700000525e+07, 1.562500000000000000e+01, "com"), 3), infsupdec (-3.243000000000000682e+02, 2.500000000000000000e+00, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-3.410678990700000525e+07, 1.562500000000000000e+01, "com"), 3)){1}, decorationpart (infsupdec (-3.243000000000000682e+02, 2.500000000000000000e+00, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (9.999999999999999547e-07, 1.264933700000000272e+01, "dac"), 3), infsupdec (9.999999999999998473e-03, 2.330000000000000515e+00, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (9.999999999999999547e-07, 1.264933700000000272e+01, "dac"), 3)){1}, decorationpart (infsupdec (9.999999999999998473e-03, 2.330000000000000515e+00, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-6.858999999999999098e+00, -3.593700000000000366e-02, "def"), 3), infsupdec (-1.900000000000000133e+00, -3.299999999999999600e-01, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-6.858999999999999098e+00, -3.593700000000000366e-02, "def"), 3)){1}, decorationpart (infsupdec (-1.900000000000000133e+00, -3.299999999999999600e-01, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (empty, "trv"), 7), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (empty, "trv"), 7)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (entire, "def"), 7), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (entire, "def"), 7)){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, 0.0, "com"), 7), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, 0.0, "com"), 7)){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, -0.0, "dac"), 7), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, -0.0, "dac"), 7)){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (6.620626219008108228e+07, 6.620626219008108974e+07, "def"), 7), infsupdec (1.309999999999999787e+01, 1.310000000000000142e+01, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (6.620626219008108228e+07, 6.620626219008108974e+07, "def"), 7)){1}, decorationpart (infsupdec (1.309999999999999787e+01, 1.310000000000000142e+01, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-1.275149497957960280e+27, -1.275149497957960005e+27, "dac"), 7), infsupdec (-7.451145000000001346e+03, -7.451144999999999527e+03, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-1.275149497957960280e+27, -1.275149497957960005e+27, "dac"), 7)){1}, decorationpart (infsupdec (-7.451145000000001346e+03, -7.451144999999999527e+03, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (1.797693134862315708e+308, 1.797693134862315708e+308, "com"), 7), infsupdec (1.087396515837748951e+44, 1.087396515837749149e+44, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (1.797693134862315708e+308, 1.797693134862315708e+308, "com"), 7)){1}, decorationpart (infsupdec (1.087396515837748951e+44, 1.087396515837749149e+44, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-1.797693134862315708e+308, -1.797693134862315708e+308, "def"), 7), infsupdec (-1.087396515837749149e+44, -1.087396515837748951e+44, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-1.797693134862315708e+308, -1.797693134862315708e+308, "def"), 7)){1}, decorationpart (infsupdec (-1.087396515837749149e+44, -1.087396515837748951e+44, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, inf, "dac"), 7), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, inf, "dac"), 7)){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, inf, "dac"), 7), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, inf, "dac"), 7)){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-inf, 0.0, "def"), 7), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-inf, 0.0, "def"), 7)){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-inf, -0.0, "def"), 7), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-inf, -0.0, "def"), 7)){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-3.772494720896449920e+17, 6.103515625000000000e+02, "dac"), 7), infsupdec (-3.243000000000000682e+02, 2.500000000000000000e+00, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-3.772494720896449920e+17, 6.103515625000000000e+02, "dac"), 7)){1}, decorationpart (infsupdec (-3.243000000000000682e+02, 2.500000000000000000e+00, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (9.999999999999999988e-15, 3.728133428371958757e+02, "com"), 7), infsupdec (9.999999999999998473e-03, 2.330000000000000515e+00, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (9.999999999999999988e-15, 3.728133428371958757e+02, "com"), 7)){1}, decorationpart (infsupdec (9.999999999999998473e-03, 2.330000000000000515e+00, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-8.938717389999997920e+01, -4.261844297700001028e-04, "def"), 7), infsupdec (-1.900000000000000133e+00, -3.299999999999999600e-01, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-8.938717389999997920e+01, -4.261844297700001028e-04, "def"), 7)){1}, decorationpart (infsupdec (-1.900000000000000133e+00, -3.299999999999999600e-01, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (empty, "trv"), -2), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (empty, "trv"), -2)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, inf, "dac"), -2), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, inf, "dac"), -2)){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, inf, "dac"), -2), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, inf, "dac"), -2)){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, 0.0, "def"), -2), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, 0.0, "def"), -2)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, -0.0, "com"), -2), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, -0.0, "com"), -2)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-10.0, 0.0, "dac"), -2), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-10.0, 0.0, "dac"), -2)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-10.0, -0.0, "def"), -2), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-10.0, -0.0, "def"), -2)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (5.827166249053085390e-03, 5.827166249053086257e-03, "dac"), -2), infsupdec (-1.310000000000000142e+01, 1.310000000000000142e+01, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (5.827166249053085390e-03, 5.827166249053086257e-03, "dac"), -2)){1}, decorationpart (infsupdec (-1.310000000000000142e+01, 1.310000000000000142e+01, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (1.801166953377180740e-08, 1.801166953377181071e-08, "def"), -2), infsupdec (-7.451145000000001346e+03, 7.451145000000001346e+03, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (1.801166953377180740e-08, 1.801166953377181071e-08, "def"), -2)){1}, decorationpart (infsupdec (-7.451145000000001346e+03, 7.451145000000001346e+03, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.000000000000000000e+00, 4.940656458412465442e-324, "com"), -2), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.000000000000000000e+00, 4.940656458412465442e-324, "com"), -2)){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (9.508370646556841917e-06, inf, "dac"), -2), infsupdec (-3.243000000000000682e+02, 3.243000000000000682e+02, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (9.508370646556841917e-06, inf, "dac"), -2)){1}, decorationpart (infsupdec (-3.243000000000000682e+02, 3.243000000000000682e+02, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (1.841993774061043421e-01, 1.000000000000000000e+04, "def"), -2), infsupdec (-2.330000000000000515e+00, 2.330000000000000515e+00, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (1.841993774061043421e-01, 1.000000000000000000e+04, "def"), -2)){1}, decorationpart (infsupdec (-2.330000000000000515e+00, 2.330000000000000515e+00, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (2.770083102493074989e-01, 9.182736455463727410e+00, "com"), -2), infsupdec (-1.900000000000000133e+00, 1.900000000000000133e+00, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (2.770083102493074989e-01, 9.182736455463727410e+00, "com"), -2)){1}, decorationpart (infsupdec (-1.900000000000000133e+00, 1.900000000000000133e+00, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (empty, "trv"), -8), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (empty, "trv"), -8)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, inf, "def"), -8), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, inf, "def"), -8)){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, inf, "dac"), -8), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, inf, "dac"), -8)){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, 0.0, "def"), -8), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, 0.0, "def"), -8)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, -0.0, "dac"), -8), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, -0.0, "dac"), -8)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (1.153000869365374417e-09, 1.153000869365374624e-09, "com"), -8), infsupdec (-1.310000000000000142e+01, 1.310000000000000142e+01, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (1.153000869365374417e-09, 1.153000869365374624e-09, "com"), -8)){1}, decorationpart (infsupdec (-1.310000000000000142e+01, 1.310000000000000142e+01, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (1.052484917283328578e-31, 1.052484917283328797e-31, "def"), -8), infsupdec (-7.451145000000001346e+03, 7.451145000000001346e+03, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (1.052484917283328578e-31, 1.052484917283328797e-31, "def"), -8)){1}, decorationpart (infsupdec (-7.451145000000001346e+03, 7.451145000000001346e+03, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.000000000000000000e+00, 4.940656458412465442e-324, "dac"), -8), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.000000000000000000e+00, 4.940656458412465442e-324, "dac"), -8)){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (8.173807596331487643e-21, inf, "def"), -8), infsupdec (-3.243000000000000682e+02, 3.243000000000000682e+02, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (8.173807596331487643e-21, inf, "def"), -8)){1}, decorationpart (infsupdec (-3.243000000000000682e+02, 3.243000000000000682e+02, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (1.151204906160357110e-03, 1.000000000000000000e+16, "com"), -8), infsupdec (-2.330000000000000515e+00, 2.330000000000000515e+00, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (1.151204906160357110e-03, 1.000000000000000000e+16, "com"), -8)){1}, decorationpart (infsupdec (-2.330000000000000515e+00, 2.330000000000000515e+00, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (5.888045974722156024e-03, 7.110309102419345436e+03, "def"), -8), infsupdec (-1.900000000000000133e+00, 1.900000000000000133e+00, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (5.888045974722156024e-03, 7.110309102419345436e+03, "def"), -8)){1}, decorationpart (infsupdec (-1.900000000000000133e+00, 1.900000000000000133e+00, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (empty, "trv"), -1), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (empty, "trv"), -1)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (entire, "def"), -1), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (entire, "def"), -1)){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, 0.0, "dac"), -1), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, 0.0, "dac"), -1)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, -0.0, "dac"), -1), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, -0.0, "dac"), -1)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (7.633587786259540819e-02, 7.633587786259542207e-02, "def"), -1), infsupdec (1.309999999999999787e+01, 1.310000000000000320e+01, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (7.633587786259540819e-02, 7.633587786259542207e-02, "def"), -1)){1}, decorationpart (infsupdec (1.309999999999999787e+01, 1.310000000000000320e+01, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-1.342075613882161712e-04, -1.342075613882161441e-04, "dac"), -1), infsupdec (-7.451145000000002256e+03, -7.451144999999999527e+03, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-1.342075613882161712e-04, -1.342075613882161441e-04, "dac"), -1)){1}, decorationpart (infsupdec (-7.451145000000002256e+03, -7.451144999999999527e+03, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (5.562684646268003458e-309, 5.562684646268008398e-309, "dac"), -1), infsupdec (1.797693134862314311e+308, inf, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (5.562684646268003458e-309, 5.562684646268008398e-309, "dac"), -1)){1}, decorationpart (infsupdec (1.797693134862314311e+308, inf, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-5.562684646268008398e-309, -5.562684646268003458e-309, "def"), -1), infsupdec (-inf, -1.797693134862314311e+308, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-5.562684646268008398e-309, -5.562684646268003458e-309, "def"), -1)){1}, decorationpart (infsupdec (-inf, -1.797693134862314311e+308, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, inf, "dac"), -1), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, inf, "dac"), -1)){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, inf, "dac"), -1), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, inf, "dac"), -1)){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-inf, 0.0, "dac"), -1), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-inf, 0.0, "dac"), -1)){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-inf, -0.0, "def"), -1), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-inf, -0.0, "def"), -1)){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (4.291845493562231328e-01, 1.000000000000000000e+02, "com"), -1), infsupdec (9.999999999999998473e-03, 2.330000000000000515e+00, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (4.291845493562231328e-01, 1.000000000000000000e+02, "com"), -1)){1}, decorationpart (infsupdec (9.999999999999998473e-03, 2.330000000000000515e+00, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-3.030303030303030276e+00, -5.263157894736841813e-01, "com"), -1), infsupdec (-1.900000000000000133e+00, -3.299999999999999600e-01, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-3.030303030303030276e+00, -5.263157894736841813e-01, "com"), -1)){1}, decorationpart (infsupdec (-1.900000000000000133e+00, -3.299999999999999600e-01, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (empty, "trv"), -3), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (empty, "trv"), -3)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (entire, "def"), -3), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (entire, "def"), -3)){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, 0.0, "def"), -3), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, 0.0, "def"), -3)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, -0.0, "dac"), -3), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, -0.0, "dac"), -3)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (4.448218510727546177e-04, 4.448218510727546720e-04, "com"), -3), infsupdec (1.309999999999999787e+01, 1.310000000000000142e+01, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (4.448218510727546177e-04, 4.448218510727546720e-04, "com"), -3)){1}, decorationpart (infsupdec (1.309999999999999787e+01, 1.310000000000000142e+01, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-2.417302244657943502e-12, -2.417302244657943098e-12, "def"), -3), infsupdec (-7.451145000000001346e+03, -7.451144999999999527e+03, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-2.417302244657943502e-12, -2.417302244657943098e-12, "def"), -3)){1}, decorationpart (infsupdec (-7.451145000000001346e+03, -7.451144999999999527e+03, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.000000000000000000e+00, 4.940656458412465442e-324, "dac"), -3), infsupdec (5.871356456934583070e+107, inf, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.000000000000000000e+00, 4.940656458412465442e-324, "dac"), -3)){1}, decorationpart (infsupdec (5.871356456934583070e+107, inf, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-4.940656458412465442e-324, -0.000000000000000000e+00, "def"), -3), infsupdec (-inf, -5.871356456934583070e+107, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-4.940656458412465442e-324, -0.000000000000000000e+00, "def"), -3)){1}, decorationpart (infsupdec (-inf, -5.871356456934583070e+107, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, inf, "dac"), -3), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, inf, "dac"), -3)){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, inf, "dac"), -3), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, inf, "dac"), -3)){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-inf, 0.0, "def"), -3), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-inf, 0.0, "def"), -3)){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-inf, -0.0, "def"), -3), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-inf, -0.0, "def"), -3)){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (7.905552678373577169e-02, 1.000000000000000000e+06, "com"), -3), infsupdec (9.999999999999998473e-03, 2.330000000000000515e+00, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (7.905552678373577169e-02, 1.000000000000000000e+06, "com"), -3)){1}, decorationpart (infsupdec (9.999999999999998473e-03, 2.330000000000000515e+00, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-2.782647410746584171e+01, -1.457938474996355316e-01, "def"), -3), infsupdec (-1.900000000000000133e+00, -3.299999999999999600e-01, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-2.782647410746584171e+01, -1.457938474996355316e-01, "def"), -3)){1}, decorationpart (infsupdec (-1.900000000000000133e+00, -3.299999999999999600e-01, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (empty, "trv"), -7), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (empty, "trv"), -7)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (entire, "def"), -7), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (entire, "def"), -7)){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, 0.0, "com"), -7), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, 0.0, "com"), -7)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, -0.0, "def"), -7), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, -0.0, "def"), -7)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (1.510431138868640339e-08, 1.510431138868640670e-08, "dac"), -7), infsupdec (1.309999999999999787e+01, 1.310000000000000142e+01, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (1.510431138868640339e-08, 1.510431138868640670e-08, "dac"), -7)){1}, decorationpart (infsupdec (1.309999999999999787e+01, 1.310000000000000142e+01, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-7.842217728991088300e-28, -7.842217728991087403e-28, "dac"), -7), infsupdec (-7.451145000000001346e+03, -7.451144999999999527e+03, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-7.842217728991088300e-28, -7.842217728991087403e-28, "dac"), -7)){1}, decorationpart (infsupdec (-7.451145000000001346e+03, -7.451144999999999527e+03, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.000000000000000000e+00, 4.940656458412465442e-324, "def"), -7), infsupdec (1.536746355637629315e+46, inf, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.000000000000000000e+00, 4.940656458412465442e-324, "def"), -7)){1}, decorationpart (infsupdec (1.536746355637629315e+46, inf, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-4.940656458412465442e-324, -0.000000000000000000e+00, "def"), -7), infsupdec (-inf, -1.536746355637629315e+46, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-4.940656458412465442e-324, -0.000000000000000000e+00, "def"), -7)){1}, decorationpart (infsupdec (-inf, -1.536746355637629315e+46, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, inf, "dac"), -7), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, inf, "dac"), -7)){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, inf, "def"), -7), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, inf, "def"), -7)){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-inf, 0.0, "dac"), -7), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-inf, 0.0, "dac"), -7)){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-inf, -0.0, "def"), -7), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-inf, -0.0, "def"), -7)){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (2.682307431353632161e-03, 1.000000000000000000e+14, "com"), -7), infsupdec (9.999999999999998473e-03, 2.330000000000000515e+00, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (2.682307431353632161e-03, 1.000000000000000000e+14, "com"), -7)){1}, decorationpart (infsupdec (9.999999999999998473e-03, 2.330000000000000515e+00, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-2.346402003798384158e+03, -1.118728735197209619e-02, "com"), -7), infsupdec (-1.900000000000000133e+00, -3.299999999999999600e-01, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-2.346402003798384158e+03, -1.118728735197209619e-02, "com"), -7)){1}, decorationpart (infsupdec (-1.900000000000000133e+00, -3.299999999999999600e-01, "trv")){1})); ## minimal_pownRev_dec_bin_test %!test %! assert (isequal (pownrev (infsupdec (empty, "trv"), infsupdec (1.0, 1.0, "def"), 0), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (empty, "trv"), infsupdec (1.0, 1.0, "def"), 0)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (1.0, 1.0, "dac"), infsupdec (1.0, 1.0, "dac"), 0), infsupdec (1.0, 1.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (1.0, 1.0, "dac"), infsupdec (1.0, 1.0, "dac"), 0)){1}, decorationpart (infsupdec (1.0, 1.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-1.0, 5.0, "def"), infsupdec (-51.0, 12.0, "dac"), 0), infsupdec (-51.0, 12.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-1.0, 5.0, "def"), infsupdec (-51.0, 12.0, "dac"), 0)){1}, decorationpart (infsupdec (-51.0, 12.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-1.0, 0.0, "com"), infsupdec (5.0, 10.0, "dac"), 0), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-1.0, 0.0, "com"), infsupdec (5.0, 10.0, "dac"), 0)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-1.0, -0.0, "dac"), infsupdec (-1.0, 1.0, "def"), 0), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-1.0, -0.0, "dac"), infsupdec (-1.0, 1.0, "def"), 0)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (1.1, 10.0, "def"), infsupdec (1.0, 41.0, "dac"), 0), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (1.1, 10.0, "def"), infsupdec (1.0, 41.0, "dac"), 0)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (empty, "trv"), infsupdec (0.0, 100.1, "dac"), 1), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (empty, "trv"), infsupdec (0.0, 100.1, "dac"), 1)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (entire, "def"), infsupdec (-5.1, 10.0, "def"), 1), infsupdec (-5.1, 10.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (entire, "def"), infsupdec (-5.1, 10.0, "def"), 1)){1}, decorationpart (infsupdec (-5.1, 10.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, 0.0, "com"), infsupdec (-10.0, 5.1, "dac"), 1), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, 0.0, "com"), infsupdec (-10.0, 5.1, "dac"), 1)){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-0.0, -0.0, "def"), infsupdec (1.0, 5.0, "dac"), 1), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-0.0, -0.0, "def"), infsupdec (1.0, 5.0, "dac"), 1)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (empty, "trv"), infsupdec (5.0, 17.1, "def"), 2), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (empty, "trv"), infsupdec (5.0, 17.1, "def"), 2)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, inf, "dac"), infsupdec (5.6, 27.544, "dac"), 2), infsupdec (5.6, 27.544, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, inf, "dac"), infsupdec (5.6, 27.544, "dac"), 2)){1}, decorationpart (infsupdec (5.6, 27.544, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, 0.0, "def"), infsupdec (1.0, 2.0, "def"), 2), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, 0.0, "def"), infsupdec (1.0, 2.0, "def"), 2)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (9.999999999999999124e-05, 5.428900000000000503e+00, "com"), infsupdec (1.0, inf, "def"), 2), infsupdec (1.0, 2.330000000000000515e+00, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (9.999999999999999124e-05, 5.428900000000000503e+00, "com"), infsupdec (1.0, inf, "def"), 2)){1}, decorationpart (infsupdec (1.0, 2.330000000000000515e+00, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (1.088999999999999968e-01, 3.609999999999999876e+00, "dac"), infsupdec (-inf, -1.0, "def"), 2), infsupdec (-1.900000000000000133e+00, -1.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (1.088999999999999968e-01, 3.609999999999999876e+00, "dac"), infsupdec (-inf, -1.0, "def"), 2)){1}, decorationpart (infsupdec (-1.900000000000000133e+00, -1.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (empty, "trv"), infsupdec (-23.0, -1.0, "dac"), 3), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (empty, "trv"), infsupdec (-23.0, -1.0, "dac"), 3)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (entire, "def"), infsupdec (-23.0, -1.0, "com"), 3), infsupdec (-23.0, -1.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (entire, "def"), infsupdec (-23.0, -1.0, "com"), 3)){1}, decorationpart (infsupdec (-23.0, -1.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, 0.0, "def"), infsupdec (1.0, 2.0, "dac"), 3), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, 0.0, "def"), infsupdec (1.0, 2.0, "dac"), 3)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (9.999999999999999547e-07, 1.264933700000000272e+01, "com"), infsupdec (1.0, inf, "dac"), 3), infsupdec (1.0, 2.330000000000000515e+00, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (9.999999999999999547e-07, 1.264933700000000272e+01, "com"), infsupdec (1.0, inf, "dac"), 3)){1}, decorationpart (infsupdec (1.0, 2.330000000000000515e+00, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-6.858999999999999098e+00, -3.593700000000000366e-02, "com"), infsupdec (-inf, -1.0, "dac"), 3), infsupdec (-1.900000000000000133e+00, -1.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-6.858999999999999098e+00, -3.593700000000000366e-02, "com"), infsupdec (-inf, -1.0, "dac"), 3)){1}, decorationpart (infsupdec (-1.900000000000000133e+00, -1.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (empty, "trv"), infsupdec (-3.0, 17.3, "def"), -2), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (empty, "trv"), infsupdec (-3.0, 17.3, "def"), -2)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, inf, "dac"), infsupdec (-5.1, -0.1, "dac"), -2), infsupdec (-5.1, -0.1, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, inf, "dac"), infsupdec (-5.1, -0.1, "dac"), -2)){1}, decorationpart (infsupdec (-5.1, -0.1, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, 0.0, "def"), infsupdec (27.2, 55.1, "dac"), -2), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, 0.0, "def"), infsupdec (27.2, 55.1, "dac"), -2)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (9.508370646556841917e-06, inf, "def"), infsupdec (-inf, -1.797693134862315708e+308, "dac"), -2), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (9.508370646556841917e-06, inf, "def"), infsupdec (-inf, -1.797693134862315708e+308, "dac"), -2)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (1.841993774061043421e-01, 1.000000000000000000e+04, "com"), infsupdec (1.0, inf, "dac"), -2), infsupdec (1.0, 2.330000000000000515e+00, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (1.841993774061043421e-01, 1.000000000000000000e+04, "com"), infsupdec (1.0, inf, "dac"), -2)){1}, decorationpart (infsupdec (1.0, 2.330000000000000515e+00, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (2.770083102493074989e-01, 9.182736455463727410e+00, "com"), infsupdec (-inf, -1.0, "dac"), -2), infsupdec (-1.900000000000000133e+00, -1.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (2.770083102493074989e-01, 9.182736455463727410e+00, "com"), infsupdec (-inf, -1.0, "dac"), -2)){1}, decorationpart (infsupdec (-1.900000000000000133e+00, -1.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (empty, "trv"), infsupdec (-5.1, 55.5, "def"), -1), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (empty, "trv"), infsupdec (-5.1, 55.5, "def"), -1)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (entire, "def"), infsupdec (-5.1, 55.5, "dac"), -1), infsupdec (-5.1, 55.5, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (entire, "def"), infsupdec (-5.1, 55.5, "dac"), -1)){1}, decorationpart (infsupdec (-5.1, 55.5, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, 0.0, "dac"), infsupdec (-5.1, 55.5, "def"), -1), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, 0.0, "dac"), infsupdec (-5.1, 55.5, "def"), -1)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-inf, -0.0, "dac"), infsupdec (-1.0, 1.0, "com"), -1), infsupdec (-1.0, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-inf, -0.0, "dac"), infsupdec (-1.0, 1.0, "com"), -1)){1}, decorationpart (infsupdec (-1.0, 0.0, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (4.291845493562231328e-01, 1.000000000000000000e+02, "def"), infsupdec (-1.0, 0.0, "dac"), -1), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (4.291845493562231328e-01, 1.000000000000000000e+02, "def"), infsupdec (-1.0, 0.0, "dac"), -1)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (empty, "trv"), infsupdec (-5.1, 55.5, "dac"), -3), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (empty, "trv"), infsupdec (-5.1, 55.5, "dac"), -3)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (entire, "def"), infsupdec (-5.1, 55.5, "def"), -3), infsupdec (-5.1, 55.5, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (entire, "def"), infsupdec (-5.1, 55.5, "def"), -3)){1}, decorationpart (infsupdec (-5.1, 55.5, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (0.0, 0.0, "def"), infsupdec (-5.1, 55.5, "def"), -3), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (0.0, 0.0, "def"), infsupdec (-5.1, 55.5, "def"), -3)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-inf, 0.0, "dac"), infsupdec (5.1, 55.5, "com"), -3), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-inf, 0.0, "dac"), infsupdec (5.1, 55.5, "com"), -3)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pownrev (infsupdec (-inf, -0.0, "dac"), infsupdec (-32.0, 1.1, "def"), -3), infsupdec (-32.0, 0.0, "trv"))); %! assert (isequal (decorationpart (pownrev (infsupdec (-inf, -0.0, "dac"), infsupdec (-32.0, 1.1, "def"), -3)){1}, decorationpart (infsupdec (-32.0, 0.0, "trv")){1})); ## minimal_sinRev_test %!test %! assert (isequal (sinrev (infsup), infsup)); %!test %! assert (isequal (sinrev (infsup (-2.0, -1.1)), infsup)); %!test %! assert (isequal (sinrev (infsup (1.1, 2.0)), infsup)); %!test %! assert (isequal (sinrev (infsup (-1.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (sinrev (infsup (0.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (sinrev (infsup (1.224646799147352961e-16, 1.224646799147353207e-16)), infsup (-inf, inf))); ## minimal_sinRevBin_test %!test %! assert (isequal (sinrev (infsup, infsup (-1.2, 12.1)), infsup)); %!test %! assert (isequal (sinrev (infsup (-2.0, -1.1), infsup (-5.0, 5.0)), infsup)); %!test %! assert (isequal (sinrev (infsup (1.1, 2.0), infsup (-5.0, 5.0)), infsup)); %!test %! assert (isequal (sinrev (infsup (-1.0, 1.0), infsup (-1.2, 12.1)), infsup (-1.2, 12.1))); %!test %! assert (isequal (sinrev (infsup (0.0, 0.0), infsup (-1.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (sinrev (infsup (-0.0, -0.0), infsup (2.0, 2.5)), infsup)); %!test %! assert (isequal (sinrev (infsup (-0.0, -0.0), infsup (3.0, 3.5)), infsup (3.141592653589793116e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (sinrev (infsup (9.999999999999998890e-01, 1.000000000000000000e+00), infsup (1.57, 1.58)), infsup (1.570796311893735364e+00, 1.570796341696058196e+00))); %!test %! assert (isequal (sinrev (infsup (0.0, 1.000000000000000000e+00), infsup (-0.1, 1.58)), infsup (0.0, 1.58))); %!test %! assert (isequal (sinrev (infsup (1.224646799147352961e-16, 1.224646799147353207e-16), infsup (3.14, 3.15)), infsup (3.141592653589792672e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (sinrev (infsup (-3.216245299353273201e-16, -3.216245299353272708e-16), infsup (3.14, 3.15)), infsup (3.141592653589793116e+00, 3.141592653589794004e+00))); %!test %! assert (isequal (sinrev (infsup (-3.216245299353273201e-16, 1.224646799147353207e-16), infsup (3.14, 3.15)), infsup (3.141592653589792672e+00, 3.141592653589794004e+00))); %!test %! assert (isequal (sinrev (infsup (0.0, 1.0), infsup (-0.1, 3.15)), infsup (0.0, 3.141592653589793560e+00))); %!test %! assert (isequal (sinrev (infsup (0.0, 1.0), infsup (-0.1, 3.15)), infsup (-0.0, 3.141592653589793560e+00))); %!test %! assert (isequal (sinrev (infsup (-3.216245299353273201e-16, 1.0), infsup (-0.1, 3.15)), infsup (-3.216245299353273694e-16, 3.141592653589794004e+00))); %!test %! assert (isequal (sinrev (infsup (-3.216245299353273201e-16, 1.0), infsup (0.0, 3.15)), infsup (0.0, 3.141592653589794004e+00))); %!test %! assert (isequal (sinrev (infsup (1.224646799147352961e-16, 1.000000000000000000e+00), infsup (3.14, 3.15)), infsup (3.14, 3.141592653589793560e+00))); %!test %! assert (isequal (sinrev (infsup (-3.216245299353273201e-16, 1.000000000000000000e+00), infsup (1.57, 3.15)), infsup (1.57, 3.141592653589794004e+00))); %!test %! assert (isequal (sinrev (infsup (1.224646799147352961e-16, 1.224646799147353207e-16), infsup (-inf, 3.15)), infsup (-inf, 3.141592653589793560e+00))); %!test %! assert (isequal (sinrev (infsup (-3.216245299353273201e-16, -3.216245299353272708e-16), infsup (3.14, inf)), infsup (3.141592653589793116e+00, inf))); ## minimal_sinRev_dec_test %!test %! assert (isequal (sinrev (infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (-2.0, -1.1, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (-2.0, -1.1, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (1.1, 2.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (1.1, 2.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (-1.0, 1.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (-1.0, 1.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (0.0, 0.0, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (0.0, 0.0, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (1.224646799147352961e-16, 1.224646799147353207e-16, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (1.224646799147352961e-16, 1.224646799147353207e-16, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); ## minimal_sinRev_dec_bin_test %!test %! assert (isequal (sinrev (infsupdec (empty, "trv"), infsupdec (-1.2, 12.1, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (empty, "trv"), infsupdec (-1.2, 12.1, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (-2.0, -1.1, "def"), infsupdec (-5.0, 5.0, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (-2.0, -1.1, "def"), infsupdec (-5.0, 5.0, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (1.1, 2.0, "dac"), infsupdec (-5.0, 5.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (1.1, 2.0, "dac"), infsupdec (-5.0, 5.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (-1.0, 1.0, "com"), infsupdec (-1.2, 12.1, "def")), infsupdec (-1.2, 12.1, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (-1.0, 1.0, "com"), infsupdec (-1.2, 12.1, "def"))){1}, decorationpart (infsupdec (-1.2, 12.1, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (0.0, 0.0, "dac"), infsupdec (-1.0, 1.0, "def")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (0.0, 0.0, "dac"), infsupdec (-1.0, 1.0, "def"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (-0.0, -0.0, "def"), infsupdec (2.0, 2.5, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (-0.0, -0.0, "def"), infsupdec (2.0, 2.5, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (-0.0, -0.0, "def"), infsupdec (3.0, 3.5, "dac")), infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (-0.0, -0.0, "def"), infsupdec (3.0, 3.5, "dac"))){1}, decorationpart (infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (9.999999999999998890e-01, 1.000000000000000000e+00, "dac"), infsupdec (1.57, 1.58, "dac")), infsupdec (1.570796311893735364e+00, 1.570796341696058196e+00, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (9.999999999999998890e-01, 1.000000000000000000e+00, "dac"), infsupdec (1.57, 1.58, "dac"))){1}, decorationpart (infsupdec (1.570796311893735364e+00, 1.570796341696058196e+00, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (0.0, 1.000000000000000000e+00, "com"), infsupdec (-0.1, 1.58, "dac")), infsupdec (0.0, 1.58, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (0.0, 1.000000000000000000e+00, "com"), infsupdec (-0.1, 1.58, "dac"))){1}, decorationpart (infsupdec (0.0, 1.58, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (1.224646799147352961e-16, 1.224646799147353207e-16, "com"), infsupdec (3.14, 3.15, "def")), infsupdec (3.141592653589792672e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (1.224646799147352961e-16, 1.224646799147353207e-16, "com"), infsupdec (3.14, 3.15, "def"))){1}, decorationpart (infsupdec (3.141592653589792672e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (-3.216245299353273201e-16, -3.216245299353272708e-16, "com"), infsupdec (3.14, 3.15, "dac")), infsupdec (3.141592653589793116e+00, 3.141592653589794004e+00, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (-3.216245299353273201e-16, -3.216245299353272708e-16, "com"), infsupdec (3.14, 3.15, "dac"))){1}, decorationpart (infsupdec (3.141592653589793116e+00, 3.141592653589794004e+00, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (-3.216245299353273201e-16, 1.224646799147353207e-16, "dac"), infsupdec (3.14, 3.15, "com")), infsupdec (3.141592653589792672e+00, 3.141592653589794004e+00, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (-3.216245299353273201e-16, 1.224646799147353207e-16, "dac"), infsupdec (3.14, 3.15, "com"))){1}, decorationpart (infsupdec (3.141592653589792672e+00, 3.141592653589794004e+00, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (0.0, 1.0, "def"), infsupdec (-0.1, 3.15, "def")), infsupdec (0.0, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (0.0, 1.0, "def"), infsupdec (-0.1, 3.15, "def"))){1}, decorationpart (infsupdec (0.0, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (0.0, 1.0, "dac"), infsupdec (-0.1, 3.15, "com")), infsupdec (-0.0, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (0.0, 1.0, "dac"), infsupdec (-0.1, 3.15, "com"))){1}, decorationpart (infsupdec (-0.0, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (-3.216245299353273201e-16, 1.0, "def"), infsupdec (-0.1, 3.15, "def")), infsupdec (-3.216245299353273694e-16, 3.141592653589794004e+00, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (-3.216245299353273201e-16, 1.0, "def"), infsupdec (-0.1, 3.15, "def"))){1}, decorationpart (infsupdec (-3.216245299353273694e-16, 3.141592653589794004e+00, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (-3.216245299353273201e-16, 1.0, "com"), infsupdec (0.0, 3.15, "dac")), infsupdec (0.0, 3.141592653589794004e+00, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (-3.216245299353273201e-16, 1.0, "com"), infsupdec (0.0, 3.15, "dac"))){1}, decorationpart (infsupdec (0.0, 3.141592653589794004e+00, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (1.224646799147352961e-16, 1.000000000000000000e+00, "def"), infsupdec (3.14, 3.15, "com")), infsupdec (3.14, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (1.224646799147352961e-16, 1.000000000000000000e+00, "def"), infsupdec (3.14, 3.15, "com"))){1}, decorationpart (infsupdec (3.14, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (-3.216245299353273201e-16, 1.000000000000000000e+00, "dac"), infsupdec (1.57, 3.15, "com")), infsupdec (1.57, 3.141592653589794004e+00, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (-3.216245299353273201e-16, 1.000000000000000000e+00, "dac"), infsupdec (1.57, 3.15, "com"))){1}, decorationpart (infsupdec (1.57, 3.141592653589794004e+00, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (1.224646799147352961e-16, 1.224646799147353207e-16, "com"), infsupdec (-inf, 3.15, "dac")), infsupdec (-inf, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (1.224646799147352961e-16, 1.224646799147353207e-16, "com"), infsupdec (-inf, 3.15, "dac"))){1}, decorationpart (infsupdec (-inf, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (sinrev (infsupdec (-3.216245299353273201e-16, -3.216245299353272708e-16, "com"), infsupdec (3.14, inf, "dac")), infsupdec (3.141592653589793116e+00, inf, "trv"))); %! assert (isequal (decorationpart (sinrev (infsupdec (-3.216245299353273201e-16, -3.216245299353272708e-16, "com"), infsupdec (3.14, inf, "dac"))){1}, decorationpart (infsupdec (3.141592653589793116e+00, inf, "trv")){1})); ## minimal_cosRev_test %!test %! assert (isequal (cosrev (infsup), infsup)); %!test %! assert (isequal (cosrev (infsup (-2.0, -1.1)), infsup)); %!test %! assert (isequal (cosrev (infsup (1.1, 2.0)), infsup)); %!test %! assert (isequal (cosrev (infsup (-1.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (cosrev (infsup (0.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (cosrev (infsup (1.224646799147352961e-16, 1.224646799147353207e-16)), infsup (-inf, inf))); ## minimal_cosRevBin_test %!test %! assert (isequal (cosrev (infsup, infsup (-1.2, 12.1)), infsup)); %!test %! assert (isequal (cosrev (infsup (-2.0, -1.1), infsup (-5.0, 5.0)), infsup)); %!test %! assert (isequal (cosrev (infsup (1.1, 2.0), infsup (-5.0, 5.0)), infsup)); %!test %! assert (isequal (cosrev (infsup (-1.0, 1.0), infsup (-1.2, 12.1)), infsup (-1.2, 12.1))); %!test %! assert (isequal (cosrev (infsup (1.0, 1.0), infsup (-0.1, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (cosrev (infsup (-1.0, -1.0), infsup (3.14, 3.15)), infsup (3.141592653589793116e+00, 3.141592653589794004e+00))); %!test %! assert (isequal (cosrev (infsup (6.123233995736764803e-17, 6.123233995736766036e-17), infsup (1.57, 1.58)), infsup (1.570796326794896336e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (cosrev (infsup (-1.608122649676636601e-16, -1.608122649676636354e-16), infsup (1.57, 1.58)), infsup (1.570796326794896558e+00, 1.570796326794897002e+00))); %!test %! assert (isequal (cosrev (infsup (-1.608122649676636601e-16, 6.123233995736766036e-17), infsup (1.57, 1.58)), infsup (1.570796326794896336e+00, 1.570796326794897002e+00))); %!test %! assert (isequal (cosrev (infsup (6.123233995736764803e-17, 1.0), infsup (-2.0, 2.0)), infsup (-1.570796326794896780e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (cosrev (infsup (6.123233995736764803e-17, 1.0), infsup (0.0, 2.0)), infsup (0.0, 1.570796326794896780e+00))); %!test %! assert (isequal (cosrev (infsup (-1.608122649676636601e-16, 1.0), infsup (-0.1, 1.5708)), infsup (-0.1, 1.570796326794897002e+00))); %!test %! assert (isequal (cosrev (infsup (-1.000000000000000000e+00, -9.999999999999998890e-01), infsup (3.14, 3.15)), infsup (3.141592638688631922e+00, 3.141592668490955198e+00))); %!test %! assert (isequal (cosrev (infsup (-1.000000000000000000e+00, -9.999999999999998890e-01), infsup (-3.15, -3.14)), infsup (-3.141592668490955198e+00, -3.141592638688631922e+00))); %!test %! assert (isequal (cosrev (infsup (-1.000000000000000000e+00, -9.999999999999998890e-01), infsup (9.42, 9.45)), infsup (9.424777945868218154e+00, 9.424777975670542318e+00))); %!test %! assert (isequal (cosrev (infsup (7.648421872844883840e-01, 1.0), infsup (-1.0, 0.1)), infsup (-7.000000000000000666e-01, 0.1))); %!test %! assert (isequal (cosrev (infsup (-4.161468365471424069e-01, 5.403023058681397650e-01), infsup (0.0, 2.1)), infsup (9.999999999999998890e-01, 2.000000000000000444e+00))); %!test %! assert (isequal (cosrev (infsup (1.224646799147352961e-16, 1.224646799147353207e-16), infsup (-inf, 1.58)), infsup (-inf, 1.570796326794896558e+00))); %!test %! assert (isequal (cosrev (infsup (1.224646799147352961e-16, 1.224646799147353207e-16), infsup (-inf, 1.5)), infsup (-inf, -1.570796326794896336e+00))); %!test %! assert (isequal (cosrev (infsup (-3.216245299353273201e-16, -3.216245299353272708e-16), infsup (-1.58, inf)), infsup (-1.570796326794897002e+00, inf))); %!test %! assert (isequal (cosrev (infsup (-3.216245299353273201e-16, -3.216245299353272708e-16), infsup (-1.5, inf)), infsup (1.570796326794896780e+00, inf))); ## minimal_cosRev_dec_test %!test %! assert (isequal (cosrev (infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (-2.0, -1.1, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (-2.0, -1.1, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (1.1, 2.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (1.1, 2.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (-1.0, 1.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (-1.0, 1.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (0.0, 0.0, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (0.0, 0.0, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (1.224646799147352961e-16, 1.224646799147353207e-16, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (1.224646799147352961e-16, 1.224646799147353207e-16, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); ## minimal_cosRev_dec_bin_test %!test %! assert (isequal (cosrev (infsupdec (empty, "trv"), infsupdec (-1.2, 12.1, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (empty, "trv"), infsupdec (-1.2, 12.1, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (-2.0, -1.1, "dac"), infsupdec (-5.0, 5.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (-2.0, -1.1, "dac"), infsupdec (-5.0, 5.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (1.1, 2.0, "dac"), infsupdec (-5.0, 5.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (1.1, 2.0, "dac"), infsupdec (-5.0, 5.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (-1.0, 1.0, "dac"), infsupdec (-1.2, 12.1, "def")), infsupdec (-1.2, 12.1, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (-1.0, 1.0, "dac"), infsupdec (-1.2, 12.1, "def"))){1}, decorationpart (infsupdec (-1.2, 12.1, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (1.0, 1.0, "def"), infsupdec (-0.1, 0.1, "dac")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (1.0, 1.0, "def"), infsupdec (-0.1, 0.1, "dac"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (-1.0, -1.0, "com"), infsupdec (3.14, 3.15, "dac")), infsupdec (3.141592653589793116e+00, 3.141592653589794004e+00, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (-1.0, -1.0, "com"), infsupdec (3.14, 3.15, "dac"))){1}, decorationpart (infsupdec (3.141592653589793116e+00, 3.141592653589794004e+00, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (6.123233995736764803e-17, 6.123233995736766036e-17, "def"), infsupdec (1.57, 1.58, "def")), infsupdec (1.570796326794896336e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (6.123233995736764803e-17, 6.123233995736766036e-17, "def"), infsupdec (1.57, 1.58, "def"))){1}, decorationpart (infsupdec (1.570796326794896336e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (-1.608122649676636601e-16, -1.608122649676636354e-16, "dac"), infsupdec (1.57, 1.58, "dac")), infsupdec (1.570796326794896558e+00, 1.570796326794897002e+00, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (-1.608122649676636601e-16, -1.608122649676636354e-16, "dac"), infsupdec (1.57, 1.58, "dac"))){1}, decorationpart (infsupdec (1.570796326794896558e+00, 1.570796326794897002e+00, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (-1.608122649676636601e-16, 6.123233995736766036e-17, "com"), infsupdec (1.57, 1.58, "dac")), infsupdec (1.570796326794896336e+00, 1.570796326794897002e+00, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (-1.608122649676636601e-16, 6.123233995736766036e-17, "com"), infsupdec (1.57, 1.58, "dac"))){1}, decorationpart (infsupdec (1.570796326794896336e+00, 1.570796326794897002e+00, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (6.123233995736764803e-17, 1.0, "def"), infsupdec (-2.0, 2.0, "com")), infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (6.123233995736764803e-17, 1.0, "def"), infsupdec (-2.0, 2.0, "com"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (6.123233995736764803e-17, 1.0, "dac"), infsupdec (0.0, 2.0, "def")), infsupdec (0.0, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (6.123233995736764803e-17, 1.0, "dac"), infsupdec (0.0, 2.0, "def"))){1}, decorationpart (infsupdec (0.0, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (-1.608122649676636601e-16, 1.0, "def"), infsupdec (-0.1, 1.5708, "dac")), infsupdec (-0.1, 1.570796326794897002e+00, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (-1.608122649676636601e-16, 1.0, "def"), infsupdec (-0.1, 1.5708, "dac"))){1}, decorationpart (infsupdec (-0.1, 1.570796326794897002e+00, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (-1.000000000000000000e+00, -9.999999999999998890e-01, "dac"), infsupdec (3.14, 3.15, "def")), infsupdec (3.141592638688631922e+00, 3.141592668490955198e+00, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (-1.000000000000000000e+00, -9.999999999999998890e-01, "dac"), infsupdec (3.14, 3.15, "def"))){1}, decorationpart (infsupdec (3.141592638688631922e+00, 3.141592668490955198e+00, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (-1.000000000000000000e+00, -9.999999999999998890e-01, "def"), infsupdec (-3.15, -3.14, "com")), infsupdec (-3.141592668490955198e+00, -3.141592638688631922e+00, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (-1.000000000000000000e+00, -9.999999999999998890e-01, "def"), infsupdec (-3.15, -3.14, "com"))){1}, decorationpart (infsupdec (-3.141592668490955198e+00, -3.141592638688631922e+00, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (-1.000000000000000000e+00, -9.999999999999998890e-01, "def"), infsupdec (9.42, 9.45, "dac")), infsupdec (9.424777945868218154e+00, 9.424777975670542318e+00, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (-1.000000000000000000e+00, -9.999999999999998890e-01, "def"), infsupdec (9.42, 9.45, "dac"))){1}, decorationpart (infsupdec (9.424777945868218154e+00, 9.424777975670542318e+00, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (7.648421872844883840e-01, 1.0, "dac"), infsupdec (-1.0, 0.1, "def")), infsupdec (-7.000000000000000666e-01, 0.1, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (7.648421872844883840e-01, 1.0, "dac"), infsupdec (-1.0, 0.1, "def"))){1}, decorationpart (infsupdec (-7.000000000000000666e-01, 0.1, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (-4.161468365471424069e-01, 5.403023058681397650e-01, "com"), infsupdec (0.0, 2.1, "dac")), infsupdec (9.999999999999998890e-01, 2.000000000000000444e+00, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (-4.161468365471424069e-01, 5.403023058681397650e-01, "com"), infsupdec (0.0, 2.1, "dac"))){1}, decorationpart (infsupdec (9.999999999999998890e-01, 2.000000000000000444e+00, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (1.224646799147352961e-16, 1.224646799147353207e-16, "com"), infsupdec (-inf, 1.58, "dac")), infsupdec (-inf, 1.570796326794896558e+00, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (1.224646799147352961e-16, 1.224646799147353207e-16, "com"), infsupdec (-inf, 1.58, "dac"))){1}, decorationpart (infsupdec (-inf, 1.570796326794896558e+00, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (1.224646799147352961e-16, 1.224646799147353207e-16, "def"), infsupdec (-inf, 1.5, "dac")), infsupdec (-inf, -1.570796326794896336e+00, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (1.224646799147352961e-16, 1.224646799147353207e-16, "def"), infsupdec (-inf, 1.5, "dac"))){1}, decorationpart (infsupdec (-inf, -1.570796326794896336e+00, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (-3.216245299353273201e-16, -3.216245299353272708e-16, "dac"), infsupdec (-1.58, inf, "dac")), infsupdec (-1.570796326794897002e+00, inf, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (-3.216245299353273201e-16, -3.216245299353272708e-16, "dac"), infsupdec (-1.58, inf, "dac"))){1}, decorationpart (infsupdec (-1.570796326794897002e+00, inf, "trv")){1})); %!test %! assert (isequal (cosrev (infsupdec (-3.216245299353273201e-16, -3.216245299353272708e-16, "def"), infsupdec (-1.5, inf, "dac")), infsupdec (1.570796326794896780e+00, inf, "trv"))); %! assert (isequal (decorationpart (cosrev (infsupdec (-3.216245299353273201e-16, -3.216245299353272708e-16, "def"), infsupdec (-1.5, inf, "dac"))){1}, decorationpart (infsupdec (1.570796326794896780e+00, inf, "trv")){1})); ## minimal_tanRev_test %!test %! assert (isequal (tanrev (infsup), infsup)); %!test %! assert (isequal (tanrev (infsup (-1.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (tanrev (infsup (-156.0, -12.0)), infsup (-inf, inf))); %!test %! assert (isequal (tanrev (infsup (0.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (tanrev (infsup (1.224646799147352961e-16, 1.224646799147353207e-16)), infsup (-inf, inf))); ## minimal_tanRevBin_test %!test %! assert (isequal (tanrev (infsup, infsup (-1.5708, 1.5708)), infsup)); %!test %! assert (isequal (tanrev (infsup (-inf, inf), infsup (-1.5708, 1.5708)), infsup (-1.5708, 1.5708))); %!test %! assert (isequal (tanrev (infsup (0.0, 0.0), infsup (-1.5708, 1.5708)), infsup (0.0, 0.0))); %!test %! assert (isequal (tanrev (infsup (1.633123935319536800e+16, 1.633123935319537000e+16), infsup (-1.5708, 1.5708)), infsup (-1.570796326794897224e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (tanrev (infsup (-1.224646799147353207e-16, -1.224646799147352961e-16), infsup (3.14, 3.15)), infsup (3.141592653589792672e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (tanrev (infsup (3.216245299353272708e-16, 3.216245299353273201e-16), infsup (-3.15, 3.15)), infsup (-3.141592653589793560e+00, 3.141592653589794004e+00))); %!test %! assert (isequal (tanrev (infsup (-1.633123935309004800e+16, 1.633123935309004800e+16), infsup (-inf, 1.5707965)), infsup (-inf, 1.570796499999999929e+00))); %!test %! assert (isequal (tanrev (infsup (-1.633123935309004800e+16, 1.633123935309004800e+16), infsup (-1.5707965, inf)), infsup (-1.570796499999999929e+00, inf))); %!test %! assert (isequal (tanrev (infsup (-1.633123935309004800e+16, 1.633123935309004800e+16), infsup (-1.5707965, 1.5707965)), infsup (-1.570796499999999929e+00, 1.570796499999999929e+00))); %!test %! assert (isequal (tanrev (infsup (-1.633123935319537000e+16, 1.633123935319537000e+16), infsup (-1.5707965, 1.5707965)), infsup (-1.5707965, 1.5707965))); ## minimal_tanRev_dec_test %!test %! assert (isequal (tanrev (infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (tanrev (infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (tanrev (infsupdec (-1.0, 1.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tanrev (infsupdec (-1.0, 1.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tanrev (infsupdec (-156.0, -12.0, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tanrev (infsupdec (-156.0, -12.0, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tanrev (infsupdec (0.0, 0.0, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tanrev (infsupdec (0.0, 0.0, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tanrev (infsupdec (1.224646799147352961e-16, 1.224646799147353207e-16, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tanrev (infsupdec (1.224646799147352961e-16, 1.224646799147353207e-16, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); ## minimal_tanRev_dec_bin_test %!test %! assert (isequal (tanrev (infsupdec (empty, "trv"), infsupdec (-1.5708, 1.5708, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (tanrev (infsupdec (empty, "trv"), infsupdec (-1.5708, 1.5708, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (tanrev (infsupdec (entire, "def"), infsupdec (-1.5708, 1.5708, "dac")), infsupdec (-1.5708, 1.5708, "trv"))); %! assert (isequal (decorationpart (tanrev (infsupdec (entire, "def"), infsupdec (-1.5708, 1.5708, "dac"))){1}, decorationpart (infsupdec (-1.5708, 1.5708, "trv")){1})); %!test %! assert (isequal (tanrev (infsupdec (0.0, 0.0, "com"), infsupdec (-1.5708, 1.5708, "def")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (tanrev (infsupdec (0.0, 0.0, "com"), infsupdec (-1.5708, 1.5708, "def"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (tanrev (infsupdec (1.633123935319536800e+16, 1.633123935319537000e+16, "dac"), infsupdec (-1.5708, 1.5708, "def")), infsupdec (-1.570796326794897224e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (tanrev (infsupdec (1.633123935319536800e+16, 1.633123935319537000e+16, "dac"), infsupdec (-1.5708, 1.5708, "def"))){1}, decorationpart (infsupdec (-1.570796326794897224e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (tanrev (infsupdec (-1.224646799147353207e-16, -1.224646799147352961e-16, "def"), infsupdec (3.14, 3.15, "dac")), infsupdec (3.141592653589792672e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (tanrev (infsupdec (-1.224646799147353207e-16, -1.224646799147352961e-16, "def"), infsupdec (3.14, 3.15, "dac"))){1}, decorationpart (infsupdec (3.141592653589792672e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (tanrev (infsupdec (3.216245299353272708e-16, 3.216245299353273201e-16, "com"), infsupdec (-3.15, 3.15, "com")), infsupdec (-3.141592653589793560e+00, 3.141592653589794004e+00, "trv"))); %! assert (isequal (decorationpart (tanrev (infsupdec (3.216245299353272708e-16, 3.216245299353273201e-16, "com"), infsupdec (-3.15, 3.15, "com"))){1}, decorationpart (infsupdec (-3.141592653589793560e+00, 3.141592653589794004e+00, "trv")){1})); %!test %! assert (isequal (tanrev (infsupdec (-1.633123935309004800e+16, 1.633123935309004800e+16, "def"), infsupdec (-inf, 1.5707965, "def")), infsupdec (-inf, 1.570796499999999929e+00, "trv"))); %! assert (isequal (decorationpart (tanrev (infsupdec (-1.633123935309004800e+16, 1.633123935309004800e+16, "def"), infsupdec (-inf, 1.5707965, "def"))){1}, decorationpart (infsupdec (-inf, 1.570796499999999929e+00, "trv")){1})); %!test %! assert (isequal (tanrev (infsupdec (-1.633123935309004800e+16, 1.633123935309004800e+16, "com"), infsupdec (-1.5707965, inf, "dac")), infsupdec (-1.570796499999999929e+00, inf, "trv"))); %! assert (isequal (decorationpart (tanrev (infsupdec (-1.633123935309004800e+16, 1.633123935309004800e+16, "com"), infsupdec (-1.5707965, inf, "dac"))){1}, decorationpart (infsupdec (-1.570796499999999929e+00, inf, "trv")){1})); %!test %! assert (isequal (tanrev (infsupdec (-1.633123935309004800e+16, 1.633123935309004800e+16, "com"), infsupdec (-1.5707965, 1.5707965, "com")), infsupdec (-1.570796499999999929e+00, 1.570796499999999929e+00, "trv"))); %! assert (isequal (decorationpart (tanrev (infsupdec (-1.633123935309004800e+16, 1.633123935309004800e+16, "com"), infsupdec (-1.5707965, 1.5707965, "com"))){1}, decorationpart (infsupdec (-1.570796499999999929e+00, 1.570796499999999929e+00, "trv")){1})); %!test %! assert (isequal (tanrev (infsupdec (-1.633123935319537000e+16, 1.633123935319537000e+16, "dac"), infsupdec (-1.5707965, 1.5707965, "def")), infsupdec (-1.5707965, 1.5707965, "trv"))); %! assert (isequal (decorationpart (tanrev (infsupdec (-1.633123935319537000e+16, 1.633123935319537000e+16, "dac"), infsupdec (-1.5707965, 1.5707965, "def"))){1}, decorationpart (infsupdec (-1.5707965, 1.5707965, "trv")){1})); ## minimal_coshRev_test %!test %! assert (isequal (coshrev (infsup), infsup)); %!test %! assert (isequal (coshrev (infsup (1.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (coshrev (infsup (0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (coshrev (infsup (1.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (coshrev (infsup (1.543080634815243712e+00, 1.705784684221513993e+130)), infsup (-3.005632345000000782e+02, 3.005632345000000782e+02))); ## minimal_coshRevBin_test %!test %! assert (isequal (coshrev (infsup, infsup (0.0, inf)), infsup)); %!test %! assert (isequal (coshrev (infsup (1.0, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (coshrev (infsup (0.0, inf), infsup (1.0, 2.0)), infsup (1.0, 2.0))); %!test %! assert (isequal (coshrev (infsup (1.0, 1.0), infsup (1.0, inf)), infsup)); %!test %! assert (isequal (coshrev (infsup (1.543080634815243712e+00, 1.705784684221513993e+130), infsup (-inf, 0.0)), infsup (-3.005632345000000782e+02, -9.999999999999998890e-01))); ## minimal_coshRev_dec_test %!test %! assert (isequal (coshrev (infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (coshrev (infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (coshrev (infsupdec (1.0, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (coshrev (infsupdec (1.0, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (coshrev (infsupdec (0.0, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (coshrev (infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (coshrev (infsupdec (1.0, 1.0, "def")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (coshrev (infsupdec (1.0, 1.0, "def"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (coshrev (infsupdec (1.543080634815243712e+00, 1.705784684221513993e+130, "com")), infsupdec (-3.005632345000000782e+02, 3.005632345000000782e+02, "trv"))); %! assert (isequal (decorationpart (coshrev (infsupdec (1.543080634815243712e+00, 1.705784684221513993e+130, "com"))){1}, decorationpart (infsupdec (-3.005632345000000782e+02, 3.005632345000000782e+02, "trv")){1})); ## minimal_coshRev_dec_bin_test %!test %! assert (isequal (coshrev (infsupdec (empty, "trv"), infsupdec (0.0, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (coshrev (infsupdec (empty, "trv"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (coshrev (infsupdec (1.0, inf, "def"), infsupdec (0.0, inf, "dac")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (coshrev (infsupdec (1.0, inf, "def"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (coshrev (infsupdec (0.0, inf, "def"), infsupdec (1.0, 2.0, "com")), infsupdec (1.0, 2.0, "trv"))); %! assert (isequal (decorationpart (coshrev (infsupdec (0.0, inf, "def"), infsupdec (1.0, 2.0, "com"))){1}, decorationpart (infsupdec (1.0, 2.0, "trv")){1})); %!test %! assert (isequal (coshrev (infsupdec (1.0, 1.0, "dac"), infsupdec (1.0, inf, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (coshrev (infsupdec (1.0, 1.0, "dac"), infsupdec (1.0, inf, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (coshrev (infsupdec (1.543080634815243712e+00, 1.705784684221513993e+130, "com"), infsupdec (-inf, 0.0, "dac")), infsupdec (-3.005632345000000782e+02, -9.999999999999998890e-01, "trv"))); %! assert (isequal (decorationpart (coshrev (infsupdec (1.543080634815243712e+00, 1.705784684221513993e+130, "com"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (-3.005632345000000782e+02, -9.999999999999998890e-01, "trv")){1})); ## minimal_mulRev_test %!test %! assert (isequal (mulrev (infsup, infsup (1.0, 2.0)), infsup)); %!test %! assert (isequal (mulrev (infsup (1.0, 2.0), infsup), infsup)); %!test %! assert (isequal (mulrev (infsup, infsup), infsup)); %!test %! assert (isequal (mulrev (infsup (-2.0, -0.1), infsup (-2.1, -0.4)), infsup (2.000000000000000111e-01, 2.100000000000000000e+01))); %!test %! assert (isequal (mulrev (infsup (-2.0, 0.0), infsup (-2.1, -0.4)), infsup (2.000000000000000111e-01, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, 1.1), infsup (-2.1, -0.4)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, 1.1), infsup (-2.1, -0.4)), infsup (-inf, -3.636363636363635909e-01))); %!test %! assert (isequal (mulrev (infsup (0.01, 1.1), infsup (-2.1, -0.4)), infsup (-2.100000000000000284e+02, -3.636363636363635909e-01))); %!test %! assert (isequal (mulrev (infsup (0.0, 0.0), infsup (-2.1, -0.4)), infsup)); %!test %! assert (isequal (mulrev (infsup (-inf, -0.1), infsup (-2.1, -0.4)), infsup (0.0, 2.100000000000000000e+01))); %!test %! assert (isequal (mulrev (infsup (-inf, 0.0), infsup (-2.1, -0.4)), infsup (0.0, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, 1.1), infsup (-2.1, -0.4)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, inf), infsup (-2.1, -0.4)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, inf), infsup (-2.1, -0.4)), infsup (-inf, 0.0))); %!test %! assert (isequal (mulrev (infsup (0.01, inf), infsup (-2.1, -0.4)), infsup (-2.100000000000000284e+02, 0.0))); %!test %! assert (isequal (mulrev (infsup (-inf, inf), infsup (-2.1, -0.4)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, -0.1), infsup (-2.1, 0.0)), infsup (0.0, 2.100000000000000000e+01))); %!test %! assert (isequal (mulrev (infsup (-2.0, 0.0), infsup (-2.1, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, 1.1), infsup (-2.1, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, 1.1), infsup (-2.1, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.01, 1.1), infsup (-2.1, 0.0)), infsup (-2.100000000000000284e+02, 0.0))); %!test %! assert (isequal (mulrev (infsup (0.0, 0.0), infsup (-2.1, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, -0.1), infsup (-2.1, 0.0)), infsup (0.0, 2.100000000000000000e+01))); %!test %! assert (isequal (mulrev (infsup (-inf, 0.0), infsup (-2.1, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, 1.1), infsup (-2.1, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, inf), infsup (-2.1, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, inf), infsup (-2.1, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.01, inf), infsup (-2.1, 0.0)), infsup (-2.100000000000000284e+02, 0.0))); %!test %! assert (isequal (mulrev (infsup (-inf, inf), infsup (-2.1, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, -0.1), infsup (-2.1, 0.12)), infsup (-1.199999999999999956e+00, 2.100000000000000000e+01))); %!test %! assert (isequal (mulrev (infsup (-2.0, 0.0), infsup (-2.1, 0.12)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, 1.1), infsup (-2.1, 0.12)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, 1.1), infsup (-2.1, 0.12)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.01, 1.1), infsup (-2.1, 0.12)), infsup (-2.100000000000000284e+02, 1.200000000000000000e+01))); %!test %! assert (isequal (mulrev (infsup (0.0, 0.0), infsup (-2.1, 0.12)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, -0.1), infsup (-2.1, 0.12)), infsup (-1.199999999999999956e+00, 2.100000000000000000e+01))); %!test %! assert (isequal (mulrev (infsup (-inf, 0.0), infsup (-2.1, 0.12)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, 1.1), infsup (-2.1, 0.12)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, inf), infsup (-2.1, 0.12)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, inf), infsup (-2.1, 0.12)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.01, inf), infsup (-2.1, 0.12)), infsup (-2.100000000000000284e+02, 1.200000000000000000e+01))); %!test %! assert (isequal (mulrev (infsup (-inf, inf), infsup (-2.1, 0.12)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, -0.1), infsup (0.0, 0.12)), infsup (-1.199999999999999956e+00, 0.0))); %!test %! assert (isequal (mulrev (infsup (-2.0, 0.0), infsup (0.0, 0.12)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, 1.1), infsup (0.0, 0.12)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, 1.1), infsup (0.0, 0.12)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.01, 1.1), infsup (0.0, 0.12)), infsup (0.0, 1.200000000000000000e+01))); %!test %! assert (isequal (mulrev (infsup (0.0, 0.0), infsup (0.0, 0.12)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, -0.1), infsup (0.0, 0.12)), infsup (-1.199999999999999956e+00, 0.0))); %!test %! assert (isequal (mulrev (infsup (-inf, 0.0), infsup (0.0, 0.12)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, 1.1), infsup (0.0, 0.12)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, inf), infsup (0.0, 0.12)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, inf), infsup (0.0, 0.12)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.01, inf), infsup (0.0, 0.12)), infsup (0.0, 1.200000000000000000e+01))); %!test %! assert (isequal (mulrev (infsup (-inf, inf), infsup (0.0, 0.12)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, -0.1), infsup (0.01, 0.12)), infsup (-1.199999999999999956e+00, -5.000000000000000104e-03))); %!test %! assert (isequal (mulrev (infsup (-2.0, 0.0), infsup (0.01, 0.12)), infsup (-inf, -5.000000000000000104e-03))); %!test %! assert (isequal (mulrev (infsup (-2.0, 1.1), infsup (0.01, 0.12)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, 1.1), infsup (0.01, 0.12)), infsup (9.090909090909088733e-03, inf))); %!test %! assert (isequal (mulrev (infsup (0.01, 1.1), infsup (0.01, 0.12)), infsup (9.090909090909088733e-03, 1.200000000000000000e+01))); %!test %! assert (isequal (mulrev (infsup (0.0, 0.0), infsup (0.01, 0.12)), infsup)); %!test %! assert (isequal (mulrev (infsup (-inf, -0.1), infsup (0.01, 0.12)), infsup (-1.199999999999999956e+00, 0.0))); %!test %! assert (isequal (mulrev (infsup (-inf, 0.0), infsup (0.01, 0.12)), infsup (-inf, 0.0))); %!test %! assert (isequal (mulrev (infsup (-inf, 1.1), infsup (0.01, 0.12)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, inf), infsup (0.01, 0.12)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, inf), infsup (0.01, 0.12)), infsup (0.0, inf))); %!test %! assert (isequal (mulrev (infsup (0.01, inf), infsup (0.01, 0.12)), infsup (0.0, 1.200000000000000000e+01))); %!test %! assert (isequal (mulrev (infsup (-inf, inf), infsup (0.01, 0.12)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, -0.1), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (mulrev (infsup (-2.0, 0.0), infsup (0.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, 1.1), infsup (0.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, 1.1), infsup (0.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.01, 1.1), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (mulrev (infsup (0.0, 0.0), infsup (0.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, -0.1), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (mulrev (infsup (-inf, 0.0), infsup (0.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, 1.1), infsup (0.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, inf), infsup (0.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, inf), infsup (0.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.01, inf), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (mulrev (infsup (-inf, inf), infsup (0.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, -0.1), infsup (-inf, -0.1)), infsup (5.000000000000000278e-02, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, 0.0), infsup (-inf, -0.1)), infsup (5.000000000000000278e-02, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, 1.1), infsup (-inf, -0.1)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, 1.1), infsup (-inf, -0.1)), infsup (-inf, -9.090909090909089774e-02))); %!test %! assert (isequal (mulrev (infsup (0.01, 1.1), infsup (-inf, -0.1)), infsup (-inf, -9.090909090909089774e-02))); %!test %! assert (isequal (mulrev (infsup (0.0, 0.0), infsup (-inf, -0.1)), infsup)); %!test %! assert (isequal (mulrev (infsup (-inf, -0.1), infsup (-inf, -0.1)), infsup (0.0, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, 0.0), infsup (-inf, -0.1)), infsup (0.0, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, 1.1), infsup (-inf, -0.1)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, inf), infsup (-inf, -0.1)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, inf), infsup (-inf, -0.1)), infsup (-inf, 0.0))); %!test %! assert (isequal (mulrev (infsup (0.01, inf), infsup (-inf, -0.1)), infsup (-inf, 0.0))); %!test %! assert (isequal (mulrev (infsup (-inf, inf), infsup (-inf, -0.1)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, -0.1), infsup (-inf, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, 0.0), infsup (-inf, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, 1.1), infsup (-inf, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, 1.1), infsup (-inf, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.01, 1.1), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (mulrev (infsup (0.0, 0.0), infsup (-inf, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, -0.1), infsup (-inf, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, 0.0), infsup (-inf, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, 1.1), infsup (-inf, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, inf), infsup (-inf, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, inf), infsup (-inf, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.01, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (mulrev (infsup (-inf, inf), infsup (-inf, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, -0.1), infsup (-inf, 0.3)), infsup (-3.000000000000000000e+00, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, 0.0), infsup (-inf, 0.3)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, 1.1), infsup (-inf, 0.3)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, 1.1), infsup (-inf, 0.3)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.01, 1.1), infsup (-inf, 0.3)), infsup (-inf, 3.000000000000000000e+01))); %!test %! assert (isequal (mulrev (infsup (0.0, 0.0), infsup (-inf, 0.3)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, -0.1), infsup (-inf, 0.3)), infsup (-3.000000000000000000e+00, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, 0.0), infsup (-inf, 0.3)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, 1.1), infsup (-inf, 0.3)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, inf), infsup (-inf, 0.3)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, inf), infsup (-inf, 0.3)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.01, inf), infsup (-inf, 0.3)), infsup (-inf, 3.000000000000000000e+01))); %!test %! assert (isequal (mulrev (infsup (-inf, inf), infsup (-inf, 0.3)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, -0.1), infsup (-0.21, inf)), infsup (-inf, 2.100000000000000089e+00))); %!test %! assert (isequal (mulrev (infsup (-2.0, 0.0), infsup (-0.21, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, 1.1), infsup (-0.21, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, 1.1), infsup (-0.21, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.01, 1.1), infsup (-0.21, inf)), infsup (-2.100000000000000000e+01, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, 0.0), infsup (-0.21, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, -0.1), infsup (-0.21, inf)), infsup (-inf, 2.100000000000000089e+00))); %!test %! assert (isequal (mulrev (infsup (-inf, 0.0), infsup (-0.21, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, 1.1), infsup (-0.21, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, inf), infsup (-0.21, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, inf), infsup (-0.21, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.01, inf), infsup (-0.21, inf)), infsup (-2.100000000000000000e+01, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, inf), infsup (-0.21, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, -0.1), infsup (0.0, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (mulrev (infsup (-2.0, 0.0), infsup (0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, 1.1), infsup (0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, 1.1), infsup (0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.01, 1.1), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, 0.0), infsup (0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, -0.1), infsup (0.0, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (mulrev (infsup (-inf, 0.0), infsup (0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, 1.1), infsup (0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, inf), infsup (0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, inf), infsup (0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.01, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, inf), infsup (0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, -0.1), infsup (0.04, inf)), infsup (-inf, -2.000000000000000042e-02))); %!test %! assert (isequal (mulrev (infsup (-2.0, 0.0), infsup (0.04, inf)), infsup (-inf, -2.000000000000000042e-02))); %!test %! assert (isequal (mulrev (infsup (-2.0, 1.1), infsup (0.04, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, 1.1), infsup (0.04, inf)), infsup (3.636363636363635493e-02, inf))); %!test %! assert (isequal (mulrev (infsup (0.01, 1.1), infsup (0.04, inf)), infsup (3.636363636363635493e-02, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, 0.0), infsup (0.04, inf)), infsup)); %!test %! assert (isequal (mulrev (infsup (-inf, -0.1), infsup (0.04, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (mulrev (infsup (-inf, 0.0), infsup (0.04, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (mulrev (infsup (-inf, 1.1), infsup (0.04, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, inf), infsup (0.04, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, inf), infsup (0.04, inf)), infsup (0.0, inf))); %!test %! assert (isequal (mulrev (infsup (0.01, inf), infsup (0.04, inf)), infsup (0.0, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, inf), infsup (0.04, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, -0.1), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, 0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, 1.1), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, 1.1), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.01, 1.1), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, 0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, -0.1), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, 0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, 1.1), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-2.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (0.01, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (mulrev (infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); ## minimal_mulRevTen_test %!test %! assert (isequal (mulrev (infsup (-2.0, -0.1), infsup (-2.1, -0.4), infsup (-2.1, -0.4)), infsup)); %!test %! assert (isequal (mulrev (infsup (-2.0, 1.1), infsup (-2.1, -0.4), infsup (-2.1, -0.4)), infsup (-2.1, -0.4))); %!test %! assert (isequal (mulrev (infsup (0.01, 1.1), infsup (-2.1, 0.0), infsup (-2.1, 0.0)), infsup (-2.1, 0.0))); %!test %! assert (isequal (mulrev (infsup (-inf, -0.1), infsup (0.0, 0.12), infsup (0.0, 0.12)), infsup (0.0, 0.0))); %!test %! assert (isequal (mulrev (infsup (-2.0, 1.1), infsup (0.04, inf), infsup (0.04, inf)), infsup (0.04, inf))); ## minimal_mulRev_dec_test %!test %! assert (isequal (mulrev (infsupdec (-2.0, -0.1, "dac"), infsupdec (-2.1, -0.4, "dac")), infsupdec (2.000000000000000111e-01, 2.100000000000000000e+01, "trv"))); %! assert (isequal (decorationpart (mulrev (infsupdec (-2.0, -0.1, "dac"), infsupdec (-2.1, -0.4, "dac"))){1}, decorationpart (infsupdec (2.000000000000000111e-01, 2.100000000000000000e+01, "trv")){1})); %!test %! assert (isequal (mulrev (infsupdec (-2.0, -0.1, "def"), infsupdec (-2.1, 0.0, "def")), infsupdec (0.0, 2.100000000000000000e+01, "trv"))); %! assert (isequal (decorationpart (mulrev (infsupdec (-2.0, -0.1, "def"), infsupdec (-2.1, 0.0, "def"))){1}, decorationpart (infsupdec (0.0, 2.100000000000000000e+01, "trv")){1})); %!test %! assert (isequal (mulrev (infsupdec (-2.0, -0.1, "com"), infsupdec (-2.1, 0.12, "dac")), infsupdec (-1.199999999999999956e+00, 2.100000000000000000e+01, "trv"))); %! assert (isequal (decorationpart (mulrev (infsupdec (-2.0, -0.1, "com"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (-1.199999999999999956e+00, 2.100000000000000000e+01, "trv")){1})); %!test %! assert (isequal (mulrev (infsupdec (-inf, -0.1, "dac"), infsupdec (0.0, 0.12, "com")), infsupdec (-1.199999999999999956e+00, 0.0, "trv"))); %! assert (isequal (decorationpart (mulrev (infsupdec (-inf, -0.1, "dac"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (-1.199999999999999956e+00, 0.0, "trv")){1})); %!test %! assert (isequal (mulrev (infsupdec (0.01, 1.1, "def"), infsupdec (0.01, 0.12, "dac")), infsupdec (9.090909090909088733e-03, 1.200000000000000000e+01, "trv"))); %! assert (isequal (decorationpart (mulrev (infsupdec (0.01, 1.1, "def"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (9.090909090909088733e-03, 1.200000000000000000e+01, "trv")){1})); %!test %! assert (isequal (mulrev (infsupdec (0.01, 1.1, "dac"), infsupdec (-inf, 0.3, "def")), infsupdec (-inf, 3.000000000000000000e+01, "trv"))); %! assert (isequal (decorationpart (mulrev (infsupdec (0.01, 1.1, "dac"), infsupdec (-inf, 0.3, "def"))){1}, decorationpart (infsupdec (-inf, 3.000000000000000000e+01, "trv")){1})); %!test %! assert (isequal (mulrev (infsupdec (-inf, -0.1, "trv"), infsupdec (-0.21, inf, "dac")), infsupdec (-inf, 2.100000000000000089e+00, "trv"))); %! assert (isequal (decorationpart (mulrev (infsupdec (-inf, -0.1, "trv"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (-inf, 2.100000000000000089e+00, "trv")){1})); ## minimal_mulRev_dec_ten_test %!test %! assert (isequal (mulrev (infsupdec (-2.0, -0.1, "dac"), infsupdec (-2.1, -0.4, "dac"), infsupdec (-2.1, -0.4, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (mulrev (infsupdec (-2.0, -0.1, "dac"), infsupdec (-2.1, -0.4, "dac"), infsupdec (-2.1, -0.4, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (mulrev (infsupdec (-2.0, 1.1, "def"), infsupdec (-2.1, -0.4, "com"), infsupdec (-2.1, -0.4, "com")), infsupdec (-2.1, -0.4, "trv"))); %! assert (isequal (decorationpart (mulrev (infsupdec (-2.0, 1.1, "def"), infsupdec (-2.1, -0.4, "com"), infsupdec (-2.1, -0.4, "com"))){1}, decorationpart (infsupdec (-2.1, -0.4, "trv")){1})); %!test %! assert (isequal (mulrev (infsupdec (0.01, 1.1, "com"), infsupdec (-2.1, 0.0, "dac"), infsupdec (-2.1, 0.0, "dac")), infsupdec (-2.1, 0.0, "trv"))); %! assert (isequal (decorationpart (mulrev (infsupdec (0.01, 1.1, "com"), infsupdec (-2.1, 0.0, "dac"), infsupdec (-2.1, 0.0, "dac"))){1}, decorationpart (infsupdec (-2.1, 0.0, "trv")){1})); %!test %! assert (isequal (mulrev (infsupdec (-inf, -0.1, "dac"), infsupdec (0.0, 0.12, "com"), infsupdec (0.0, 0.12, "com")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (mulrev (infsupdec (-inf, -0.1, "dac"), infsupdec (0.0, 0.12, "com"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (mulrev (infsupdec (-2.0, 1.1, "def"), infsupdec (0.04, inf, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (0.04, inf, "trv"))); %! assert (isequal (decorationpart (mulrev (infsupdec (-2.0, 1.1, "def"), infsupdec (0.04, inf, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (0.04, inf, "trv")){1})); interval-1.4.1/inst/test/libieeep1788_tests_mul_rev.tst0000644000175000017500000044515212657476047022531 0ustar oliveroliver## DO NOT EDIT! Generated automatically from test/libieeep1788_tests_mul_rev.itl ## by the Interval Testing Framework for IEEE 1788. ## https://github.com/nehmeier/ITF1788/tree/635bff73cc64ff8aab0ff2031ee8a53980be0115 ## ## Copyright 2013-2015 Marco Nehmeier (nehmeier@informatik.uni-wuerzburg.de) ## Copyright 2015-2016 Oliver Heimlich ## ## Original author: Marco Nehmeier (unit tests in libieeep1788, ## original license: Apache License 2.0) ## Converted into portable ITL format by Oliver Heimlich with minor corrections. ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## %!#Test library imports %!#Arithmetic library imports pkg load interval %!#Preamble try; error ("__FILE__"); catch test (lasterror.stack.file, "quiet", stdout); end_try_catch; %!function assert_warn (observed_value, expected_value) %! if (not (isequal (observed_value, expected_value))) %! observed_expression = regexprep (argn(1, :), '\s+$', ''); %! expected_expression = regexprep (argn(2, :), '\s+$', ''); %! observed_as_char = disp (observed_value)(1 : end - 1); %! expected_as_char = disp(expected_value)(1 : end - 1); %! warning ([observed_expression, " != ", expected_expression, ... %! "\n ", observed_as_char, " != ", expected_as_char]); %! endif %!endfunction ## minimal_mulRevToPair_test %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup, infsup (1.0, 2.0)), infsup)); %! assert (isequal (nthargout(2, 2, @mulrev, infsup, infsup (1.0, 2.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (1.0, 2.0), infsup), infsup)); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (1.0, 2.0), infsup), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup, infsup), infsup)); %! assert (isequal (nthargout(2, 2, @mulrev, infsup, infsup), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, -0.1), infsup (-2.1, -0.4)), infsup (2.000000000000000111e-01, 2.100000000000000000e+01))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, -0.1), infsup (-2.1, -0.4)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 0.0), infsup (-2.1, -0.4)), infsup (2.000000000000000111e-01, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 0.0), infsup (-2.1, -0.4)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 1.1), infsup (-2.1, -0.4)), infsup (-inf, -3.636363636363635909e-01))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 1.1), infsup (-2.1, -0.4)), infsup (2.000000000000000111e-01, inf))); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 1.1), infsup (-2.1, -0.4)), infsup (-inf, -3.636363636363635909e-01))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 1.1), infsup (-2.1, -0.4)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, 1.1), infsup (-2.1, -0.4)), infsup (-2.100000000000000284e+02, -3.636363636363635909e-01))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, 1.1), infsup (-2.1, -0.4)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 0.0), infsup (-2.1, -0.4)), infsup)); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 0.0), infsup (-2.1, -0.4)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, -0.1), infsup (-2.1, -0.4)), infsup (0.0, 2.100000000000000000e+01))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, -0.1), infsup (-2.1, -0.4)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 0.0), infsup (-2.1, -0.4)), infsup (0.0, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 0.0), infsup (-2.1, -0.4)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 1.1), infsup (-2.1, -0.4)), infsup (-inf, -3.636363636363635909e-01))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 1.1), infsup (-2.1, -0.4)), infsup (0.0, inf))); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, inf), infsup (-2.1, -0.4)), infsup (-inf, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, inf), infsup (-2.1, -0.4)), infsup (2.000000000000000111e-01, inf))); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, inf), infsup (-2.1, -0.4)), infsup (-inf, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, inf), infsup (-2.1, -0.4)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, inf), infsup (-2.1, -0.4)), infsup (-2.100000000000000284e+02, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, inf), infsup (-2.1, -0.4)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, inf), infsup (-2.1, -0.4)), infsup (-inf, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, inf), infsup (-2.1, -0.4)), infsup (0.0, inf))); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, -0.1), infsup (-2.1, 0.0)), infsup (0.0, 2.100000000000000000e+01))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, -0.1), infsup (-2.1, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 0.0), infsup (-2.1, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 0.0), infsup (-2.1, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 1.1), infsup (-2.1, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 1.1), infsup (-2.1, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 1.1), infsup (-2.1, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 1.1), infsup (-2.1, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, 1.1), infsup (-2.1, 0.0)), infsup (-2.100000000000000284e+02, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, 1.1), infsup (-2.1, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 0.0), infsup (-2.1, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 0.0), infsup (-2.1, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, -0.1), infsup (-2.1, 0.0)), infsup (0.0, 2.100000000000000000e+01))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, -0.1), infsup (-2.1, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 0.0), infsup (-2.1, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 0.0), infsup (-2.1, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 1.1), infsup (-2.1, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 1.1), infsup (-2.1, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, inf), infsup (-2.1, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, inf), infsup (-2.1, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, inf), infsup (-2.1, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, inf), infsup (-2.1, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, inf), infsup (-2.1, 0.0)), infsup (-2.100000000000000284e+02, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, inf), infsup (-2.1, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, inf), infsup (-2.1, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, inf), infsup (-2.1, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, -0.1), infsup (-2.1, 0.12)), infsup (-1.199999999999999956e+00, 2.100000000000000000e+01))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, -0.1), infsup (-2.1, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 0.0), infsup (-2.1, 0.12)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 0.0), infsup (-2.1, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 1.1), infsup (-2.1, 0.12)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 1.1), infsup (-2.1, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 1.1), infsup (-2.1, 0.12)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 1.1), infsup (-2.1, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, 1.1), infsup (-2.1, 0.12)), infsup (-2.100000000000000284e+02, 1.200000000000000000e+01))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, 1.1), infsup (-2.1, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 0.0), infsup (-2.1, 0.12)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 0.0), infsup (-2.1, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, -0.1), infsup (-2.1, 0.12)), infsup (-1.199999999999999956e+00, 2.100000000000000000e+01))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, -0.1), infsup (-2.1, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 0.0), infsup (-2.1, 0.12)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 0.0), infsup (-2.1, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 1.1), infsup (-2.1, 0.12)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 1.1), infsup (-2.1, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, inf), infsup (-2.1, 0.12)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, inf), infsup (-2.1, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, inf), infsup (-2.1, 0.12)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, inf), infsup (-2.1, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, inf), infsup (-2.1, 0.12)), infsup (-2.100000000000000284e+02, 1.200000000000000000e+01))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, inf), infsup (-2.1, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, inf), infsup (-2.1, 0.12)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, inf), infsup (-2.1, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, -0.1), infsup (0.0, 0.12)), infsup (-1.199999999999999956e+00, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, -0.1), infsup (0.0, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 0.0), infsup (0.0, 0.12)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 0.0), infsup (0.0, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 1.1), infsup (0.0, 0.12)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 1.1), infsup (0.0, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 1.1), infsup (0.0, 0.12)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 1.1), infsup (0.0, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, 1.1), infsup (0.0, 0.12)), infsup (0.0, 1.200000000000000000e+01))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, 1.1), infsup (0.0, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 0.0), infsup (0.0, 0.12)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 0.0), infsup (0.0, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, -0.1), infsup (0.0, 0.12)), infsup (-1.199999999999999956e+00, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, -0.1), infsup (0.0, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 0.0), infsup (0.0, 0.12)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 0.0), infsup (0.0, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 1.1), infsup (0.0, 0.12)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 1.1), infsup (0.0, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, inf), infsup (0.0, 0.12)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, inf), infsup (0.0, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, inf), infsup (0.0, 0.12)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, inf), infsup (0.0, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, inf), infsup (0.0, 0.12)), infsup (0.0, 1.200000000000000000e+01))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, inf), infsup (0.0, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, inf), infsup (0.0, 0.12)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, inf), infsup (0.0, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, -0.1), infsup (0.01, 0.12)), infsup (-1.199999999999999956e+00, -5.000000000000000104e-03))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, -0.1), infsup (0.01, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 0.0), infsup (0.01, 0.12)), infsup (-inf, -5.000000000000000104e-03))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 0.0), infsup (0.01, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 1.1), infsup (0.01, 0.12)), infsup (-inf, -5.000000000000000104e-03))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 1.1), infsup (0.01, 0.12)), infsup (9.090909090909088733e-03, inf))); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 1.1), infsup (0.01, 0.12)), infsup (9.090909090909088733e-03, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 1.1), infsup (0.01, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, 1.1), infsup (0.01, 0.12)), infsup (9.090909090909088733e-03, 1.200000000000000000e+01))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, 1.1), infsup (0.01, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 0.0), infsup (0.01, 0.12)), infsup)); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 0.0), infsup (0.01, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, -0.1), infsup (0.01, 0.12)), infsup (-1.199999999999999956e+00, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, -0.1), infsup (0.01, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 0.0), infsup (0.01, 0.12)), infsup (-inf, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 0.0), infsup (0.01, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 1.1), infsup (0.01, 0.12)), infsup (-inf, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 1.1), infsup (0.01, 0.12)), infsup (9.090909090909088733e-03, inf))); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, inf), infsup (0.01, 0.12)), infsup (-inf, -5.000000000000000104e-03))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, inf), infsup (0.01, 0.12)), infsup (0.0, inf))); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, inf), infsup (0.01, 0.12)), infsup (0.0, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, inf), infsup (0.01, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, inf), infsup (0.01, 0.12)), infsup (0.0, 1.200000000000000000e+01))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, inf), infsup (0.01, 0.12)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, inf), infsup (0.01, 0.12)), infsup (-inf, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, inf), infsup (0.01, 0.12)), infsup (0.0, inf))); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, -0.1), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, -0.1), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 0.0), infsup (0.0, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 0.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 1.1), infsup (0.0, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 1.1), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 1.1), infsup (0.0, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 1.1), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, 1.1), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, 1.1), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 0.0), infsup (0.0, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 0.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, -0.1), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, -0.1), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 0.0), infsup (0.0, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 0.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 1.1), infsup (0.0, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 1.1), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, inf), infsup (0.0, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, inf), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, inf), infsup (0.0, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, inf), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, inf), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, inf), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, inf), infsup (0.0, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, inf), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, -0.1), infsup (-inf, -0.1)), infsup (5.000000000000000278e-02, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, -0.1), infsup (-inf, -0.1)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 0.0), infsup (-inf, -0.1)), infsup (5.000000000000000278e-02, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 0.0), infsup (-inf, -0.1)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 1.1), infsup (-inf, -0.1)), infsup (-inf, -9.090909090909089774e-02))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 1.1), infsup (-inf, -0.1)), infsup (5.000000000000000278e-02, inf))); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 1.1), infsup (-inf, -0.1)), infsup (-inf, -9.090909090909089774e-02))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 1.1), infsup (-inf, -0.1)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, 1.1), infsup (-inf, -0.1)), infsup (-inf, -9.090909090909089774e-02))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, 1.1), infsup (-inf, -0.1)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 0.0), infsup (-inf, -0.1)), infsup)); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 0.0), infsup (-inf, -0.1)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, -0.1), infsup (-inf, -0.1)), infsup (0.0, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, -0.1), infsup (-inf, -0.1)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 0.0), infsup (-inf, -0.1)), infsup (0.0, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 0.0), infsup (-inf, -0.1)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 1.1), infsup (-inf, -0.1)), infsup (-inf, -9.090909090909089774e-02))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 1.1), infsup (-inf, -0.1)), infsup (0.0, inf))); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, inf), infsup (-inf, -0.1)), infsup (-inf, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, inf), infsup (-inf, -0.1)), infsup (5.000000000000000278e-02, inf))); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, inf), infsup (-inf, -0.1)), infsup (-inf, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, inf), infsup (-inf, -0.1)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, inf), infsup (-inf, -0.1)), infsup (-inf, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, inf), infsup (-inf, -0.1)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, inf), infsup (-inf, -0.1)), infsup (-inf, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, inf), infsup (-inf, -0.1)), infsup (0.0, inf))); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, -0.1), infsup (-inf, 0.0)), infsup (0.0, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, -0.1), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 0.0), infsup (-inf, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 0.0), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 1.1), infsup (-inf, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 1.1), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 1.1), infsup (-inf, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 1.1), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, 1.1), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, 1.1), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 0.0), infsup (-inf, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 0.0), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, -0.1), infsup (-inf, 0.0)), infsup (0.0, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, -0.1), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 0.0), infsup (-inf, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 0.0), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 1.1), infsup (-inf, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 1.1), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, inf), infsup (-inf, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, inf), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, inf), infsup (-inf, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, inf), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, inf), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, inf), infsup (-inf, 0.0)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, inf), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, -0.1), infsup (-inf, 0.3)), infsup (-3.000000000000000000e+00, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, -0.1), infsup (-inf, 0.3)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 0.0), infsup (-inf, 0.3)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 0.0), infsup (-inf, 0.3)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 1.1), infsup (-inf, 0.3)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 1.1), infsup (-inf, 0.3)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 1.1), infsup (-inf, 0.3)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 1.1), infsup (-inf, 0.3)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, 1.1), infsup (-inf, 0.3)), infsup (-inf, 3.000000000000000000e+01))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, 1.1), infsup (-inf, 0.3)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 0.0), infsup (-inf, 0.3)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 0.0), infsup (-inf, 0.3)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, -0.1), infsup (-inf, 0.3)), infsup (-3.000000000000000000e+00, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, -0.1), infsup (-inf, 0.3)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 0.0), infsup (-inf, 0.3)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 0.0), infsup (-inf, 0.3)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 1.1), infsup (-inf, 0.3)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 1.1), infsup (-inf, 0.3)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, inf), infsup (-inf, 0.3)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, inf), infsup (-inf, 0.3)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, inf), infsup (-inf, 0.3)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, inf), infsup (-inf, 0.3)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, inf), infsup (-inf, 0.3)), infsup (-inf, 3.000000000000000000e+01))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, inf), infsup (-inf, 0.3)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, inf), infsup (-inf, 0.3)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, inf), infsup (-inf, 0.3)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, -0.1), infsup (-0.21, inf)), infsup (-inf, 2.100000000000000089e+00))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, -0.1), infsup (-0.21, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 0.0), infsup (-0.21, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 0.0), infsup (-0.21, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 1.1), infsup (-0.21, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 1.1), infsup (-0.21, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 1.1), infsup (-0.21, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 1.1), infsup (-0.21, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, 1.1), infsup (-0.21, inf)), infsup (-2.100000000000000000e+01, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, 1.1), infsup (-0.21, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 0.0), infsup (-0.21, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 0.0), infsup (-0.21, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, -0.1), infsup (-0.21, inf)), infsup (-inf, 2.100000000000000089e+00))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, -0.1), infsup (-0.21, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 0.0), infsup (-0.21, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 0.0), infsup (-0.21, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 1.1), infsup (-0.21, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 1.1), infsup (-0.21, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, inf), infsup (-0.21, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, inf), infsup (-0.21, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, inf), infsup (-0.21, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, inf), infsup (-0.21, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, inf), infsup (-0.21, inf)), infsup (-2.100000000000000000e+01, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, inf), infsup (-0.21, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, inf), infsup (-0.21, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, inf), infsup (-0.21, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, -0.1), infsup (0.0, inf)), infsup (-inf, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, -0.1), infsup (0.0, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 0.0), infsup (0.0, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 0.0), infsup (0.0, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 1.1), infsup (0.0, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 1.1), infsup (0.0, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 1.1), infsup (0.0, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 1.1), infsup (0.0, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, 1.1), infsup (0.0, inf)), infsup (0.0, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, 1.1), infsup (0.0, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 0.0), infsup (0.0, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 0.0), infsup (0.0, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, -0.1), infsup (0.0, inf)), infsup (-inf, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, -0.1), infsup (0.0, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 0.0), infsup (0.0, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 0.0), infsup (0.0, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 1.1), infsup (0.0, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 1.1), infsup (0.0, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, inf), infsup (0.0, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, inf), infsup (0.0, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, inf), infsup (0.0, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, inf), infsup (0.0, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, inf), infsup (0.0, inf)), infsup (0.0, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, inf), infsup (0.0, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, inf), infsup (0.0, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, inf), infsup (0.0, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, -0.1), infsup (0.04, inf)), infsup (-inf, -2.000000000000000042e-02))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, -0.1), infsup (0.04, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 0.0), infsup (0.04, inf)), infsup (-inf, -2.000000000000000042e-02))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 0.0), infsup (0.04, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 1.1), infsup (0.04, inf)), infsup (-inf, -2.000000000000000042e-02))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 1.1), infsup (0.04, inf)), infsup (3.636363636363635493e-02, inf))); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 1.1), infsup (0.04, inf)), infsup (3.636363636363635493e-02, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 1.1), infsup (0.04, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, 1.1), infsup (0.04, inf)), infsup (3.636363636363635493e-02, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, 1.1), infsup (0.04, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 0.0), infsup (0.04, inf)), infsup)); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 0.0), infsup (0.04, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, -0.1), infsup (0.04, inf)), infsup (-inf, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, -0.1), infsup (0.04, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 0.0), infsup (0.04, inf)), infsup (-inf, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 0.0), infsup (0.04, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 1.1), infsup (0.04, inf)), infsup (-inf, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 1.1), infsup (0.04, inf)), infsup (3.636363636363635493e-02, inf))); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, inf), infsup (0.04, inf)), infsup (-inf, -2.000000000000000042e-02))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, inf), infsup (0.04, inf)), infsup (0.0, inf))); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, inf), infsup (0.04, inf)), infsup (0.0, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, inf), infsup (0.04, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, inf), infsup (0.04, inf)), infsup (0.0, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, inf), infsup (0.04, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, inf), infsup (0.04, inf)), infsup (-inf, 0.0))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, inf), infsup (0.04, inf)), infsup (0.0, inf))); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, -0.1), infsup (-inf, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, -0.1), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 0.0), infsup (-inf, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 0.0), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, 1.1), infsup (-inf, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, 1.1), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 1.1), infsup (-inf, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 1.1), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, 1.1), infsup (-inf, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, 1.1), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, 0.0), infsup (-inf, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, 0.0), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, -0.1), infsup (-inf, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, -0.1), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 0.0), infsup (-inf, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 0.0), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, 1.1), infsup (-inf, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, 1.1), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-2.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-2.0, inf), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.0, inf), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (0.01, inf), infsup (-inf, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (0.01, inf), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); %! assert (isequal (nthargout(2, 2, @mulrev, infsup (-inf, inf), infsup (-inf, inf)), infsup)); ## minimal_mulRevToPair_dec_test %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (empty, "trv"), infsupdec (1.0, 2.0, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (empty, "trv"), infsupdec (1.0, 2.0, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (empty, "trv"), infsupdec (1.0, 2.0, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (empty, "trv"), infsupdec (1.0, 2.0, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (1.0, 2.0, "com"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (1.0, 2.0, "com"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (1.0, 2.0, "com"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (1.0, 2.0, "com"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (empty, "trv"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (empty, "trv"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (empty, "trv"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (empty, "trv"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "com"), infsupdec (-2.1, -0.4, "com")), infsupdec (2.000000000000000111e-01, 2.100000000000000000e+01, "com"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "com"), infsupdec (-2.1, -0.4, "com"))){1}, decorationpart (infsupdec (2.000000000000000111e-01, 2.100000000000000000e+01, "com")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "com"), infsupdec (-2.1, -0.4, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "com"), infsupdec (-2.1, -0.4, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-2.1, -0.4, "com")), infsupdec (2.000000000000000111e-01, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-2.1, -0.4, "com"))){1}, decorationpart (infsupdec (2.000000000000000111e-01, inf, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-2.1, -0.4, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-2.1, -0.4, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "com"), infsupdec (-2.1, -0.4, "dac")), infsupdec (-inf, -3.636363636363635909e-01, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "com"), infsupdec (-2.1, -0.4, "dac"))){1}, decorationpart (infsupdec (-inf, -3.636363636363635909e-01, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "com"), infsupdec (-2.1, -0.4, "dac")), infsupdec (2.000000000000000111e-01, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "com"), infsupdec (-2.1, -0.4, "dac"))){1}, decorationpart (infsupdec (2.000000000000000111e-01, inf, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "trv"), infsupdec (-2.1, -0.4, "def")), infsupdec (-inf, -3.636363636363635909e-01, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "trv"), infsupdec (-2.1, -0.4, "def"))){1}, decorationpart (infsupdec (-inf, -3.636363636363635909e-01, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "trv"), infsupdec (-2.1, -0.4, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "trv"), infsupdec (-2.1, -0.4, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "com"), infsupdec (-2.1, -0.4, "com")), infsupdec (-2.100000000000000284e+02, -3.636363636363635909e-01, "com"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "com"), infsupdec (-2.1, -0.4, "com"))){1}, decorationpart (infsupdec (-2.100000000000000284e+02, -3.636363636363635909e-01, "com")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "com"), infsupdec (-2.1, -0.4, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "com"), infsupdec (-2.1, -0.4, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-2.1, -0.4, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-2.1, -0.4, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-2.1, -0.4, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-2.1, -0.4, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-2.1, -0.4, "dac")), infsupdec (0.0, 2.100000000000000000e+01, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-2.1, -0.4, "dac"))){1}, decorationpart (infsupdec (0.0, 2.100000000000000000e+01, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-2.1, -0.4, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-2.1, -0.4, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "def"), infsupdec (-2.1, -0.4, "com")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "def"), infsupdec (-2.1, -0.4, "com"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "def"), infsupdec (-2.1, -0.4, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "def"), infsupdec (-2.1, -0.4, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "trv"), infsupdec (-2.1, -0.4, "def")), infsupdec (-inf, -3.636363636363635909e-01, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "trv"), infsupdec (-2.1, -0.4, "def"))){1}, decorationpart (infsupdec (-inf, -3.636363636363635909e-01, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "trv"), infsupdec (-2.1, -0.4, "def")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "trv"), infsupdec (-2.1, -0.4, "def"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-2.1, -0.4, "dac")), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-2.1, -0.4, "dac"))){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-2.1, -0.4, "dac")), infsupdec (2.000000000000000111e-01, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-2.1, -0.4, "dac"))){1}, decorationpart (infsupdec (2.000000000000000111e-01, inf, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "def"), infsupdec (-2.1, -0.4, "com")), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "def"), infsupdec (-2.1, -0.4, "com"))){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "def"), infsupdec (-2.1, -0.4, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "def"), infsupdec (-2.1, -0.4, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "def"), infsupdec (-2.1, -0.4, "def")), infsupdec (-2.100000000000000284e+02, 0.0, "def"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "def"), infsupdec (-2.1, -0.4, "def"))){1}, decorationpart (infsupdec (-2.100000000000000284e+02, 0.0, "def")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "def"), infsupdec (-2.1, -0.4, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "def"), infsupdec (-2.1, -0.4, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-2.1, -0.4, "dac")), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-2.1, -0.4, "dac"))){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-2.1, -0.4, "dac")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-2.1, -0.4, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (0.0, 2.100000000000000000e+01, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (0.0, 2.100000000000000000e+01, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (-2.100000000000000284e+02, 0.0, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (-2.100000000000000284e+02, 0.0, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (0.0, 2.100000000000000000e+01, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (0.0, 2.100000000000000000e+01, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (-2.100000000000000284e+02, 0.0, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (-2.100000000000000284e+02, 0.0, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-2.1, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-2.1, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (-1.199999999999999956e+00, 2.100000000000000000e+01, "def"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (-1.199999999999999956e+00, 2.100000000000000000e+01, "def")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (-2.100000000000000284e+02, 1.200000000000000000e+01, "def"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (-2.100000000000000284e+02, 1.200000000000000000e+01, "def")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (-1.199999999999999956e+00, 2.100000000000000000e+01, "def"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (-1.199999999999999956e+00, 2.100000000000000000e+01, "def")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (-2.100000000000000284e+02, 1.200000000000000000e+01, "def"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (-2.100000000000000284e+02, 1.200000000000000000e+01, "def")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (entire, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (entire, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (entire, "def"), infsupdec (-2.1, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (entire, "def"), infsupdec (-2.1, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "com"), infsupdec (0.0, 0.12, "com")), infsupdec (-1.199999999999999956e+00, 0.0, "com"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "com"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (-1.199999999999999956e+00, 0.0, "com")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "com"), infsupdec (0.0, 0.12, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "com"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "com"), infsupdec (0.0, 0.12, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "com"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "com"), infsupdec (0.0, 0.12, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "com"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "com"), infsupdec (0.0, 0.12, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "com"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "com"), infsupdec (0.0, 0.12, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "com"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "com"), infsupdec (0.0, 0.12, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "com"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "com"), infsupdec (0.0, 0.12, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "com"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "com"), infsupdec (0.0, 0.12, "com")), infsupdec (0.0, 1.200000000000000000e+01, "com"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "com"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (0.0, 1.200000000000000000e+01, "com")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "com"), infsupdec (0.0, 0.12, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "com"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "com"), infsupdec (0.0, 0.12, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "com"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "com"), infsupdec (0.0, 0.12, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "com"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (0.0, 0.12, "com")), infsupdec (-1.199999999999999956e+00, 0.0, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (-1.199999999999999956e+00, 0.0, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (0.0, 0.12, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (0.0, 0.12, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (0.0, 0.12, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (0.0, 0.12, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (0.0, 0.12, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (0.0, 0.12, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (0.0, 0.12, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (0.0, 0.12, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (0.0, 0.12, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (0.0, 0.12, "com")), infsupdec (0.0, 1.200000000000000000e+01, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (0.0, 1.200000000000000000e+01, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (0.0, 0.12, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (0.0, 0.12, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (0.0, 0.12, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (0.0, 0.12, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (-1.199999999999999956e+00, -5.000000000000000104e-03, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (-1.199999999999999956e+00, -5.000000000000000104e-03, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (-inf, -5.000000000000000104e-03, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (-inf, -5.000000000000000104e-03, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (-inf, -5.000000000000000104e-03, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (-inf, -5.000000000000000104e-03, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (9.090909090909088733e-03, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (9.090909090909088733e-03, inf, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (9.090909090909088733e-03, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (9.090909090909088733e-03, inf, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (9.090909090909088733e-03, 1.200000000000000000e+01, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (9.090909090909088733e-03, 1.200000000000000000e+01, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (-1.199999999999999956e+00, 0.0, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (-1.199999999999999956e+00, 0.0, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (9.090909090909088733e-03, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (9.090909090909088733e-03, inf, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (-inf, -5.000000000000000104e-03, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (-inf, -5.000000000000000104e-03, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (0.0, 1.200000000000000000e+01, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (0.0, 1.200000000000000000e+01, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (0.01, 0.12, "dac")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (0.01, 0.12, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "com"), infsupdec (0.0, 0.0, "com")), infsupdec (0.0, 0.0, "com"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "com"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "com")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "com"), infsupdec (0.0, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "com"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "com"), infsupdec (0.0, 0.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "com"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "com"), infsupdec (0.0, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "com"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "com"), infsupdec (0.0, 0.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "com"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "com"), infsupdec (0.0, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "com"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "com"), infsupdec (0.0, 0.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "com"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "com"), infsupdec (0.0, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "com"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "com"), infsupdec (0.0, 0.0, "com")), infsupdec (0.0, 0.0, "com"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "com"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "com")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "com"), infsupdec (0.0, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "com"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "com"), infsupdec (0.0, 0.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "com"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "com"), infsupdec (0.0, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "com"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (0.0, 0.0, "com")), infsupdec (0.0, 0.0, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (0.0, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (0.0, 0.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (0.0, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (0.0, 0.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (0.0, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (0.0, 0.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (0.0, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (0.0, 0.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (0.0, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (0.0, 0.0, "com")), infsupdec (0.0, 0.0, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (0.0, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (0.0, 0.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (0.0, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (5.000000000000000278e-02, inf, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (5.000000000000000278e-02, inf, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (5.000000000000000278e-02, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (5.000000000000000278e-02, inf, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (-inf, -9.090909090909089774e-02, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (-inf, -9.090909090909089774e-02, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (5.000000000000000278e-02, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (5.000000000000000278e-02, inf, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (-inf, -9.090909090909089774e-02, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (-inf, -9.090909090909089774e-02, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (-inf, -9.090909090909089774e-02, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (-inf, -9.090909090909089774e-02, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (0.0, inf, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (-inf, -9.090909090909089774e-02, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (-inf, -9.090909090909089774e-02, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (5.000000000000000278e-02, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (5.000000000000000278e-02, inf, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (-inf, 0.0, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (-inf, 0.0, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-inf, -0.1, "dac")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-inf, -0.1, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (0.0, inf, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (-inf, 0.0, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (-inf, 0.0, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (0.0, inf, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (-inf, 0.0, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (-inf, 0.0, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-inf, 0.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (-3.000000000000000000e+00, inf, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (-3.000000000000000000e+00, inf, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (-inf, 3.000000000000000000e+01, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (-inf, 3.000000000000000000e+01, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (-3.000000000000000000e+00, inf, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (-3.000000000000000000e+00, inf, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (-inf, 3.000000000000000000e+01, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (-inf, 3.000000000000000000e+01, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-inf, 0.3, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-inf, 0.3, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (-inf, 2.100000000000000089e+00, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (-inf, 2.100000000000000089e+00, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (-2.100000000000000000e+01, inf, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (-2.100000000000000000e+01, inf, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (-inf, 2.100000000000000089e+00, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (-inf, 2.100000000000000089e+00, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (-2.100000000000000000e+01, inf, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (-2.100000000000000000e+01, inf, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-0.21, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (-0.21, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (-inf, 0.0, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (-inf, 0.0, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (0.0, inf, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (-inf, 0.0, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (-inf, 0.0, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (0.0, inf, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (0.0, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (-inf, -2.000000000000000042e-02, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (-inf, -2.000000000000000042e-02, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (-inf, -2.000000000000000042e-02, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (-inf, -2.000000000000000042e-02, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (-inf, -2.000000000000000042e-02, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (-inf, -2.000000000000000042e-02, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (3.636363636363635493e-02, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (3.636363636363635493e-02, inf, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (3.636363636363635493e-02, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (3.636363636363635493e-02, inf, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (3.636363636363635493e-02, inf, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (3.636363636363635493e-02, inf, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (-inf, 0.0, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (-inf, 0.0, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (3.636363636363635493e-02, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (3.636363636363635493e-02, inf, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (-inf, -2.000000000000000042e-02, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (-inf, -2.000000000000000042e-02, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (0.0, inf, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (0.04, inf, "dac")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (0.04, inf, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (entire, "dac")), infsupdec (entire, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (entire, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (entire, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, -0.1, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (entire, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (entire, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 0.0, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (entire, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (entire, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, 1.1, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (entire, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (entire, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 1.1, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (entire, "dac")), infsupdec (entire, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (entire, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (entire, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, 1.1, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (entire, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (entire, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, 0.0, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (entire, "dac")), infsupdec (entire, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (entire, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (entire, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, -0.1, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (entire, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (entire, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 0.0, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (entire, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (entire, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-inf, 1.1, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (entire, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (entire, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (-2.0, inf, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (entire, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (entire, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.0, inf, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (entire, "dac")), infsupdec (entire, "dac"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (entire, "dac")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (entire, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (0.01, inf, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (entire, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (nthargout(1, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (entire, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (nthargout(2, 2, @mulrev, infsupdec (entire, "dac"), infsupdec (entire, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); interval-1.4.1/inst/test/libieeep1788_tests_cancel.tst0000644000175000017500000016231112657476047022276 0ustar oliveroliver## DO NOT EDIT! Generated automatically from test/libieeep1788_tests_cancel.itl ## by the Interval Testing Framework for IEEE 1788. ## https://github.com/nehmeier/ITF1788/tree/635bff73cc64ff8aab0ff2031ee8a53980be0115 ## ## Copyright 2013-2015 Marco Nehmeier (nehmeier@informatik.uni-wuerzburg.de) ## Copyright 2015-2016 Oliver Heimlich ## ## Original author: Marco Nehmeier (unit tests in libieeep1788, ## original license: Apache License 2.0) ## Converted into portable ITL format by Oliver Heimlich with minor corrections. ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## %!#Test library imports %!#Arithmetic library imports pkg load interval %!#Preamble try; error ("__FILE__"); catch test (lasterror.stack.file, "quiet", stdout); end_try_catch; %!function assert_warn (observed_value, expected_value) %! if (not (isequal (observed_value, expected_value))) %! observed_expression = regexprep (argn(1, :), '\s+$', ''); %! expected_expression = regexprep (argn(2, :), '\s+$', ''); %! observed_as_char = disp (observed_value)(1 : end - 1); %! expected_as_char = disp(expected_value)(1 : end - 1); %! warning ([observed_expression, " != ", expected_expression, ... %! "\n ", observed_as_char, " != ", expected_as_char]); %! endif %!endfunction ## minimal_cancelPlus_test %!test %! assert (isequal (cancelplus (infsup (-inf, -1.0), infsup), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-1.0, inf), infsup), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-inf, inf), infsup), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-inf, -1.0), infsup (-5.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-1.0, inf), infsup (-5.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-inf, inf), infsup (-5.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-inf, -1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup, infsup (1.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup, infsup (-inf, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup, infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-1.0, 5.0), infsup (1.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-1.0, 5.0), infsup (-inf, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-1.0, 5.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-inf, inf), infsup (1.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-inf, inf), infsup (-inf, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-5.0, -1.0), infsup (1.0, 5.1)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-5.0, -1.0), infsup (0.9, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-5.0, -1.0), infsup (0.9, 5.1)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-10.0, 5.0), infsup (-5.0, 10.1)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-10.0, 5.0), infsup (-5.1, 10.0)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-10.0, 5.0), infsup (-5.1, 10.1)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (1.0, 5.0), infsup (-5.0, -0.9)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (1.0, 5.0), infsup (-5.1, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (1.0, 5.0), infsup (-5.1, -0.9)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-10.0, -1.0), infsup), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-10.0, 5.0), infsup), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (1.0, 5.0), infsup), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup, infsup), infsup)); %!test %! assert (isequal (cancelplus (infsup, infsup (1.0, 10.0)), infsup)); %!test %! assert (isequal (cancelplus (infsup, infsup (-5.0, 10.0)), infsup)); %!test %! assert (isequal (cancelplus (infsup, infsup (-5.0, -1.0)), infsup)); %!test %! assert (isequal (cancelplus (infsup (-5.1, -0.0), infsup (0.0, 5.0)), infsup (-9.999999999999964473e-02, 0.0))); %!test %! assert (isequal (cancelplus (infsup (-5.1, -1.0), infsup (1.0, 5.0)), infsup (-9.999999999999964473e-02, 0.0))); %!test %! assert (isequal (cancelplus (infsup (-5.0, -0.9), infsup (1.0, 5.0)), infsup (0.0, 9.999999999999997780e-02))); %!test %! assert (isequal (cancelplus (infsup (-5.1, -0.9), infsup (1.0, 5.0)), infsup (-9.999999999999964473e-02, 9.999999999999997780e-02))); %!test %! assert (isequal (cancelplus (infsup (-5.0, -1.0), infsup (1.0, 5.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (cancelplus (infsup (-10.1, 5.0), infsup (-5.0, 10.0)), infsup (-9.999999999999964473e-02, 0.0))); %!test %! assert (isequal (cancelplus (infsup (-10.0, 5.1), infsup (-5.0, 10.0)), infsup (0.0, 9.999999999999964473e-02))); %!test %! assert (isequal (cancelplus (infsup (-10.1, 5.1), infsup (-5.0, 10.0)), infsup (-9.999999999999964473e-02, 9.999999999999964473e-02))); %!test %! assert (isequal (cancelplus (infsup (-10.0, 5.0), infsup (-5.0, 10.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (cancelplus (infsup (0.9, 5.0), infsup (-5.0, -1.0)), infsup (-9.999999999999997780e-02, 0.0))); %!test %! assert (isequal (cancelplus (infsup (1.0, 5.1), infsup (-5.0, -1.0)), infsup (0.0, 9.999999999999964473e-02))); %!test %! assert (isequal (cancelplus (infsup (0.0, 5.1), infsup (-5.0, -0.0)), infsup (0.0, 9.999999999999964473e-02))); %!test %! assert (isequal (cancelplus (infsup (0.9, 5.1), infsup (-5.0, -1.0)), infsup (-9.999999999999997780e-02, 9.999999999999964473e-02))); %!test %! assert (isequal (cancelplus (infsup (1.0, 5.0), infsup (-5.0, -1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (cancelplus (infsup (0.0, 5.0), infsup (-5.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (cancelplus (infsup (1.999999999999996447e+00, 1.999999999999996447e+00), infsup (-1.000000000000000056e-01, -1.000000000000000056e-01)), infsup (1.899999999999996358e+00, 1.899999999999996581e+00))); %!test %! assert (isequal (cancelplus (infsup (-1.000000000000000056e-01, 1.999999999999996447e+00), infsup (-1.000000000000000056e-01, 0.01)), infsup (-9.000000000000001055e-02, 1.899999999999996581e+00))); %!test %! assert (isequal (cancelplus (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), infsup (1.797693134862315708e+308, 1.797693134862315708e+308)), infsup (1.797693134862315708e+308, inf))); %!test %! assert (isequal (cancelplus (infsup (-1.797693134862315708e+308, 1.797693134862315708e+308), infsup (-1.797693134862315708e+308, 1.797693134862315708e+308)), infsup (0.0, 0.0))); %!test %! assert (isequal (cancelplus (infsup (-1.797693134862315708e+308, 1.797693134862315708e+308), infsup (-1.797693134862315509e+308, 1.797693134862315708e+308)), infsup (0.0, 1.995840309534719812e+292))); %!test %! assert (isequal (cancelplus (infsup (-1.797693134862315708e+308, 1.797693134862315708e+308), infsup (-1.797693134862315708e+308, 1.797693134862315509e+308)), infsup (-1.995840309534719812e+292, 0.0))); %!test %! assert (isequal (cancelplus (infsup (-1.797693134862315708e+308, 1.797693134862315509e+308), infsup (-1.797693134862315708e+308, 1.797693134862315708e+308)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-1.797693134862315509e+308, 1.797693134862315708e+308), infsup (-1.797693134862315708e+308, 1.797693134862315708e+308)), infsup (-inf, inf))); %!test %! assert (isequal (cancelplus (infsup (-1.000000000000000000e+00, 2.220446049250312834e-16), infsup (-1.000000000000000000e+00, 2.220446049250312588e-16)), infsup (-9.999999999999998890e-01, -9.999999999999997780e-01))); %!test %! assert (isequal (cancelplus (infsup (-1.000000000000000000e+00, 2.220446049250312588e-16), infsup (-1.000000000000000000e+00, 2.220446049250312834e-16)), infsup (-inf, inf))); ## minimal_cancelPlus_dec_test %!test %! assert (isequal (cancelplus (infsupdec (-inf, -1.0, "dac"), infsupdec (empty, "trv")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-inf, -1.0, "dac"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-1.0, inf, "def"), infsupdec (empty, "trv")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-1.0, inf, "def"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (entire, "def"), infsupdec (empty, "trv")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (entire, "def"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-inf, -1.0, "dac"), infsupdec (-5.0, 1.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-inf, -1.0, "dac"), infsupdec (-5.0, 1.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-1.0, inf, "trv"), infsupdec (-5.0, 1.0, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-1.0, inf, "trv"), infsupdec (-5.0, 1.0, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (entire, "def"), infsupdec (-5.0, 1.0, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (entire, "def"), infsupdec (-5.0, 1.0, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-inf, -1.0, "dac"), infsupdec (entire, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-inf, -1.0, "dac"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-1.0, inf, "def"), infsupdec (entire, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-1.0, inf, "def"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (empty, "trv"), infsupdec (1.0, inf, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (empty, "trv"), infsupdec (1.0, inf, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (empty, "trv"), infsupdec (-inf, 1.0, "trv")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (empty, "trv"), infsupdec (-inf, 1.0, "trv"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (empty, "trv"), infsupdec (entire, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (empty, "trv"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-1.0, 5.0, "dac"), infsupdec (1.0, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-1.0, 5.0, "dac"), infsupdec (1.0, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-1.0, 5.0, "def"), infsupdec (-inf, 1.0, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-1.0, 5.0, "def"), infsupdec (-inf, 1.0, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-1.0, 5.0, "com"), infsupdec (entire, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-1.0, 5.0, "com"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (entire, "def"), infsupdec (1.0, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (entire, "def"), infsupdec (1.0, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (entire, "def"), infsupdec (-inf, 1.0, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (entire, "def"), infsupdec (-inf, 1.0, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (entire, "def"), infsupdec (entire, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (entire, "def"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-5.0, -1.0, "com"), infsupdec (1.0, 5.1, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-5.0, -1.0, "com"), infsupdec (1.0, 5.1, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-5.0, -1.0, "dac"), infsupdec (0.9, 5.0, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-5.0, -1.0, "dac"), infsupdec (0.9, 5.0, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-5.0, -1.0, "def"), infsupdec (0.9, 5.1, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-5.0, -1.0, "def"), infsupdec (0.9, 5.1, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-10.0, 5.0, "trv"), infsupdec (-5.0, 10.1, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-10.0, 5.0, "trv"), infsupdec (-5.0, 10.1, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-10.0, 5.0, "com"), infsupdec (-5.1, 10.0, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-10.0, 5.0, "com"), infsupdec (-5.1, 10.0, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-10.0, 5.0, "dac"), infsupdec (-5.1, 10.1, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-10.0, 5.0, "dac"), infsupdec (-5.1, 10.1, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (1.0, 5.0, "def"), infsupdec (-5.0, -0.9, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (1.0, 5.0, "def"), infsupdec (-5.0, -0.9, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (1.0, 5.0, "trv"), infsupdec (-5.1, -1.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (1.0, 5.0, "trv"), infsupdec (-5.1, -1.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (1.0, 5.0, "dac"), infsupdec (-5.1, -0.9, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (1.0, 5.0, "dac"), infsupdec (-5.1, -0.9, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-10.0, -1.0, "trv"), infsupdec (empty, "trv")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-10.0, -1.0, "trv"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-10.0, 5.0, "def"), infsupdec (empty, "trv")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-10.0, 5.0, "def"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (1.0, 5.0, "com"), infsupdec (empty, "trv")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (1.0, 5.0, "com"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (empty, "trv"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (empty, "trv"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (empty, "trv"), infsupdec (1.0, 10.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (empty, "trv"), infsupdec (1.0, 10.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (empty, "trv"), infsupdec (-5.0, 10.0, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (empty, "trv"), infsupdec (-5.0, 10.0, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (empty, "trv"), infsupdec (-5.0, -1.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (empty, "trv"), infsupdec (-5.0, -1.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-5.1, -0.0, "com"), infsupdec (0.0, 5.0, "com")), infsupdec (-9.999999999999964473e-02, 0.0, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-5.1, -0.0, "com"), infsupdec (0.0, 5.0, "com"))){1}, decorationpart (infsupdec (-9.999999999999964473e-02, 0.0, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-5.1, -1.0, "com"), infsupdec (1.0, 5.0, "dac")), infsupdec (-9.999999999999964473e-02, 0.0, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-5.1, -1.0, "com"), infsupdec (1.0, 5.0, "dac"))){1}, decorationpart (infsupdec (-9.999999999999964473e-02, 0.0, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-5.0, -0.9, "com"), infsupdec (1.0, 5.0, "def")), infsupdec (0.0, 9.999999999999997780e-02, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-5.0, -0.9, "com"), infsupdec (1.0, 5.0, "def"))){1}, decorationpart (infsupdec (0.0, 9.999999999999997780e-02, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-5.1, -0.9, "dac"), infsupdec (1.0, 5.0, "trv")), infsupdec (-9.999999999999964473e-02, 9.999999999999997780e-02, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-5.1, -0.9, "dac"), infsupdec (1.0, 5.0, "trv"))){1}, decorationpart (infsupdec (-9.999999999999964473e-02, 9.999999999999997780e-02, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-5.0, -1.0, "dac"), infsupdec (1.0, 5.0, "com")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-5.0, -1.0, "dac"), infsupdec (1.0, 5.0, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-10.1, 5.0, "dac"), infsupdec (-5.0, 10.0, "dac")), infsupdec (-9.999999999999964473e-02, 0.0, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-10.1, 5.0, "dac"), infsupdec (-5.0, 10.0, "dac"))){1}, decorationpart (infsupdec (-9.999999999999964473e-02, 0.0, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-10.0, 5.1, "def"), infsupdec (-5.0, 10.0, "def")), infsupdec (0.0, 9.999999999999964473e-02, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-10.0, 5.1, "def"), infsupdec (-5.0, 10.0, "def"))){1}, decorationpart (infsupdec (0.0, 9.999999999999964473e-02, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-10.1, 5.1, "def"), infsupdec (-5.0, 10.0, "trv")), infsupdec (-9.999999999999964473e-02, 9.999999999999964473e-02, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-10.1, 5.1, "def"), infsupdec (-5.0, 10.0, "trv"))){1}, decorationpart (infsupdec (-9.999999999999964473e-02, 9.999999999999964473e-02, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-10.0, 5.0, "def"), infsupdec (-5.0, 10.0, "com")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-10.0, 5.0, "def"), infsupdec (-5.0, 10.0, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (0.9, 5.0, "trv"), infsupdec (-5.0, -1.0, "dac")), infsupdec (-9.999999999999997780e-02, 0.0, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (0.9, 5.0, "trv"), infsupdec (-5.0, -1.0, "dac"))){1}, decorationpart (infsupdec (-9.999999999999997780e-02, 0.0, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (1.0, 5.1, "trv"), infsupdec (-5.0, -1.0, "def")), infsupdec (0.0, 9.999999999999964473e-02, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (1.0, 5.1, "trv"), infsupdec (-5.0, -1.0, "def"))){1}, decorationpart (infsupdec (0.0, 9.999999999999964473e-02, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (0.0, 5.1, "trv"), infsupdec (-5.0, -0.0, "trv")), infsupdec (0.0, 9.999999999999964473e-02, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (0.0, 5.1, "trv"), infsupdec (-5.0, -0.0, "trv"))){1}, decorationpart (infsupdec (0.0, 9.999999999999964473e-02, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (0.9, 5.1, "com"), infsupdec (-5.0, -1.0, "com")), infsupdec (-9.999999999999997780e-02, 9.999999999999964473e-02, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (0.9, 5.1, "com"), infsupdec (-5.0, -1.0, "com"))){1}, decorationpart (infsupdec (-9.999999999999997780e-02, 9.999999999999964473e-02, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (1.0, 5.0, "dac"), infsupdec (-5.0, -1.0, "dac")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (1.0, 5.0, "dac"), infsupdec (-5.0, -1.0, "dac"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (0.0, 5.0, "def"), infsupdec (-5.0, -0.0, "trv")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (0.0, 5.0, "def"), infsupdec (-5.0, -0.0, "trv"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (1.999999999999996447e+00, 1.999999999999996447e+00, "com"), infsupdec (-1.000000000000000056e-01, -1.000000000000000056e-01, "com")), infsupdec (1.899999999999996358e+00, 1.899999999999996581e+00, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (1.999999999999996447e+00, 1.999999999999996447e+00, "com"), infsupdec (-1.000000000000000056e-01, -1.000000000000000056e-01, "com"))){1}, decorationpart (infsupdec (1.899999999999996358e+00, 1.899999999999996581e+00, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-1.000000000000000056e-01, 1.999999999999996447e+00, "dac"), infsupdec (-1.000000000000000056e-01, 0.01, "com")), infsupdec (-9.000000000000001055e-02, 1.899999999999996581e+00, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-1.000000000000000056e-01, 1.999999999999996447e+00, "dac"), infsupdec (-1.000000000000000056e-01, 0.01, "com"))){1}, decorationpart (infsupdec (-9.000000000000001055e-02, 1.899999999999996581e+00, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (1.797693134862315708e+308, 1.797693134862315708e+308, "com"), infsupdec (1.797693134862315708e+308, 1.797693134862315708e+308, "com")), infsupdec (1.797693134862315708e+308, inf, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (1.797693134862315708e+308, 1.797693134862315708e+308, "com"), infsupdec (1.797693134862315708e+308, 1.797693134862315708e+308, "com"))){1}, decorationpart (infsupdec (1.797693134862315708e+308, inf, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "com"), infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "com")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "com"), infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "dac"), infsupdec (-1.797693134862315509e+308, 1.797693134862315708e+308, "com")), infsupdec (0.0, 1.995840309534719812e+292, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "dac"), infsupdec (-1.797693134862315509e+308, 1.797693134862315708e+308, "com"))){1}, decorationpart (infsupdec (0.0, 1.995840309534719812e+292, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "dac"), infsupdec (-1.797693134862315708e+308, 1.797693134862315509e+308, "com")), infsupdec (-1.995840309534719812e+292, 0.0, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "dac"), infsupdec (-1.797693134862315708e+308, 1.797693134862315509e+308, "com"))){1}, decorationpart (infsupdec (-1.995840309534719812e+292, 0.0, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-1.797693134862315708e+308, 1.797693134862315509e+308, "com"), infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-1.797693134862315708e+308, 1.797693134862315509e+308, "com"), infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-1.797693134862315509e+308, 1.797693134862315708e+308, "com"), infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-1.797693134862315509e+308, 1.797693134862315708e+308, "com"), infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-1.000000000000000000e+00, 2.220446049250312834e-16, "dac"), infsupdec (-1.000000000000000000e+00, 2.220446049250312588e-16, "com")), infsupdec (-9.999999999999998890e-01, -9.999999999999997780e-01, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-1.000000000000000000e+00, 2.220446049250312834e-16, "dac"), infsupdec (-1.000000000000000000e+00, 2.220446049250312588e-16, "com"))){1}, decorationpart (infsupdec (-9.999999999999998890e-01, -9.999999999999997780e-01, "trv")){1})); %!test %! assert (isequal (cancelplus (infsupdec (-1.000000000000000000e+00, 2.220446049250312588e-16, "def"), infsupdec (-1.000000000000000000e+00, 2.220446049250312834e-16, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelplus (infsupdec (-1.000000000000000000e+00, 2.220446049250312588e-16, "def"), infsupdec (-1.000000000000000000e+00, 2.220446049250312834e-16, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); ## minimal_cancelMinus_test %!test %! assert (isequal (cancelminus (infsup (-inf, -1.0), infsup), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-1.0, inf), infsup), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-inf, inf), infsup), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-inf, -1.0), infsup (-1.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-1.0, inf), infsup (-1.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-inf, inf), infsup (-1.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-inf, -1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup, infsup (-inf, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup, infsup (-1.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup, infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-1.0, 5.0), infsup (-inf, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-1.0, 5.0), infsup (-1.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-1.0, 5.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-inf, inf), infsup (-inf, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-inf, inf), infsup (-1.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-5.0, -1.0), infsup (-5.1, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-5.0, -1.0), infsup (-5.0, -0.9)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-5.0, -1.0), infsup (-5.1, -0.9)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-10.0, 5.0), infsup (-10.1, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-10.0, 5.0), infsup (-10.0, 5.1)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-10.0, 5.0), infsup (-10.1, 5.1)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (1.0, 5.0), infsup (0.9, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (1.0, 5.0), infsup (1.0, 5.1)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (1.0, 5.0), infsup (0.9, 5.1)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-10.0, -1.0), infsup), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-10.0, 5.0), infsup), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (1.0, 5.0), infsup), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup, infsup), infsup)); %!test %! assert (isequal (cancelminus (infsup, infsup (-10.0, -1.0)), infsup)); %!test %! assert (isequal (cancelminus (infsup, infsup (-10.0, 5.0)), infsup)); %!test %! assert (isequal (cancelminus (infsup, infsup (1.0, 5.0)), infsup)); %!test %! assert (isequal (cancelminus (infsup (-5.1, -0.0), infsup (-5.0, 0.0)), infsup (-9.999999999999964473e-02, 0.0))); %!test %! assert (isequal (cancelminus (infsup (-5.1, -1.0), infsup (-5.0, -1.0)), infsup (-9.999999999999964473e-02, 0.0))); %!test %! assert (isequal (cancelminus (infsup (-5.0, -0.9), infsup (-5.0, -1.0)), infsup (0.0, 9.999999999999997780e-02))); %!test %! assert (isequal (cancelminus (infsup (-5.1, -0.9), infsup (-5.0, -1.0)), infsup (-9.999999999999964473e-02, 9.999999999999997780e-02))); %!test %! assert (isequal (cancelminus (infsup (-5.0, -1.0), infsup (-5.0, -1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (cancelminus (infsup (-10.1, 5.0), infsup (-10.0, 5.0)), infsup (-9.999999999999964473e-02, 0.0))); %!test %! assert (isequal (cancelminus (infsup (-10.0, 5.1), infsup (-10.0, 5.0)), infsup (0.0, 9.999999999999964473e-02))); %!test %! assert (isequal (cancelminus (infsup (-10.1, 5.1), infsup (-10.0, 5.0)), infsup (-9.999999999999964473e-02, 9.999999999999964473e-02))); %!test %! assert (isequal (cancelminus (infsup (-10.0, 5.0), infsup (-10.0, 5.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (cancelminus (infsup (0.9, 5.0), infsup (1.0, 5.0)), infsup (-9.999999999999997780e-02, 0.0))); %!test %! assert (isequal (cancelminus (infsup (-0.0, 5.1), infsup (0.0, 5.0)), infsup (0.0, 9.999999999999964473e-02))); %!test %! assert (isequal (cancelminus (infsup (1.0, 5.1), infsup (1.0, 5.0)), infsup (0.0, 9.999999999999964473e-02))); %!test %! assert (isequal (cancelminus (infsup (0.9, 5.1), infsup (1.0, 5.0)), infsup (-9.999999999999997780e-02, 9.999999999999964473e-02))); %!test %! assert (isequal (cancelminus (infsup (1.0, 5.0), infsup (1.0, 5.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (cancelminus (infsup (-5.0, 1.0), infsup (-1.0, 5.0)), infsup (-4.0, -4.0))); %!test %! assert (isequal (cancelminus (infsup (-5.0, 0.0), infsup (-0.0, 5.0)), infsup (-5.0, -5.0))); %!test %! assert (isequal (cancelminus (infsup (1.999999999999996447e+00, 1.999999999999996447e+00), infsup (1.000000000000000056e-01, 1.000000000000000056e-01)), infsup (1.899999999999996358e+00, 1.899999999999996581e+00))); %!test %! assert (isequal (cancelminus (infsup (-1.000000000000000056e-01, 1.999999999999996447e+00), infsup (-0.01, 1.000000000000000056e-01)), infsup (-9.000000000000001055e-02, 1.899999999999996581e+00))); %!test %! assert (isequal (cancelminus (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), infsup (-1.797693134862315708e+308, -1.797693134862315708e+308)), infsup (1.797693134862315708e+308, inf))); %!test %! assert (isequal (cancelminus (infsup (-1.797693134862315708e+308, 1.797693134862315708e+308), infsup (-1.797693134862315708e+308, 1.797693134862315708e+308)), infsup (0.0, 0.0))); %!test %! assert (isequal (cancelminus (infsup (-1.797693134862315708e+308, 1.797693134862315708e+308), infsup (-1.797693134862315708e+308, 1.797693134862315509e+308)), infsup (0.0, 1.995840309534719812e+292))); %!test %! assert (isequal (cancelminus (infsup (-1.797693134862315708e+308, 1.797693134862315708e+308), infsup (-1.797693134862315509e+308, 1.797693134862315708e+308)), infsup (-1.995840309534719812e+292, 0.0))); %!test %! assert (isequal (cancelminus (infsup (-1.797693134862315708e+308, 1.797693134862315509e+308), infsup (-1.797693134862315708e+308, 1.797693134862315708e+308)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-1.797693134862315509e+308, 1.797693134862315708e+308), infsup (-1.797693134862315708e+308, 1.797693134862315708e+308)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (4.940656458412465442e-324, 4.940656458412465442e-324), infsup (4.940656458412465442e-324, 4.940656458412465442e-324)), infsup (0.0, 0.0))); %!test %! assert (isequal (cancelminus (infsup (4.940656458412465442e-324, 4.940656458412465442e-324), infsup (-4.940656458412465442e-324, -4.940656458412465442e-324)), infsup (9.881312916824930884e-324, 9.881312916824930884e-324))); %!test %! assert (isequal (cancelminus (infsup (2.225073858507201383e-308, 2.225073858507202371e-308), infsup (2.225073858507201383e-308, 2.225073858507201877e-308)), infsup (0.0, 4.940656458412465442e-324))); %!test %! assert (isequal (cancelminus (infsup (2.225073858507201383e-308, 2.225073858507201877e-308), infsup (2.225073858507201383e-308, 2.225073858507202371e-308)), infsup (-inf, inf))); %!test %! assert (isequal (cancelminus (infsup (-1.000000000000000000e+00, 2.220446049250312834e-16), infsup (-2.220446049250312588e-16, 1.000000000000000000e+00)), infsup (-9.999999999999998890e-01, -9.999999999999997780e-01))); %!test %! assert (isequal (cancelminus (infsup (-1.000000000000000000e+00, 2.220446049250312588e-16), infsup (-2.220446049250312834e-16, 1.000000000000000000e+00)), infsup (-inf, inf))); ## minimal_cancelMinus_dec_test %!test %! assert (isequal (cancelminus (infsupdec (-inf, -1.0, "dac"), infsupdec (empty, "trv")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-inf, -1.0, "dac"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-1.0, inf, "def"), infsupdec (empty, "trv")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-1.0, inf, "def"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (entire, "def"), infsupdec (empty, "trv")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (entire, "def"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-inf, -1.0, "trv"), infsupdec (-1.0, 5.0, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-inf, -1.0, "trv"), infsupdec (-1.0, 5.0, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-1.0, inf, "dac"), infsupdec (-1.0, 5.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-1.0, inf, "dac"), infsupdec (-1.0, 5.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (entire, "def"), infsupdec (-1.0, 5.0, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (entire, "def"), infsupdec (-1.0, 5.0, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-inf, -1.0, "def"), infsupdec (entire, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-inf, -1.0, "def"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-1.0, inf, "trv"), infsupdec (entire, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-1.0, inf, "trv"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (empty, "trv"), infsupdec (-inf, -1.0, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (empty, "trv"), infsupdec (-inf, -1.0, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (empty, "trv"), infsupdec (-1.0, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (empty, "trv"), infsupdec (-1.0, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (empty, "trv"), infsupdec (entire, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (empty, "trv"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-1.0, 5.0, "dac"), infsupdec (-inf, -1.0, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-1.0, 5.0, "dac"), infsupdec (-inf, -1.0, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-1.0, 5.0, "def"), infsupdec (-1.0, inf, "trv")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-1.0, 5.0, "def"), infsupdec (-1.0, inf, "trv"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-1.0, 5.0, "com"), infsupdec (entire, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-1.0, 5.0, "com"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (entire, "def"), infsupdec (-inf, -1.0, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (entire, "def"), infsupdec (-inf, -1.0, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (entire, "def"), infsupdec (-1.0, inf, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (entire, "def"), infsupdec (-1.0, inf, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (entire, "def"), infsupdec (entire, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (entire, "def"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-5.0, -1.0, "com"), infsupdec (-5.1, -1.0, "trv")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-5.0, -1.0, "com"), infsupdec (-5.1, -1.0, "trv"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-5.0, -1.0, "dac"), infsupdec (-5.0, -0.9, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-5.0, -1.0, "dac"), infsupdec (-5.0, -0.9, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-5.0, -1.0, "def"), infsupdec (-5.1, -0.9, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-5.0, -1.0, "def"), infsupdec (-5.1, -0.9, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-10.0, 5.0, "trv"), infsupdec (-10.1, 5.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-10.0, 5.0, "trv"), infsupdec (-10.1, 5.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-10.0, 5.0, "com"), infsupdec (-10.0, 5.1, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-10.0, 5.0, "com"), infsupdec (-10.0, 5.1, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-10.0, 5.0, "dac"), infsupdec (-10.1, 5.1, "trv")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-10.0, 5.0, "dac"), infsupdec (-10.1, 5.1, "trv"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (1.0, 5.0, "def"), infsupdec (0.9, 5.0, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (1.0, 5.0, "def"), infsupdec (0.9, 5.0, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (1.0, 5.0, "trv"), infsupdec (1.0, 5.1, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (1.0, 5.0, "trv"), infsupdec (1.0, 5.1, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (1.0, 5.0, "com"), infsupdec (0.9, 5.1, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (1.0, 5.0, "com"), infsupdec (0.9, 5.1, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-10.0, -1.0, "com"), infsupdec (empty, "trv")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-10.0, -1.0, "com"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-10.0, 5.0, "dac"), infsupdec (empty, "trv")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-10.0, 5.0, "dac"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (1.0, 5.0, "def"), infsupdec (empty, "trv")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (1.0, 5.0, "def"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (empty, "trv"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (empty, "trv"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (empty, "trv"), infsupdec (-10.0, -1.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (empty, "trv"), infsupdec (-10.0, -1.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (empty, "trv"), infsupdec (-10.0, 5.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (empty, "trv"), infsupdec (-10.0, 5.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (empty, "trv"), infsupdec (1.0, 5.0, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (empty, "trv"), infsupdec (1.0, 5.0, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-5.1, -0.0, "com"), infsupdec (-5.0, 0.0, "com")), infsupdec (-9.999999999999964473e-02, 0.0, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-5.1, -0.0, "com"), infsupdec (-5.0, 0.0, "com"))){1}, decorationpart (infsupdec (-9.999999999999964473e-02, 0.0, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-5.1, -1.0, "dac"), infsupdec (-5.0, -1.0, "com")), infsupdec (-9.999999999999964473e-02, 0.0, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-5.1, -1.0, "dac"), infsupdec (-5.0, -1.0, "com"))){1}, decorationpart (infsupdec (-9.999999999999964473e-02, 0.0, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-5.0, -0.9, "def"), infsupdec (-5.0, -1.0, "com")), infsupdec (0.0, 9.999999999999997780e-02, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-5.0, -0.9, "def"), infsupdec (-5.0, -1.0, "com"))){1}, decorationpart (infsupdec (0.0, 9.999999999999997780e-02, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-5.1, -0.9, "trv"), infsupdec (-5.0, -1.0, "com")), infsupdec (-9.999999999999964473e-02, 9.999999999999997780e-02, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-5.1, -0.9, "trv"), infsupdec (-5.0, -1.0, "com"))){1}, decorationpart (infsupdec (-9.999999999999964473e-02, 9.999999999999997780e-02, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-5.0, -1.0, "com"), infsupdec (-5.0, -1.0, "dac")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-5.0, -1.0, "com"), infsupdec (-5.0, -1.0, "dac"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-10.1, 5.0, "dac"), infsupdec (-10.0, 5.0, "dac")), infsupdec (-9.999999999999964473e-02, 0.0, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-10.1, 5.0, "dac"), infsupdec (-10.0, 5.0, "dac"))){1}, decorationpart (infsupdec (-9.999999999999964473e-02, 0.0, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-10.0, 5.1, "def"), infsupdec (-10.0, 5.0, "dac")), infsupdec (0.0, 9.999999999999964473e-02, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-10.0, 5.1, "def"), infsupdec (-10.0, 5.0, "dac"))){1}, decorationpart (infsupdec (0.0, 9.999999999999964473e-02, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-10.1, 5.1, "trv"), infsupdec (-10.0, 5.0, "def")), infsupdec (-9.999999999999964473e-02, 9.999999999999964473e-02, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-10.1, 5.1, "trv"), infsupdec (-10.0, 5.0, "def"))){1}, decorationpart (infsupdec (-9.999999999999964473e-02, 9.999999999999964473e-02, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-10.0, 5.0, "com"), infsupdec (-10.0, 5.0, "def")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-10.0, 5.0, "com"), infsupdec (-10.0, 5.0, "def"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (0.9, 5.0, "dac"), infsupdec (1.0, 5.0, "def")), infsupdec (-9.999999999999997780e-02, 0.0, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (0.9, 5.0, "dac"), infsupdec (1.0, 5.0, "def"))){1}, decorationpart (infsupdec (-9.999999999999997780e-02, 0.0, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-0.0, 5.1, "def"), infsupdec (0.0, 5.0, "def")), infsupdec (0.0, 9.999999999999964473e-02, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-0.0, 5.1, "def"), infsupdec (0.0, 5.0, "def"))){1}, decorationpart (infsupdec (0.0, 9.999999999999964473e-02, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (1.0, 5.1, "trv"), infsupdec (1.0, 5.0, "trv")), infsupdec (0.0, 9.999999999999964473e-02, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (1.0, 5.1, "trv"), infsupdec (1.0, 5.0, "trv"))){1}, decorationpart (infsupdec (0.0, 9.999999999999964473e-02, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (0.9, 5.1, "com"), infsupdec (1.0, 5.0, "trv")), infsupdec (-9.999999999999997780e-02, 9.999999999999964473e-02, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (0.9, 5.1, "com"), infsupdec (1.0, 5.0, "trv"))){1}, decorationpart (infsupdec (-9.999999999999997780e-02, 9.999999999999964473e-02, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (1.0, 5.0, "dac"), infsupdec (1.0, 5.0, "com")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (1.0, 5.0, "dac"), infsupdec (1.0, 5.0, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-5.0, 1.0, "def"), infsupdec (-1.0, 5.0, "def")), infsupdec (-4.0, -4.0, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-5.0, 1.0, "def"), infsupdec (-1.0, 5.0, "def"))){1}, decorationpart (infsupdec (-4.0, -4.0, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-5.0, 0.0, "trv"), infsupdec (-0.0, 5.0, "trv")), infsupdec (-5.0, -5.0, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-5.0, 0.0, "trv"), infsupdec (-0.0, 5.0, "trv"))){1}, decorationpart (infsupdec (-5.0, -5.0, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (1.999999999999996447e+00, 1.999999999999996447e+00, "com"), infsupdec (1.000000000000000056e-01, 1.000000000000000056e-01, "com")), infsupdec (1.899999999999996358e+00, 1.899999999999996581e+00, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (1.999999999999996447e+00, 1.999999999999996447e+00, "com"), infsupdec (1.000000000000000056e-01, 1.000000000000000056e-01, "com"))){1}, decorationpart (infsupdec (1.899999999999996358e+00, 1.899999999999996581e+00, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-1.000000000000000056e-01, 1.999999999999996447e+00, "def"), infsupdec (-0.01, 1.000000000000000056e-01, "dac")), infsupdec (-9.000000000000001055e-02, 1.899999999999996581e+00, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-1.000000000000000056e-01, 1.999999999999996447e+00, "def"), infsupdec (-0.01, 1.000000000000000056e-01, "dac"))){1}, decorationpart (infsupdec (-9.000000000000001055e-02, 1.899999999999996581e+00, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (1.797693134862315708e+308, 1.797693134862315708e+308, "com"), infsupdec (-1.797693134862315708e+308, -1.797693134862315708e+308, "com")), infsupdec (1.797693134862315708e+308, inf, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (1.797693134862315708e+308, 1.797693134862315708e+308, "com"), infsupdec (-1.797693134862315708e+308, -1.797693134862315708e+308, "com"))){1}, decorationpart (infsupdec (1.797693134862315708e+308, inf, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "com"), infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "com")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "com"), infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "com"), infsupdec (-1.797693134862315708e+308, 1.797693134862315509e+308, "com")), infsupdec (0.0, 1.995840309534719812e+292, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "com"), infsupdec (-1.797693134862315708e+308, 1.797693134862315509e+308, "com"))){1}, decorationpart (infsupdec (0.0, 1.995840309534719812e+292, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "com"), infsupdec (-1.797693134862315509e+308, 1.797693134862315708e+308, "com")), infsupdec (-1.995840309534719812e+292, 0.0, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "com"), infsupdec (-1.797693134862315509e+308, 1.797693134862315708e+308, "com"))){1}, decorationpart (infsupdec (-1.995840309534719812e+292, 0.0, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-1.797693134862315708e+308, 1.797693134862315509e+308, "com"), infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-1.797693134862315708e+308, 1.797693134862315509e+308, "com"), infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-1.797693134862315509e+308, 1.797693134862315708e+308, "com"), infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-1.797693134862315509e+308, 1.797693134862315708e+308, "com"), infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (4.940656458412465442e-324, 4.940656458412465442e-324, "com"), infsupdec (4.940656458412465442e-324, 4.940656458412465442e-324, "com")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (4.940656458412465442e-324, 4.940656458412465442e-324, "com"), infsupdec (4.940656458412465442e-324, 4.940656458412465442e-324, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (4.940656458412465442e-324, 4.940656458412465442e-324, "com"), infsupdec (-4.940656458412465442e-324, -4.940656458412465442e-324, "dac")), infsupdec (9.881312916824930884e-324, 9.881312916824930884e-324, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (4.940656458412465442e-324, 4.940656458412465442e-324, "com"), infsupdec (-4.940656458412465442e-324, -4.940656458412465442e-324, "dac"))){1}, decorationpart (infsupdec (9.881312916824930884e-324, 9.881312916824930884e-324, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (2.225073858507201383e-308, 2.225073858507202371e-308, "dac"), infsupdec (2.225073858507201383e-308, 2.225073858507201877e-308, "dac")), infsupdec (0.0, 4.940656458412465442e-324, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (2.225073858507201383e-308, 2.225073858507202371e-308, "dac"), infsupdec (2.225073858507201383e-308, 2.225073858507201877e-308, "dac"))){1}, decorationpart (infsupdec (0.0, 4.940656458412465442e-324, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (2.225073858507201383e-308, 2.225073858507201877e-308, "def"), infsupdec (2.225073858507201383e-308, 2.225073858507202371e-308, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (2.225073858507201383e-308, 2.225073858507201877e-308, "def"), infsupdec (2.225073858507201383e-308, 2.225073858507202371e-308, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-1.000000000000000000e+00, 2.220446049250312834e-16, "com"), infsupdec (-2.220446049250312588e-16, 1.000000000000000000e+00, "dac")), infsupdec (-9.999999999999998890e-01, -9.999999999999997780e-01, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-1.000000000000000000e+00, 2.220446049250312834e-16, "com"), infsupdec (-2.220446049250312588e-16, 1.000000000000000000e+00, "dac"))){1}, decorationpart (infsupdec (-9.999999999999998890e-01, -9.999999999999997780e-01, "trv")){1})); %!test %! assert (isequal (cancelminus (infsupdec (-1.000000000000000000e+00, 2.220446049250312588e-16, "def"), infsupdec (-2.220446049250312834e-16, 1.000000000000000000e+00, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (cancelminus (infsupdec (-1.000000000000000000e+00, 2.220446049250312588e-16, "def"), infsupdec (-2.220446049250312834e-16, 1.000000000000000000e+00, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); interval-1.4.1/inst/test/libieeep1788_tests_rec_bool.tst0000644000175000017500000002514712657476050022634 0ustar oliveroliver## DO NOT EDIT! Generated automatically from test/libieeep1788_tests_rec_bool.itl ## by the Interval Testing Framework for IEEE 1788. ## https://github.com/nehmeier/ITF1788/tree/635bff73cc64ff8aab0ff2031ee8a53980be0115 ## ## Copyright 2013-2015 Marco Nehmeier (nehmeier@informatik.uni-wuerzburg.de) ## Copyright 2015-2016 Oliver Heimlich ## ## Original author: Marco Nehmeier (unit tests in libieeep1788, ## original license: Apache License 2.0) ## Converted into portable ITL format by Oliver Heimlich with minor corrections. ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## %!#Test library imports %!#Arithmetic library imports pkg load interval %!#Preamble try; error ("__FILE__"); catch test (lasterror.stack.file, "quiet", stdout); end_try_catch; %!function assert_warn (observed_value, expected_value) %! if (not (isequal (observed_value, expected_value))) %! observed_expression = regexprep (argn(1, :), '\s+$', ''); %! expected_expression = regexprep (argn(2, :), '\s+$', ''); %! observed_as_char = disp (observed_value)(1 : end - 1); %! expected_as_char = disp(expected_value)(1 : end - 1); %! warning ([observed_expression, " != ", expected_expression, ... %! "\n ", observed_as_char, " != ", expected_as_char]); %! endif %!endfunction ## minimal_isCommonInterval_test %!test %! assert (iscommoninterval (infsup (-27.0, -27.0))); %!test %! assert (iscommoninterval (infsup (-27.0, 0.0))); %!test %! assert (iscommoninterval (infsup (0.0, 0.0))); %!test %! assert (iscommoninterval (infsup (-0.0, -0.0))); %!test %! assert (iscommoninterval (infsup (-0.0, 0.0))); %!test %! assert (iscommoninterval (infsup (0.0, -0.0))); %!test %! assert (iscommoninterval (infsup (5.0, 12.4))); %!test %! assert (iscommoninterval (infsup (-1.797693134862315708e+308, 1.797693134862315708e+308))); %!test %! assert (isequal (iscommoninterval (infsup (-inf, inf)), false)); %!test %! assert (isequal (iscommoninterval (infsup), false)); %!test %! assert (isequal (iscommoninterval (infsup (-inf, 0.0)), false)); %!test %! assert (isequal (iscommoninterval (infsup (0.0, inf)), false)); ## minimal_isCommonInterval_dec_test %!test %! assert (iscommoninterval (infsupdec (-27.0, -27.0, "com"))); %!test %! assert (iscommoninterval (infsupdec (-27.0, 0.0, "com"))); %!test %! assert (iscommoninterval (infsupdec (0.0, 0.0, "com"))); %!test %! assert (iscommoninterval (infsupdec (-0.0, -0.0, "com"))); %!test %! assert (iscommoninterval (infsupdec (-0.0, 0.0, "com"))); %!test %! assert (iscommoninterval (infsupdec (0.0, -0.0, "com"))); %!test %! assert (iscommoninterval (infsupdec (5.0, 12.4, "com"))); %!test %! assert (iscommoninterval (infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "com"))); %!test %! assert (iscommoninterval (infsupdec (-27.0, -27.0, "trv"))); %!test %! assert (iscommoninterval (infsupdec (-27.0, 0.0, "def"))); %!test %! assert (iscommoninterval (infsupdec (0.0, 0.0, "dac"))); %!test %! assert (iscommoninterval (infsupdec (-0.0, -0.0, "trv"))); %!test %! assert (iscommoninterval (infsupdec (-0.0, 0.0, "def"))); %!test %! assert (iscommoninterval (infsupdec (0.0, -0.0, "dac"))); %!test %! assert (iscommoninterval (infsupdec (5.0, 12.4, "def"))); %!test %! assert (iscommoninterval (infsupdec (-1.797693134862315708e+308, 1.797693134862315708e+308, "trv"))); %!test %! assert (isequal (iscommoninterval (infsupdec (entire, "dac")), false)); %!test %! assert (isequal (iscommoninterval (infsupdec (empty, "trv")), false)); %!test %! assert (isequal (iscommoninterval (infsupdec (empty, "trv")), false)); %!test %! assert (isequal (iscommoninterval (infsupdec (-inf, 0.0, "trv")), false)); %!test %! assert (isequal (iscommoninterval (infsupdec (0.0, inf, "def")), false)); ## minimal_isSingleton_test %!test %! assert (issingleton (infsup (-27.0, -27.0))); %!test %! assert (issingleton (infsup (-2.0, -2.0))); %!test %! assert (issingleton (infsup (12.0, 12.0))); %!test %! assert (issingleton (infsup (17.1, 17.1))); %!test %! assert (issingleton (infsup (-0.0, -0.0))); %!test %! assert (issingleton (infsup (0.0, 0.0))); %!test %! assert (issingleton (infsup (-0.0, 0.0))); %!test %! assert (issingleton (infsup (0.0, -0.0))); %!test %! assert (isequal (issingleton (infsup), false)); %!test %! assert (isequal (issingleton (infsup (-inf, inf)), false)); %!test %! assert (isequal (issingleton (infsup (-1.0, 0.0)), false)); %!test %! assert (isequal (issingleton (infsup (-1.0, -0.5)), false)); %!test %! assert (isequal (issingleton (infsup (1.0, 2.0)), false)); %!test %! assert (isequal (issingleton (infsup (-inf, -1.797693134862315708e+308)), false)); %!test %! assert (isequal (issingleton (infsup (-1.0, inf)), false)); ## minimal_isSingleton_dec_test %!test %! assert (issingleton (infsupdec (-27.0, -27.0, "def"))); %!test %! assert (issingleton (infsupdec (-2.0, -2.0, "trv"))); %!test %! assert (issingleton (infsupdec (12.0, 12.0, "dac"))); %!test %! assert (issingleton (infsupdec (17.1, 17.1, "com"))); %!test %! assert (issingleton (infsupdec (-0.0, -0.0, "def"))); %!test %! assert (issingleton (infsupdec (0.0, 0.0, "com"))); %!test %! assert (issingleton (infsupdec (-0.0, 0.0, "def"))); %!test %! assert (issingleton (infsupdec (0.0, -0.0, "dac"))); %!test %! assert (isequal (issingleton (infsupdec (empty, "trv")), false)); %!test %! assert (isequal (issingleton (infsupdec (empty, "trv")), false)); %!test %! assert (isequal (issingleton (infsupdec (entire, "def")), false)); %!test %! assert (isequal (issingleton (infsupdec (-1.0, 0.0, "dac")), false)); %!test %! assert (isequal (issingleton (infsupdec (-1.0, -0.5, "com")), false)); %!test %! assert (isequal (issingleton (infsupdec (1.0, 2.0, "def")), false)); %!test %! assert (isequal (issingleton (infsupdec (-inf, -1.797693134862315708e+308, "dac")), false)); %!test %! assert (isequal (issingleton (infsupdec (-1.0, inf, "trv")), false)); ## minimal_isMember_test %!test %! assert (ismember (-27.0, infsup (-27.0, -27.0))); %!test %! assert (ismember (-27.0, infsup (-27.0, 0.0))); %!test %! assert (ismember (-7.0, infsup (-27.0, 0.0))); %!test %! assert (ismember (0.0, infsup (-27.0, 0.0))); %!test %! assert (ismember (-0.0, infsup (0.0, 0.0))); %!test %! assert (ismember (0.0, infsup (0.0, 0.0))); %!test %! assert (ismember (0.0, infsup (-0.0, -0.0))); %!test %! assert (ismember (0.0, infsup (-0.0, 0.0))); %!test %! assert (ismember (0.0, infsup (0.0, -0.0))); %!test %! assert (ismember (5.0, infsup (5.0, 12.4))); %!test %! assert (ismember (6.3, infsup (5.0, 12.4))); %!test %! assert (ismember (12.4, infsup (5.0, 12.4))); %!test %! assert (ismember (0.0, infsup (-inf, inf))); %!test %! assert (ismember (5.0, infsup (-inf, inf))); %!test %! assert (ismember (6.3, infsup (-inf, inf))); %!test %! assert (ismember (12.4, infsup (-inf, inf))); %!test %! assert (isequal (ismember (-71.0, infsup (-27.0, 0.0)), false)); %!test %! assert (isequal (ismember (0.1, infsup (-27.0, 0.0)), false)); %!test %! assert (isequal (ismember (-0.01, infsup (0.0, 0.0)), false)); %!test %! assert (isequal (ismember (0.000001, infsup (0.0, 0.0)), false)); %!test %! assert (isequal (ismember (111110.0, infsup (-0.0, -0.0)), false)); %!test %! assert (isequal (ismember (4.9, infsup (5.0, 12.4)), false)); %!test %! assert (isequal (ismember (-6.3, infsup (5.0, 12.4)), false)); %!test %! assert (isequal (ismember (0.0, infsup), false)); %!test %! assert (isequal (ismember (-4535.3, infsup), false)); %!test %! assert (isequal (ismember (-inf, infsup), false)); %!test %! assert (isequal (ismember (inf, infsup), false)); %!test %! assert (isequal (ismember (-inf, infsup (-inf, inf)), false)); %!test %! assert (isequal (ismember (inf, infsup (-inf, inf)), false)); ## minimal_isMember_dec_test %!test %! assert (ismember (-27.0, infsupdec (-27.0, -27.0, "trv"))); %!test %! assert (ismember (-27.0, infsupdec (-27.0, 0.0, "def"))); %!test %! assert (ismember (-7.0, infsupdec (-27.0, 0.0, "dac"))); %!test %! assert (ismember (0.0, infsupdec (-27.0, 0.0, "com"))); %!test %! assert (ismember (-0.0, infsupdec (0.0, 0.0, "trv"))); %!test %! assert (ismember (0.0, infsupdec (0.0, 0.0, "def"))); %!test %! assert (ismember (0.0, infsupdec (-0.0, -0.0, "dac"))); %!test %! assert (ismember (0.0, infsupdec (-0.0, 0.0, "com"))); %!test %! assert (ismember (0.0, infsupdec (0.0, -0.0, "trv"))); %!test %! assert (ismember (5.0, infsupdec (5.0, 12.4, "def"))); %!test %! assert (ismember (6.3, infsupdec (5.0, 12.4, "dac"))); %!test %! assert (ismember (12.4, infsupdec (5.0, 12.4, "com"))); %!test %! assert (ismember (0.0, infsupdec (entire, "trv"))); %!test %! assert (ismember (5.0, infsupdec (entire, "def"))); %!test %! assert (ismember (6.3, infsupdec (entire, "dac"))); %!test %! assert (ismember (12.4, infsupdec (entire, "trv"))); %!test %! assert (isequal (ismember (-71.0, infsupdec (-27.0, 0.0, "trv")), false)); %!test %! assert (isequal (ismember (0.1, infsupdec (-27.0, 0.0, "def")), false)); %!test %! assert (isequal (ismember (-0.01, infsupdec (0.0, 0.0, "dac")), false)); %!test %! assert (isequal (ismember (0.000001, infsupdec (0.0, 0.0, "com")), false)); %!test %! assert (isequal (ismember (111110.0, infsupdec (-0.0, -0.0, "trv")), false)); %!test %! assert (isequal (ismember (4.9, infsupdec (5.0, 12.4, "def")), false)); %!test %! assert (isequal (ismember (-6.3, infsupdec (5.0, 12.4, "dac")), false)); %!test %! assert (isequal (ismember (0.0, infsupdec (empty, "trv")), false)); %!test %! assert (isequal (ismember (0.0, infsupdec (empty, "trv")), false)); %!test %! assert (isequal (ismember (-4535.3, infsupdec (empty, "trv")), false)); %!test %! assert (isequal (ismember (-4535.3, infsupdec (empty, "trv")), false)); %!test %! assert (isequal (ismember (-inf, infsupdec (empty, "trv")), false)); %!test %! assert (isequal (ismember (-inf, infsupdec (empty, "trv")), false)); %!test %! assert (isequal (ismember (inf, infsupdec (empty, "trv")), false)); %!test %! assert (isequal (ismember (inf, infsupdec (empty, "trv")), false)); %!test %! assert (isequal (ismember (-inf, infsupdec (entire, "trv")), false)); %!test %! assert (isequal (ismember (inf, infsupdec (entire, "def")), false)); interval-1.4.1/inst/test/atan2.tst0000644000175000017500000001557212657476050016446 0ustar oliveroliver## DO NOT EDIT! Generated automatically from test/atan2.itl ## by the Interval Testing Framework for IEEE 1788. ## https://github.com/nehmeier/ITF1788/tree/635bff73cc64ff8aab0ff2031ee8a53980be0115 ## ## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## %!#Test library imports %!#Arithmetic library imports pkg load interval %!#Preamble try; error ("__FILE__"); catch test (lasterror.stack.file, "quiet", stdout); end_try_catch; %!function assert_warn (observed_value, expected_value) %! if (not (isequal (observed_value, expected_value))) %! observed_expression = regexprep (argn(1, :), '\s+$', ''); %! expected_expression = regexprep (argn(2, :), '\s+$', ''); %! observed_as_char = disp (observed_value)(1 : end - 1); %! expected_as_char = disp(expected_value)(1 : end - 1); %! warning ([observed_expression, " != ", expected_expression, ... %! "\n ", observed_as_char, " != ", expected_as_char]); %! endif %!endfunction ## minimal.atan2_test %!test %! assert (isequal (atan2 (infsup, infsup), infsup)); %!test %! assert (isequal (atan2 (infsup, infsup (-inf, inf)), infsup)); %!test %! assert (isequal (atan2 (infsup (-inf, inf), infsup), infsup)); %!test %! assert (isequal (atan2 (infsup (0.0, 0.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup (-inf, inf), infsup (-inf, inf)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 0.0), infsup (-inf, 0.0)), infsup (3.141592653589793116e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 0.0), infsup (0.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (atan2 (infsup (0.0, inf), infsup (0.0, 0.0)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (-inf, 0.0), infsup (0.0, 0.0)), infsup (-1.570796326794896780e+00, -1.570796326794896558e+00))); %!test %! assert (isequal (atan2 (infsup (-2.225073858507201383e-308, 0.0), infsup (-2.225073858507201383e-308, -2.225073858507201383e-308)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (1.0, 1.0), infsup (-1.0, -1.0)), infsup (2.356194490192344837e+00, 2.356194490192345281e+00))); %!test %! assert (isequal (atan2 (infsup (1.0, 1.0), infsup (1.0, 1.0)), infsup (7.853981633974482790e-01, 7.853981633974483900e-01))); %!test %! assert (isequal (atan2 (infsup (-1.0, -1.0), infsup (1.0, 1.0)), infsup (-7.853981633974483900e-01, -7.853981633974482790e-01))); %!test %! assert (isequal (atan2 (infsup (-1.0, -1.0), infsup (-1.0, -1.0)), infsup (-2.356194490192345281e+00, -2.356194490192344837e+00))); %!test %! assert (isequal (atan2 (infsup (-2.225073858507201383e-308, 2.225073858507201383e-308), infsup (-2.225073858507201383e-308, -2.225073858507201383e-308)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-2.225073858507201383e-308, 2.225073858507201383e-308), infsup (2.225073858507201383e-308, 2.225073858507201383e-308)), infsup (-7.853981633974483900e-01, 7.853981633974483900e-01))); %!test %! assert (isequal (atan2 (infsup (-2.225073858507201383e-308, -2.225073858507201383e-308), infsup (-2.225073858507201383e-308, 2.225073858507201383e-308)), infsup (-2.356194490192345281e+00, -7.853981633974482790e-01))); %!test %! assert (isequal (atan2 (infsup (2.225073858507201383e-308, 2.225073858507201383e-308), infsup (-2.225073858507201383e-308, 2.225073858507201383e-308)), infsup (7.853981633974482790e-01, 2.356194490192345281e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 2.0), infsup (-3.0, -1.0)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 2.0), infsup (-3.0, -1.0)), infsup (2.034443935795702707e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (1.0, 3.0), infsup (-3.0, -1.0)), infsup (1.892546881191538688e+00, 2.819842099193151430e+00))); %!test %! assert (isequal (atan2 (infsup (1.0, 3.0), infsup (-2.0, 0.0)), infsup (1.570796326794896558e+00, 2.677945044588987411e+00))); %!test %! assert (isequal (atan2 (infsup (1.0, 3.0), infsup (-2.0, 2.0)), infsup (4.636476090008060935e-01, 2.677945044588987411e+00))); %!test %! assert (isequal (atan2 (infsup (1.0, 3.0), infsup (0.0, 2.0)), infsup (4.636476090008060935e-01, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (1.0, 3.0), infsup (1.0, 3.0)), infsup (3.217505543966421855e-01, 1.249045772398254428e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 2.0), infsup (1.0, 3.0)), infsup (0.000000000000000000e+00, 1.107148717794090631e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 2.0), infsup (1.0, 3.0)), infsup (-1.107148717794090631e+00, 1.107148717794090631e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 0.0), infsup (1.0, 3.0)), infsup (-1.107148717794090631e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (atan2 (infsup (-3.0, -1.0), infsup (1.0, 3.0)), infsup (-1.249045772398254428e+00, -3.217505543966421855e-01))); %!test %! assert (isequal (atan2 (infsup (-3.0, -1.0), infsup (0.0, 2.0)), infsup (-1.570796326794896780e+00, -4.636476090008060935e-01))); %!test %! assert (isequal (atan2 (infsup (-3.0, -1.0), infsup (-2.0, 2.0)), infsup (-2.677945044588987411e+00, -4.636476090008060935e-01))); %!test %! assert (isequal (atan2 (infsup (-3.0, -1.0), infsup (-2.0, 0.0)), infsup (-2.677945044588987411e+00, -1.570796326794896558e+00))); %!test %! assert (isequal (atan2 (infsup (-3.0, -1.0), infsup (-3.0, -1.0)), infsup (-2.819842099193151430e+00, -1.892546881191538688e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 0.0), infsup (-3.0, -1.0)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-5.0, 0.0), infsup (-5.0, 0.0)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 5.0), infsup (-5.0, 0.0)), infsup (1.570796326794896558e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 5.0), infsup (0.0, 5.0)), infsup (0.000000000000000000e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (-5.0, 0.0), infsup (0.0, 5.0)), infsup (-1.570796326794896780e+00, 0.000000000000000000e+00))); interval-1.4.1/inst/test/libieeep1788_tests_bool.tst0000644000175000017500000011500612657476050021775 0ustar oliveroliver## DO NOT EDIT! Generated automatically from test/libieeep1788_tests_bool.itl ## by the Interval Testing Framework for IEEE 1788. ## https://github.com/nehmeier/ITF1788/tree/635bff73cc64ff8aab0ff2031ee8a53980be0115 ## ## Copyright 2013-2015 Marco Nehmeier (nehmeier@informatik.uni-wuerzburg.de) ## Copyright 2015-2016 Oliver Heimlich ## ## Original author: Marco Nehmeier (unit tests in libieeep1788, ## original license: Apache License 2.0) ## Converted into portable ITL format by Oliver Heimlich with minor corrections. ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## %!#Test library imports %!#Arithmetic library imports pkg load interval %!#Preamble try; error ("__FILE__"); catch test (lasterror.stack.file, "quiet", stdout); end_try_catch; %!function assert_warn (observed_value, expected_value) %! if (not (isequal (observed_value, expected_value))) %! observed_expression = regexprep (argn(1, :), '\s+$', ''); %! expected_expression = regexprep (argn(2, :), '\s+$', ''); %! observed_as_char = disp (observed_value)(1 : end - 1); %! expected_as_char = disp(expected_value)(1 : end - 1); %! warning ([observed_expression, " != ", expected_expression, ... %! "\n ", observed_as_char, " != ", expected_as_char]); %! endif %!endfunction ## minimal_empty_test %!test %! assert (isempty (infsup)); %!test %! assert (isequal (isempty (infsup (-inf, inf)), false)); %!test %! assert (isequal (isempty (infsup (1.0, 2.0)), false)); %!test %! assert (isequal (isempty (infsup (-1.0, 2.0)), false)); %!test %! assert (isequal (isempty (infsup (-3.0, -2.0)), false)); %!test %! assert (isequal (isempty (infsup (-inf, 2.0)), false)); %!test %! assert (isequal (isempty (infsup (-inf, 0.0)), false)); %!test %! assert (isequal (isempty (infsup (-inf, -0.0)), false)); %!test %! assert (isequal (isempty (infsup (0.0, inf)), false)); %!test %! assert (isequal (isempty (infsup (-0.0, inf)), false)); %!test %! assert (isequal (isempty (infsup (-0.0, 0.0)), false)); %!test %! assert (isequal (isempty (infsup (0.0, -0.0)), false)); %!test %! assert (isequal (isempty (infsup (0.0, 0.0)), false)); %!test %! assert (isequal (isempty (infsup (-0.0, -0.0)), false)); ## minimal_empty_dec_test %!test %! assert (isempty (infsupdec (empty, "trv"))); %!test %! assert (isequal (isempty (infsupdec (-inf, inf, "def")), false)); %!test %! assert (isequal (isempty (infsupdec (1.0, 2.0, "com")), false)); %!test %! assert (isequal (isempty (infsupdec (-1.0, 2.0, "trv")), false)); %!test %! assert (isequal (isempty (infsupdec (-3.0, -2.0, "dac")), false)); %!test %! assert (isequal (isempty (infsupdec (-inf, 2.0, "trv")), false)); %!test %! assert (isequal (isempty (infsupdec (-inf, 0.0, "trv")), false)); %!test %! assert (isequal (isempty (infsupdec (-inf, -0.0, "trv")), false)); %!test %! assert (isequal (isempty (infsupdec (0.0, inf, "def")), false)); %!test %! assert (isequal (isempty (infsupdec (-0.0, inf, "trv")), false)); %!test %! assert (isequal (isempty (infsupdec (-0.0, 0.0, "com")), false)); %!test %! assert (isequal (isempty (infsupdec (0.0, -0.0, "trv")), false)); %!test %! assert (isequal (isempty (infsupdec (0.0, 0.0, "trv")), false)); %!test %! assert (isequal (isempty (infsupdec (-0.0, -0.0, "trv")), false)); ## minimal_entire_test %!test %! assert (isequal (isentire (infsup), false)); %!test %! assert (isentire (infsup (-inf, inf))); %!test %! assert (isequal (isentire (infsup (1.0, 2.0)), false)); %!test %! assert (isequal (isentire (infsup (-1.0, 2.0)), false)); %!test %! assert (isequal (isentire (infsup (-3.0, -2.0)), false)); %!test %! assert (isequal (isentire (infsup (-inf, 2.0)), false)); %!test %! assert (isequal (isentire (infsup (-inf, 0.0)), false)); %!test %! assert (isequal (isentire (infsup (-inf, -0.0)), false)); %!test %! assert (isequal (isentire (infsup (0.0, inf)), false)); %!test %! assert (isequal (isentire (infsup (-0.0, inf)), false)); %!test %! assert (isequal (isentire (infsup (-0.0, 0.0)), false)); %!test %! assert (isequal (isentire (infsup (0.0, -0.0)), false)); %!test %! assert (isequal (isentire (infsup (0.0, 0.0)), false)); %!test %! assert (isequal (isentire (infsup (-0.0, -0.0)), false)); ## minimal_entire_dec_test %!test %! assert (isequal (isentire (infsupdec (empty, "trv")), false)); %!test %! assert (isentire (infsupdec (-inf, inf, "trv"))); %!test %! assert (isentire (infsupdec (-inf, inf, "def"))); %!test %! assert (isentire (infsupdec (-inf, inf, "dac"))); %!test %! assert (isequal (isentire (infsupdec (1.0, 2.0, "com")), false)); %!test %! assert (isequal (isentire (infsupdec (-1.0, 2.0, "trv")), false)); %!test %! assert (isequal (isentire (infsupdec (-3.0, -2.0, "dac")), false)); %!test %! assert (isequal (isentire (infsupdec (-inf, 2.0, "trv")), false)); %!test %! assert (isequal (isentire (infsupdec (-inf, 0.0, "trv")), false)); %!test %! assert (isequal (isentire (infsupdec (-inf, -0.0, "trv")), false)); %!test %! assert (isequal (isentire (infsupdec (0.0, inf, "def")), false)); %!test %! assert (isequal (isentire (infsupdec (-0.0, inf, "trv")), false)); %!test %! assert (isequal (isentire (infsupdec (-0.0, 0.0, "com")), false)); %!test %! assert (isequal (isentire (infsupdec (0.0, -0.0, "trv")), false)); %!test %! assert (isequal (isentire (infsupdec (0.0, 0.0, "trv")), false)); %!test %! assert (isequal (isentire (infsupdec (-0.0, -0.0, "trv")), false)); ## minimal_nai_dec_test %!test %! assert (isequal (isnai (infsupdec (-inf, inf, "trv")), false)); %!test %! assert (isequal (isnai (infsupdec (-inf, inf, "def")), false)); %!test %! assert (isequal (isnai (infsupdec (-inf, inf, "dac")), false)); %!test %! assert (isequal (isnai (infsupdec (1.0, 2.0, "com")), false)); %!test %! assert (isequal (isnai (infsupdec (-1.0, 2.0, "trv")), false)); %!test %! assert (isequal (isnai (infsupdec (-3.0, -2.0, "dac")), false)); %!test %! assert (isequal (isnai (infsupdec (-inf, 2.0, "trv")), false)); %!test %! assert (isequal (isnai (infsupdec (-inf, 0.0, "trv")), false)); %!test %! assert (isequal (isnai (infsupdec (-inf, -0.0, "trv")), false)); %!test %! assert (isequal (isnai (infsupdec (0.0, inf, "def")), false)); %!test %! assert (isequal (isnai (infsupdec (-0.0, inf, "trv")), false)); %!test %! assert (isequal (isnai (infsupdec (-0.0, 0.0, "com")), false)); %!test %! assert (isequal (isnai (infsupdec (0.0, -0.0, "trv")), false)); %!test %! assert (isequal (isnai (infsupdec (0.0, 0.0, "trv")), false)); %!test %! assert (isequal (isnai (infsupdec (-0.0, -0.0, "trv")), false)); ## minimal_equal_test %!test %! assert (eq (infsup (1.0, 2.0), infsup (1.0, 2.0))); %! assert (infsup (1.0, 2.0) == infsup (1.0, 2.0)); %!test %! assert (isequal (eq (infsup (1.0, 2.1), infsup (1.0, 2.0)), false)); %! assert (isequal (infsup (1.0, 2.1) == infsup (1.0, 2.0), false)); %!test %! assert (eq (infsup, infsup)); %! assert (infsup == infsup); %!test %! assert (isequal (eq (infsup, infsup (1.0, 2.0)), false)); %! assert (isequal (infsup == infsup (1.0, 2.0), false)); %!test %! assert (eq (infsup (-inf, inf), infsup (-inf, inf))); %! assert (infsup (-inf, inf) == infsup (-inf, inf)); %!test %! assert (isequal (eq (infsup (1.0, 2.4), infsup (-inf, inf)), false)); %! assert (isequal (infsup (1.0, 2.4) == infsup (-inf, inf), false)); %!test %! assert (eq (infsup (1.0, inf), infsup (1.0, inf))); %! assert (infsup (1.0, inf) == infsup (1.0, inf)); %!test %! assert (isequal (eq (infsup (1.0, 2.4), infsup (1.0, inf)), false)); %! assert (isequal (infsup (1.0, 2.4) == infsup (1.0, inf), false)); %!test %! assert (eq (infsup (-inf, 2.0), infsup (-inf, 2.0))); %! assert (infsup (-inf, 2.0) == infsup (-inf, 2.0)); %!test %! assert (isequal (eq (infsup (-inf, 2.4), infsup (-inf, 2.0)), false)); %! assert (isequal (infsup (-inf, 2.4) == infsup (-inf, 2.0), false)); %!test %! assert (eq (infsup (-2.0, 0.0), infsup (-2.0, 0.0))); %! assert (infsup (-2.0, 0.0) == infsup (-2.0, 0.0)); %!test %! assert (eq (infsup (-0.0, 2.0), infsup (0.0, 2.0))); %! assert (infsup (-0.0, 2.0) == infsup (0.0, 2.0)); %!test %! assert (eq (infsup (-0.0, -0.0), infsup (0.0, 0.0))); %! assert (infsup (-0.0, -0.0) == infsup (0.0, 0.0)); %!test %! assert (eq (infsup (-0.0, 0.0), infsup (0.0, 0.0))); %! assert (infsup (-0.0, 0.0) == infsup (0.0, 0.0)); %!test %! assert (eq (infsup (0.0, -0.0), infsup (0.0, 0.0))); %! assert (infsup (0.0, -0.0) == infsup (0.0, 0.0)); ## minimal_equal_dec_test %!test %! assert (eq (infsupdec (1.0, 2.0, "def"), infsupdec (1.0, 2.0, "trv"))); %! assert (infsupdec (1.0, 2.0, "def") == infsupdec (1.0, 2.0, "trv")); %!test %! assert (isequal (eq (infsupdec (1.0, 2.1, "trv"), infsupdec (1.0, 2.0, "trv")), false)); %! assert (isequal (infsupdec (1.0, 2.1, "trv") == infsupdec (1.0, 2.0, "trv"), false)); %!test %! assert (eq (infsupdec (empty, "trv"), infsupdec (empty, "trv"))); %! assert (infsupdec (empty, "trv") == infsupdec (empty, "trv")); %!test %! assert (isequal (eq (infsupdec (empty, "trv"), infsupdec (1.0, 2.0, "trv")), false)); %! assert (isequal (infsupdec (empty, "trv") == infsupdec (1.0, 2.0, "trv"), false)); %!test %! assert (isequal (eq (infsupdec (empty, "trv"), infsupdec (1.0, 2.0, "trv")), false)); %! assert (isequal (infsupdec (empty, "trv") == infsupdec (1.0, 2.0, "trv"), false)); %!test %! assert (eq (infsupdec (-inf, inf, "def"), infsupdec (-inf, inf, "trv"))); %! assert (infsupdec (-inf, inf, "def") == infsupdec (-inf, inf, "trv")); %!test %! assert (isequal (eq (infsupdec (1.0, 2.4, "trv"), infsupdec (-inf, inf, "trv")), false)); %! assert (isequal (infsupdec (1.0, 2.4, "trv") == infsupdec (-inf, inf, "trv"), false)); %!test %! assert (eq (infsupdec (1.0, inf, "trv"), infsupdec (1.0, inf, "trv"))); %! assert (infsupdec (1.0, inf, "trv") == infsupdec (1.0, inf, "trv")); %!test %! assert (isequal (eq (infsupdec (1.0, 2.4, "def"), infsupdec (1.0, inf, "trv")), false)); %! assert (isequal (infsupdec (1.0, 2.4, "def") == infsupdec (1.0, inf, "trv"), false)); %!test %! assert (eq (infsupdec (-inf, 2.0, "trv"), infsupdec (-inf, 2.0, "trv"))); %! assert (infsupdec (-inf, 2.0, "trv") == infsupdec (-inf, 2.0, "trv")); %!test %! assert (isequal (eq (infsupdec (-inf, 2.4, "def"), infsupdec (-inf, 2.0, "trv")), false)); %! assert (isequal (infsupdec (-inf, 2.4, "def") == infsupdec (-inf, 2.0, "trv"), false)); %!test %! assert (eq (infsupdec (-2.0, 0.0, "trv"), infsupdec (-2.0, 0.0, "trv"))); %! assert (infsupdec (-2.0, 0.0, "trv") == infsupdec (-2.0, 0.0, "trv")); %!test %! assert (eq (infsupdec (-0.0, 2.0, "def"), infsupdec (0.0, 2.0, "trv"))); %! assert (infsupdec (-0.0, 2.0, "def") == infsupdec (0.0, 2.0, "trv")); %!test %! assert (eq (infsupdec (-0.0, -0.0, "trv"), infsupdec (0.0, 0.0, "trv"))); %! assert (infsupdec (-0.0, -0.0, "trv") == infsupdec (0.0, 0.0, "trv")); %!test %! assert (eq (infsupdec (-0.0, 0.0, "def"), infsupdec (0.0, 0.0, "trv"))); %! assert (infsupdec (-0.0, 0.0, "def") == infsupdec (0.0, 0.0, "trv")); %!test %! assert (eq (infsupdec (0.0, -0.0, "trv"), infsupdec (0.0, 0.0, "trv"))); %! assert (infsupdec (0.0, -0.0, "trv") == infsupdec (0.0, 0.0, "trv")); ## minimal_subset_test %!test %! assert (subset (infsup, infsup)); %!test %! assert (subset (infsup, infsup (0.0, 4.0))); %!test %! assert (subset (infsup, infsup (-0.0, 4.0))); %!test %! assert (subset (infsup, infsup (-0.1, 1.0))); %!test %! assert (subset (infsup, infsup (-0.1, 0.0))); %!test %! assert (subset (infsup, infsup (-0.1, -0.0))); %!test %! assert (subset (infsup, infsup (-inf, inf))); %!test %! assert (isequal (subset (infsup (0.0, 4.0), infsup), false)); %!test %! assert (isequal (subset (infsup (-0.0, 4.0), infsup), false)); %!test %! assert (isequal (subset (infsup (-0.1, 1.0), infsup), false)); %!test %! assert (isequal (subset (infsup (-inf, inf), infsup), false)); %!test %! assert (subset (infsup (0.0, 4.0), infsup (-inf, inf))); %!test %! assert (subset (infsup (-0.0, 4.0), infsup (-inf, inf))); %!test %! assert (subset (infsup (-0.1, 1.0), infsup (-inf, inf))); %!test %! assert (subset (infsup (-inf, inf), infsup (-inf, inf))); %!test %! assert (subset (infsup (1.0, 2.0), infsup (1.0, 2.0))); %!test %! assert (subset (infsup (1.0, 2.0), infsup (0.0, 4.0))); %!test %! assert (subset (infsup (1.0, 2.0), infsup (-0.0, 4.0))); %!test %! assert (subset (infsup (0.1, 0.2), infsup (0.0, 4.0))); %!test %! assert (subset (infsup (0.1, 0.2), infsup (-0.0, 4.0))); %!test %! assert (subset (infsup (-0.1, -0.1), infsup (-4.0, 3.4))); %!test %! assert (subset (infsup (0.0, 0.0), infsup (-0.0, -0.0))); %!test %! assert (subset (infsup (-0.0, -0.0), infsup (0.0, 0.0))); %!test %! assert (subset (infsup (-0.0, 0.0), infsup (0.0, 0.0))); %!test %! assert (subset (infsup (-0.0, 0.0), infsup (0.0, -0.0))); %!test %! assert (subset (infsup (0.0, -0.0), infsup (0.0, 0.0))); %!test %! assert (subset (infsup (0.0, -0.0), infsup (-0.0, 0.0))); ## minimal_subset_dec_test %!test %! assert (subset (infsupdec (empty, "trv"), infsupdec (0.0, 4.0, "trv"))); %!test %! assert (subset (infsupdec (empty, "trv"), infsupdec (-0.0, 4.0, "def"))); %!test %! assert (subset (infsupdec (empty, "trv"), infsupdec (-0.1, 1.0, "trv"))); %!test %! assert (subset (infsupdec (empty, "trv"), infsupdec (-0.1, 0.0, "trv"))); %!test %! assert (subset (infsupdec (empty, "trv"), infsupdec (-0.1, -0.0, "trv"))); %!test %! assert (subset (infsupdec (empty, "trv"), infsupdec (-inf, inf, "trv"))); %!test %! assert (isequal (subset (infsupdec (0.0, 4.0, "trv"), infsupdec (empty, "trv")), false)); %!test %! assert (isequal (subset (infsupdec (-0.0, 4.0, "def"), infsupdec (empty, "trv")), false)); %!test %! assert (isequal (subset (infsupdec (-0.1, 1.0, "trv"), infsupdec (empty, "trv")), false)); %!test %! assert (isequal (subset (infsupdec (-inf, inf, "trv"), infsupdec (empty, "trv")), false)); %!test %! assert (subset (infsupdec (0.0, 4.0, "trv"), infsupdec (-inf, inf, "trv"))); %!test %! assert (subset (infsupdec (-0.0, 4.0, "trv"), infsupdec (-inf, inf, "trv"))); %!test %! assert (subset (infsupdec (-0.1, 1.0, "trv"), infsupdec (-inf, inf, "trv"))); %!test %! assert (subset (infsupdec (-inf, inf, "trv"), infsupdec (-inf, inf, "trv"))); %!test %! assert (subset (infsupdec (1.0, 2.0, "trv"), infsupdec (1.0, 2.0, "trv"))); %!test %! assert (subset (infsupdec (1.0, 2.0, "trv"), infsupdec (0.0, 4.0, "trv"))); %!test %! assert (subset (infsupdec (1.0, 2.0, "def"), infsupdec (-0.0, 4.0, "def"))); %!test %! assert (subset (infsupdec (0.1, 0.2, "trv"), infsupdec (0.0, 4.0, "trv"))); %!test %! assert (subset (infsupdec (0.1, 0.2, "trv"), infsupdec (-0.0, 4.0, "def"))); %!test %! assert (subset (infsupdec (-0.1, -0.1, "trv"), infsupdec (-4.0, 3.4, "trv"))); %!test %! assert (subset (infsupdec (0.0, 0.0, "trv"), infsupdec (-0.0, -0.0, "trv"))); %!test %! assert (subset (infsupdec (-0.0, -0.0, "trv"), infsupdec (0.0, 0.0, "def"))); %!test %! assert (subset (infsupdec (-0.0, 0.0, "trv"), infsupdec (0.0, 0.0, "trv"))); %!test %! assert (subset (infsupdec (-0.0, 0.0, "trv"), infsupdec (0.0, -0.0, "trv"))); %!test %! assert (subset (infsupdec (0.0, -0.0, "def"), infsupdec (0.0, 0.0, "trv"))); %!test %! assert (subset (infsupdec (0.0, -0.0, "trv"), infsupdec (-0.0, 0.0, "trv"))); ## minimal_less_test %!test %! assert (le (infsup, infsup)); %! assert (infsup <= infsup); %!test %! assert (isequal (le (infsup (1.0, 2.0), infsup), false)); %! assert (isequal (infsup (1.0, 2.0) <= infsup, false)); %!test %! assert (isequal (le (infsup, infsup (1.0, 2.0)), false)); %! assert (isequal (infsup <= infsup (1.0, 2.0), false)); %!test %! assert (le (infsup (-inf, inf), infsup (-inf, inf))); %! assert (infsup (-inf, inf) <= infsup (-inf, inf)); %!test %! assert (isequal (le (infsup (1.0, 2.0), infsup (-inf, inf)), false)); %! assert (isequal (infsup (1.0, 2.0) <= infsup (-inf, inf), false)); %!test %! assert (isequal (le (infsup (0.0, 2.0), infsup (-inf, inf)), false)); %! assert (isequal (infsup (0.0, 2.0) <= infsup (-inf, inf), false)); %!test %! assert (isequal (le (infsup (-0.0, 2.0), infsup (-inf, inf)), false)); %! assert (isequal (infsup (-0.0, 2.0) <= infsup (-inf, inf), false)); %!test %! assert (isequal (le (infsup (-inf, inf), infsup (1.0, 2.0)), false)); %! assert (isequal (infsup (-inf, inf) <= infsup (1.0, 2.0), false)); %!test %! assert (isequal (le (infsup (-inf, inf), infsup (0.0, 2.0)), false)); %! assert (isequal (infsup (-inf, inf) <= infsup (0.0, 2.0), false)); %!test %! assert (isequal (le (infsup (-inf, inf), infsup (-0.0, 2.0)), false)); %! assert (isequal (infsup (-inf, inf) <= infsup (-0.0, 2.0), false)); %!test %! assert (le (infsup (0.0, 2.0), infsup (0.0, 2.0))); %! assert (infsup (0.0, 2.0) <= infsup (0.0, 2.0)); %!test %! assert (le (infsup (0.0, 2.0), infsup (-0.0, 2.0))); %! assert (infsup (0.0, 2.0) <= infsup (-0.0, 2.0)); %!test %! assert (le (infsup (0.0, 2.0), infsup (1.0, 2.0))); %! assert (infsup (0.0, 2.0) <= infsup (1.0, 2.0)); %!test %! assert (le (infsup (-0.0, 2.0), infsup (1.0, 2.0))); %! assert (infsup (-0.0, 2.0) <= infsup (1.0, 2.0)); %!test %! assert (le (infsup (1.0, 2.0), infsup (1.0, 2.0))); %! assert (infsup (1.0, 2.0) <= infsup (1.0, 2.0)); %!test %! assert (le (infsup (1.0, 2.0), infsup (3.0, 4.0))); %! assert (infsup (1.0, 2.0) <= infsup (3.0, 4.0)); %!test %! assert (le (infsup (1.0, 3.5), infsup (3.0, 4.0))); %! assert (infsup (1.0, 3.5) <= infsup (3.0, 4.0)); %!test %! assert (le (infsup (1.0, 4.0), infsup (3.0, 4.0))); %! assert (infsup (1.0, 4.0) <= infsup (3.0, 4.0)); %!test %! assert (le (infsup (-2.0, -1.0), infsup (-2.0, -1.0))); %! assert (infsup (-2.0, -1.0) <= infsup (-2.0, -1.0)); %!test %! assert (le (infsup (-3.0, -1.5), infsup (-2.0, -1.0))); %! assert (infsup (-3.0, -1.5) <= infsup (-2.0, -1.0)); %!test %! assert (le (infsup (0.0, 0.0), infsup (-0.0, -0.0))); %! assert (infsup (0.0, 0.0) <= infsup (-0.0, -0.0)); %!test %! assert (le (infsup (-0.0, -0.0), infsup (0.0, 0.0))); %! assert (infsup (-0.0, -0.0) <= infsup (0.0, 0.0)); %!test %! assert (le (infsup (-0.0, 0.0), infsup (0.0, 0.0))); %! assert (infsup (-0.0, 0.0) <= infsup (0.0, 0.0)); %!test %! assert (le (infsup (-0.0, 0.0), infsup (0.0, -0.0))); %! assert (infsup (-0.0, 0.0) <= infsup (0.0, -0.0)); %!test %! assert (le (infsup (0.0, -0.0), infsup (0.0, 0.0))); %! assert (infsup (0.0, -0.0) <= infsup (0.0, 0.0)); %!test %! assert (le (infsup (0.0, -0.0), infsup (-0.0, 0.0))); %! assert (infsup (0.0, -0.0) <= infsup (-0.0, 0.0)); ## minimal_less_dec_test %!test %! assert (isequal (le (infsupdec (1.0, 2.0, "trv"), infsupdec (empty, "trv")), false)); %! assert (isequal (infsupdec (1.0, 2.0, "trv") <= infsupdec (empty, "trv"), false)); %!test %! assert (isequal (le (infsupdec (empty, "trv"), infsupdec (1.0, 2.0, "def")), false)); %! assert (isequal (infsupdec (empty, "trv") <= infsupdec (1.0, 2.0, "def"), false)); %!test %! assert (isequal (le (infsupdec (1.0, 2.0, "trv"), infsupdec (empty, "trv")), false)); %! assert (isequal (infsupdec (1.0, 2.0, "trv") <= infsupdec (empty, "trv"), false)); %!test %! assert (isequal (le (infsupdec (empty, "trv"), infsupdec (1.0, 2.0, "trv")), false)); %! assert (isequal (infsupdec (empty, "trv") <= infsupdec (1.0, 2.0, "trv"), false)); %!test %! assert (le (infsupdec (-inf, inf, "trv"), infsupdec (-inf, inf, "trv"))); %! assert (infsupdec (-inf, inf, "trv") <= infsupdec (-inf, inf, "trv")); %!test %! assert (isequal (le (infsupdec (1.0, 2.0, "def"), infsupdec (-inf, inf, "trv")), false)); %! assert (isequal (infsupdec (1.0, 2.0, "def") <= infsupdec (-inf, inf, "trv"), false)); %!test %! assert (isequal (le (infsupdec (0.0, 2.0, "trv"), infsupdec (-inf, inf, "trv")), false)); %! assert (isequal (infsupdec (0.0, 2.0, "trv") <= infsupdec (-inf, inf, "trv"), false)); %!test %! assert (isequal (le (infsupdec (-0.0, 2.0, "trv"), infsupdec (-inf, inf, "trv")), false)); %! assert (isequal (infsupdec (-0.0, 2.0, "trv") <= infsupdec (-inf, inf, "trv"), false)); %!test %! assert (isequal (le (infsupdec (-inf, inf, "trv"), infsupdec (1.0, 2.0, "trv")), false)); %! assert (isequal (infsupdec (-inf, inf, "trv") <= infsupdec (1.0, 2.0, "trv"), false)); %!test %! assert (isequal (le (infsupdec (-inf, inf, "trv"), infsupdec (0.0, 2.0, "def")), false)); %! assert (isequal (infsupdec (-inf, inf, "trv") <= infsupdec (0.0, 2.0, "def"), false)); %!test %! assert (isequal (le (infsupdec (-inf, inf, "trv"), infsupdec (-0.0, 2.0, "trv")), false)); %! assert (isequal (infsupdec (-inf, inf, "trv") <= infsupdec (-0.0, 2.0, "trv"), false)); %!test %! assert (le (infsupdec (0.0, 2.0, "trv"), infsupdec (0.0, 2.0, "trv"))); %! assert (infsupdec (0.0, 2.0, "trv") <= infsupdec (0.0, 2.0, "trv")); %!test %! assert (le (infsupdec (0.0, 2.0, "trv"), infsupdec (-0.0, 2.0, "trv"))); %! assert (infsupdec (0.0, 2.0, "trv") <= infsupdec (-0.0, 2.0, "trv")); %!test %! assert (le (infsupdec (0.0, 2.0, "def"), infsupdec (1.0, 2.0, "def"))); %! assert (infsupdec (0.0, 2.0, "def") <= infsupdec (1.0, 2.0, "def")); %!test %! assert (le (infsupdec (-0.0, 2.0, "trv"), infsupdec (1.0, 2.0, "trv"))); %! assert (infsupdec (-0.0, 2.0, "trv") <= infsupdec (1.0, 2.0, "trv")); %!test %! assert (le (infsupdec (1.0, 2.0, "trv"), infsupdec (1.0, 2.0, "trv"))); %! assert (infsupdec (1.0, 2.0, "trv") <= infsupdec (1.0, 2.0, "trv")); %!test %! assert (le (infsupdec (1.0, 2.0, "trv"), infsupdec (3.0, 4.0, "def"))); %! assert (infsupdec (1.0, 2.0, "trv") <= infsupdec (3.0, 4.0, "def")); %!test %! assert (le (infsupdec (1.0, 3.5, "trv"), infsupdec (3.0, 4.0, "trv"))); %! assert (infsupdec (1.0, 3.5, "trv") <= infsupdec (3.0, 4.0, "trv")); %!test %! assert (le (infsupdec (1.0, 4.0, "trv"), infsupdec (3.0, 4.0, "trv"))); %! assert (infsupdec (1.0, 4.0, "trv") <= infsupdec (3.0, 4.0, "trv")); %!test %! assert (le (infsupdec (-2.0, -1.0, "trv"), infsupdec (-2.0, -1.0, "trv"))); %! assert (infsupdec (-2.0, -1.0, "trv") <= infsupdec (-2.0, -1.0, "trv")); %!test %! assert (le (infsupdec (-3.0, -1.5, "trv"), infsupdec (-2.0, -1.0, "trv"))); %! assert (infsupdec (-3.0, -1.5, "trv") <= infsupdec (-2.0, -1.0, "trv")); %!test %! assert (le (infsupdec (0.0, 0.0, "trv"), infsupdec (-0.0, -0.0, "trv"))); %! assert (infsupdec (0.0, 0.0, "trv") <= infsupdec (-0.0, -0.0, "trv")); %!test %! assert (le (infsupdec (-0.0, -0.0, "trv"), infsupdec (0.0, 0.0, "def"))); %! assert (infsupdec (-0.0, -0.0, "trv") <= infsupdec (0.0, 0.0, "def")); %!test %! assert (le (infsupdec (-0.0, 0.0, "trv"), infsupdec (0.0, 0.0, "trv"))); %! assert (infsupdec (-0.0, 0.0, "trv") <= infsupdec (0.0, 0.0, "trv")); %!test %! assert (le (infsupdec (-0.0, 0.0, "trv"), infsupdec (0.0, -0.0, "trv"))); %! assert (infsupdec (-0.0, 0.0, "trv") <= infsupdec (0.0, -0.0, "trv")); %!test %! assert (le (infsupdec (0.0, -0.0, "def"), infsupdec (0.0, 0.0, "trv"))); %! assert (infsupdec (0.0, -0.0, "def") <= infsupdec (0.0, 0.0, "trv")); %!test %! assert (le (infsupdec (0.0, -0.0, "trv"), infsupdec (-0.0, 0.0, "trv"))); %! assert (infsupdec (0.0, -0.0, "trv") <= infsupdec (-0.0, 0.0, "trv")); ## minimal_precedes_test %!test %! assert (precedes (infsup, infsup (3.0, 4.0))); %!test %! assert (precedes (infsup (3.0, 4.0), infsup)); %!test %! assert (precedes (infsup, infsup)); %!test %! assert (isequal (precedes (infsup (1.0, 2.0), infsup (-inf, inf)), false)); %!test %! assert (isequal (precedes (infsup (0.0, 2.0), infsup (-inf, inf)), false)); %!test %! assert (isequal (precedes (infsup (-0.0, 2.0), infsup (-inf, inf)), false)); %!test %! assert (isequal (precedes (infsup (-inf, inf), infsup (1.0, 2.0)), false)); %!test %! assert (isequal (precedes (infsup (-inf, inf), infsup (-inf, inf)), false)); %!test %! assert (precedes (infsup (1.0, 2.0), infsup (3.0, 4.0))); %!test %! assert (precedes (infsup (1.0, 3.0), infsup (3.0, 4.0))); %!test %! assert (precedes (infsup (-3.0, -1.0), infsup (-1.0, 0.0))); %!test %! assert (precedes (infsup (-3.0, -1.0), infsup (-1.0, -0.0))); %!test %! assert (isequal (precedes (infsup (1.0, 3.5), infsup (3.0, 4.0)), false)); %!test %! assert (isequal (precedes (infsup (1.0, 4.0), infsup (3.0, 4.0)), false)); %!test %! assert (isequal (precedes (infsup (-3.0, -0.1), infsup (-1.0, 0.0)), false)); %!test %! assert (precedes (infsup (0.0, 0.0), infsup (-0.0, -0.0))); %!test %! assert (precedes (infsup (-0.0, -0.0), infsup (0.0, 0.0))); %!test %! assert (precedes (infsup (-0.0, 0.0), infsup (0.0, 0.0))); %!test %! assert (precedes (infsup (-0.0, 0.0), infsup (0.0, -0.0))); %!test %! assert (precedes (infsup (0.0, -0.0), infsup (0.0, 0.0))); %!test %! assert (precedes (infsup (0.0, -0.0), infsup (-0.0, 0.0))); ## minimal_precedes_dec_test %!test %! assert (precedes (infsupdec (empty, "trv"), infsupdec (3.0, 4.0, "def"))); %!test %! assert (precedes (infsupdec (3.0, 4.0, "trv"), infsupdec (empty, "trv"))); %!test %! assert (precedes (infsupdec (empty, "trv"), infsupdec (3.0, 4.0, "trv"))); %!test %! assert (precedes (infsupdec (3.0, 4.0, "trv"), infsupdec (empty, "trv"))); %!test %! assert (isequal (precedes (infsupdec (1.0, 2.0, "trv"), infsupdec (-inf, inf, "trv")), false)); %!test %! assert (isequal (precedes (infsupdec (0.0, 2.0, "trv"), infsupdec (-inf, inf, "trv")), false)); %!test %! assert (isequal (precedes (infsupdec (-0.0, 2.0, "trv"), infsupdec (-inf, inf, "trv")), false)); %!test %! assert (isequal (precedes (infsupdec (-inf, inf, "trv"), infsupdec (1.0, 2.0, "trv")), false)); %!test %! assert (isequal (precedes (infsupdec (-inf, inf, "trv"), infsupdec (-inf, inf, "trv")), false)); %!test %! assert (precedes (infsupdec (1.0, 2.0, "trv"), infsupdec (3.0, 4.0, "trv"))); %!test %! assert (precedes (infsupdec (1.0, 3.0, "trv"), infsupdec (3.0, 4.0, "def"))); %!test %! assert (precedes (infsupdec (-3.0, -1.0, "def"), infsupdec (-1.0, 0.0, "trv"))); %!test %! assert (precedes (infsupdec (-3.0, -1.0, "trv"), infsupdec (-1.0, -0.0, "trv"))); %!test %! assert (isequal (precedes (infsupdec (1.0, 3.5, "trv"), infsupdec (3.0, 4.0, "trv")), false)); %!test %! assert (isequal (precedes (infsupdec (1.0, 4.0, "trv"), infsupdec (3.0, 4.0, "trv")), false)); %!test %! assert (isequal (precedes (infsupdec (-3.0, -0.1, "trv"), infsupdec (-1.0, 0.0, "trv")), false)); %!test %! assert (precedes (infsupdec (0.0, 0.0, "trv"), infsupdec (-0.0, -0.0, "trv"))); %!test %! assert (precedes (infsupdec (-0.0, -0.0, "trv"), infsupdec (0.0, 0.0, "def"))); %!test %! assert (precedes (infsupdec (-0.0, 0.0, "trv"), infsupdec (0.0, 0.0, "trv"))); %!test %! assert (precedes (infsupdec (-0.0, 0.0, "def"), infsupdec (0.0, -0.0, "trv"))); %!test %! assert (precedes (infsupdec (0.0, -0.0, "trv"), infsupdec (0.0, 0.0, "trv"))); %!test %! assert (precedes (infsupdec (0.0, -0.0, "trv"), infsupdec (-0.0, 0.0, "trv"))); ## minimal_interior_test %!test %! assert (interior (infsup, infsup)); %!test %! assert (interior (infsup, infsup (0.0, 4.0))); %!test %! assert (isequal (interior (infsup (0.0, 4.0), infsup), false)); %!test %! assert (interior (infsup (-inf, inf), infsup (-inf, inf))); %!test %! assert (interior (infsup (0.0, 4.0), infsup (-inf, inf))); %!test %! assert (interior (infsup, infsup (-inf, inf))); %!test %! assert (isequal (interior (infsup (-inf, inf), infsup (0.0, 4.0)), false)); %!test %! assert (isequal (interior (infsup (0.0, 4.0), infsup (0.0, 4.0)), false)); %!test %! assert (interior (infsup (1.0, 2.0), infsup (0.0, 4.0))); %!test %! assert (isequal (interior (infsup (-2.0, 2.0), infsup (-2.0, 4.0)), false)); %!test %! assert (interior (infsup (-0.0, -0.0), infsup (-2.0, 4.0))); %!test %! assert (interior (infsup (0.0, 0.0), infsup (-2.0, 4.0))); %!test %! assert (isequal (interior (infsup (0.0, 0.0), infsup (-0.0, -0.0)), false)); %!test %! assert (isequal (interior (infsup (0.0, 4.4), infsup (0.0, 4.0)), false)); %!test %! assert (isequal (interior (infsup (-1.0, -1.0), infsup (0.0, 4.0)), false)); %!test %! assert (isequal (interior (infsup (2.0, 2.0), infsup (-2.0, -1.0)), false)); ## minimal_interior_dec_test %!test %! assert (interior (infsupdec (empty, "trv"), infsupdec (0.0, 4.0, "trv"))); %!test %! assert (isequal (interior (infsupdec (0.0, 4.0, "def"), infsupdec (empty, "trv")), false)); %!test %! assert (isequal (interior (infsupdec (0.0, 4.0, "trv"), infsupdec (empty, "trv")), false)); %!test %! assert (interior (infsupdec (-inf, inf, "trv"), infsupdec (-inf, inf, "trv"))); %!test %! assert (interior (infsupdec (0.0, 4.0, "trv"), infsupdec (-inf, inf, "trv"))); %!test %! assert (interior (infsupdec (empty, "trv"), infsupdec (-inf, inf, "trv"))); %!test %! assert (isequal (interior (infsupdec (-inf, inf, "trv"), infsupdec (0.0, 4.0, "trv")), false)); %!test %! assert (isequal (interior (infsupdec (0.0, 4.0, "trv"), infsupdec (0.0, 4.0, "trv")), false)); %!test %! assert (interior (infsupdec (1.0, 2.0, "def"), infsupdec (0.0, 4.0, "trv"))); %!test %! assert (isequal (interior (infsupdec (-2.0, 2.0, "trv"), infsupdec (-2.0, 4.0, "def")), false)); %!test %! assert (interior (infsupdec (-0.0, -0.0, "trv"), infsupdec (-2.0, 4.0, "trv"))); %!test %! assert (interior (infsupdec (0.0, 0.0, "def"), infsupdec (-2.0, 4.0, "trv"))); %!test %! assert (isequal (interior (infsupdec (0.0, 0.0, "trv"), infsupdec (-0.0, -0.0, "trv")), false)); %!test %! assert (isequal (interior (infsupdec (0.0, 4.4, "trv"), infsupdec (0.0, 4.0, "trv")), false)); %!test %! assert (isequal (interior (infsupdec (-1.0, -1.0, "trv"), infsupdec (0.0, 4.0, "def")), false)); %!test %! assert (isequal (interior (infsupdec (2.0, 2.0, "def"), infsupdec (-2.0, -1.0, "trv")), false)); ## minimal_strictLess_test %!test %! assert (lt (infsup, infsup)); %! assert (infsup < infsup); %!test %! assert (isequal (lt (infsup (1.0, 2.0), infsup), false)); %! assert (isequal (infsup (1.0, 2.0) < infsup, false)); %!test %! assert (isequal (lt (infsup, infsup (1.0, 2.0)), false)); %! assert (isequal (infsup < infsup (1.0, 2.0), false)); %!test %! assert (lt (infsup (-inf, inf), infsup (-inf, inf))); %! assert (infsup (-inf, inf) < infsup (-inf, inf)); %!test %! assert (isequal (lt (infsup (1.0, 2.0), infsup (-inf, inf)), false)); %! assert (isequal (infsup (1.0, 2.0) < infsup (-inf, inf), false)); %!test %! assert (isequal (lt (infsup (-inf, inf), infsup (1.0, 2.0)), false)); %! assert (isequal (infsup (-inf, inf) < infsup (1.0, 2.0), false)); %!test %! assert (isequal (lt (infsup (1.0, 2.0), infsup (1.0, 2.0)), false)); %! assert (isequal (infsup (1.0, 2.0) < infsup (1.0, 2.0), false)); %!test %! assert (lt (infsup (1.0, 2.0), infsup (3.0, 4.0))); %! assert (infsup (1.0, 2.0) < infsup (3.0, 4.0)); %!test %! assert (lt (infsup (1.0, 3.5), infsup (3.0, 4.0))); %! assert (infsup (1.0, 3.5) < infsup (3.0, 4.0)); %!test %! assert (isequal (lt (infsup (1.0, 4.0), infsup (3.0, 4.0)), false)); %! assert (isequal (infsup (1.0, 4.0) < infsup (3.0, 4.0), false)); %!test %! assert (isequal (lt (infsup (0.0, 4.0), infsup (0.0, 4.0)), false)); %! assert (isequal (infsup (0.0, 4.0) < infsup (0.0, 4.0), false)); %!test %! assert (isequal (lt (infsup (-0.0, 4.0), infsup (0.0, 4.0)), false)); %! assert (isequal (infsup (-0.0, 4.0) < infsup (0.0, 4.0), false)); %!test %! assert (isequal (lt (infsup (-2.0, -1.0), infsup (-2.0, -1.0)), false)); %! assert (isequal (infsup (-2.0, -1.0) < infsup (-2.0, -1.0), false)); %!test %! assert (lt (infsup (-3.0, -1.5), infsup (-2.0, -1.0))); %! assert (infsup (-3.0, -1.5) < infsup (-2.0, -1.0)); ## minimal_strictLess_dec_test %!test %! assert (isequal (lt (infsupdec (1.0, 2.0, "trv"), infsupdec (empty, "trv")), false)); %! assert (isequal (infsupdec (1.0, 2.0, "trv") < infsupdec (empty, "trv"), false)); %!test %! assert (isequal (lt (infsupdec (empty, "trv"), infsupdec (1.0, 2.0, "def")), false)); %! assert (isequal (infsupdec (empty, "trv") < infsupdec (1.0, 2.0, "def"), false)); %!test %! assert (isequal (lt (infsupdec (1.0, 2.0, "def"), infsupdec (empty, "trv")), false)); %! assert (isequal (infsupdec (1.0, 2.0, "def") < infsupdec (empty, "trv"), false)); %!test %! assert (isequal (lt (infsupdec (empty, "trv"), infsupdec (1.0, 2.0, "def")), false)); %! assert (isequal (infsupdec (empty, "trv") < infsupdec (1.0, 2.0, "def"), false)); %!test %! assert (lt (infsupdec (-inf, inf, "trv"), infsupdec (-inf, inf, "trv"))); %! assert (infsupdec (-inf, inf, "trv") < infsupdec (-inf, inf, "trv")); %!test %! assert (isequal (lt (infsupdec (1.0, 2.0, "trv"), infsupdec (-inf, inf, "trv")), false)); %! assert (isequal (infsupdec (1.0, 2.0, "trv") < infsupdec (-inf, inf, "trv"), false)); %!test %! assert (isequal (lt (infsupdec (-inf, inf, "trv"), infsupdec (1.0, 2.0, "trv")), false)); %! assert (isequal (infsupdec (-inf, inf, "trv") < infsupdec (1.0, 2.0, "trv"), false)); %!test %! assert (isequal (lt (infsupdec (1.0, 2.0, "trv"), infsupdec (1.0, 2.0, "trv")), false)); %! assert (isequal (infsupdec (1.0, 2.0, "trv") < infsupdec (1.0, 2.0, "trv"), false)); %!test %! assert (lt (infsupdec (1.0, 2.0, "trv"), infsupdec (3.0, 4.0, "trv"))); %! assert (infsupdec (1.0, 2.0, "trv") < infsupdec (3.0, 4.0, "trv")); %!test %! assert (lt (infsupdec (1.0, 3.5, "def"), infsupdec (3.0, 4.0, "trv"))); %! assert (infsupdec (1.0, 3.5, "def") < infsupdec (3.0, 4.0, "trv")); %!test %! assert (isequal (lt (infsupdec (1.0, 4.0, "trv"), infsupdec (3.0, 4.0, "def")), false)); %! assert (isequal (infsupdec (1.0, 4.0, "trv") < infsupdec (3.0, 4.0, "def"), false)); %!test %! assert (isequal (lt (infsupdec (0.0, 4.0, "trv"), infsupdec (0.0, 4.0, "def")), false)); %! assert (isequal (infsupdec (0.0, 4.0, "trv") < infsupdec (0.0, 4.0, "def"), false)); %!test %! assert (isequal (lt (infsupdec (-0.0, 4.0, "def"), infsupdec (0.0, 4.0, "trv")), false)); %! assert (isequal (infsupdec (-0.0, 4.0, "def") < infsupdec (0.0, 4.0, "trv"), false)); %!test %! assert (isequal (lt (infsupdec (-2.0, -1.0, "def"), infsupdec (-2.0, -1.0, "def")), false)); %! assert (isequal (infsupdec (-2.0, -1.0, "def") < infsupdec (-2.0, -1.0, "def"), false)); %!test %! assert (lt (infsupdec (-3.0, -1.5, "trv"), infsupdec (-2.0, -1.0, "trv"))); %! assert (infsupdec (-3.0, -1.5, "trv") < infsupdec (-2.0, -1.0, "trv")); ## minimal_strictPrecedes_test %!test %! assert (strictprecedes (infsup, infsup (3.0, 4.0))); %!test %! assert (strictprecedes (infsup (3.0, 4.0), infsup)); %!test %! assert (strictprecedes (infsup, infsup)); %!test %! assert (isequal (strictprecedes (infsup (1.0, 2.0), infsup (-inf, inf)), false)); %!test %! assert (isequal (strictprecedes (infsup (-inf, inf), infsup (1.0, 2.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (-inf, inf), infsup (-inf, inf)), false)); %!test %! assert (strictprecedes (infsup (1.0, 2.0), infsup (3.0, 4.0))); %!test %! assert (isequal (strictprecedes (infsup (1.0, 3.0), infsup (3.0, 4.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (-3.0, -1.0), infsup (-1.0, 0.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (-3.0, -0.0), infsup (0.0, 1.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (-3.0, 0.0), infsup (-0.0, 1.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (1.0, 3.5), infsup (3.0, 4.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (1.0, 4.0), infsup (3.0, 4.0)), false)); %!test %! assert (isequal (strictprecedes (infsup (-3.0, -0.1), infsup (-1.0, 0.0)), false)); ## minimal_strictPrecedes_dec_test %!test %! assert (strictprecedes (infsupdec (empty, "trv"), infsupdec (3.0, 4.0, "trv"))); %!test %! assert (strictprecedes (infsupdec (3.0, 4.0, "def"), infsupdec (empty, "trv"))); %!test %! assert (strictprecedes (infsupdec (empty, "trv"), infsupdec (3.0, 4.0, "trv"))); %!test %! assert (strictprecedes (infsupdec (3.0, 4.0, "def"), infsupdec (empty, "trv"))); %!test %! assert (isequal (strictprecedes (infsupdec (1.0, 2.0, "trv"), infsupdec (-inf, inf, "trv")), false)); %!test %! assert (isequal (strictprecedes (infsupdec (-inf, inf, "trv"), infsupdec (1.0, 2.0, "trv")), false)); %!test %! assert (isequal (strictprecedes (infsupdec (-inf, inf, "trv"), infsupdec (-inf, inf, "trv")), false)); %!test %! assert (strictprecedes (infsupdec (1.0, 2.0, "trv"), infsupdec (3.0, 4.0, "trv"))); %!test %! assert (isequal (strictprecedes (infsupdec (1.0, 3.0, "def"), infsupdec (3.0, 4.0, "trv")), false)); %!test %! assert (isequal (strictprecedes (infsupdec (-3.0, -1.0, "trv"), infsupdec (-1.0, 0.0, "def")), false)); %!test %! assert (isequal (strictprecedes (infsupdec (-3.0, -0.0, "def"), infsupdec (0.0, 1.0, "trv")), false)); %!test %! assert (isequal (strictprecedes (infsupdec (-3.0, 0.0, "trv"), infsupdec (-0.0, 1.0, "trv")), false)); %!test %! assert (isequal (strictprecedes (infsupdec (1.0, 3.5, "trv"), infsupdec (3.0, 4.0, "trv")), false)); %!test %! assert (isequal (strictprecedes (infsupdec (1.0, 4.0, "trv"), infsupdec (3.0, 4.0, "def")), false)); %!test %! assert (isequal (strictprecedes (infsupdec (-3.0, -0.1, "trv"), infsupdec (-1.0, 0.0, "trv")), false)); ## minimal_disjoint_test %!test %! assert (disjoint (infsup, infsup (3.0, 4.0))); %!test %! assert (disjoint (infsup (3.0, 4.0), infsup)); %!test %! assert (disjoint (infsup, infsup)); %!test %! assert (disjoint (infsup (3.0, 4.0), infsup (1.0, 2.0))); %!test %! assert (isequal (disjoint (infsup (0.0, 0.0), infsup (-0.0, -0.0)), false)); %!test %! assert (isequal (disjoint (infsup (0.0, -0.0), infsup (-0.0, 0.0)), false)); %!test %! assert (isequal (disjoint (infsup (3.0, 4.0), infsup (1.0, 7.0)), false)); %!test %! assert (isequal (disjoint (infsup (3.0, 4.0), infsup (-inf, inf)), false)); %!test %! assert (isequal (disjoint (infsup (-inf, inf), infsup (1.0, 7.0)), false)); %!test %! assert (isequal (disjoint (infsup (-inf, inf), infsup (-inf, inf)), false)); ## minimal_disjoint_dec_test %!test %! assert (disjoint (infsupdec (empty, "trv"), infsupdec (3.0, 4.0, "def"))); %!test %! assert (disjoint (infsupdec (3.0, 4.0, "trv"), infsupdec (empty, "trv"))); %!test %! assert (disjoint (infsupdec (empty, "trv"), infsupdec (3.0, 4.0, "trv"))); %!test %! assert (disjoint (infsupdec (3.0, 4.0, "trv"), infsupdec (empty, "trv"))); %!test %! assert (disjoint (infsupdec (3.0, 4.0, "trv"), infsupdec (1.0, 2.0, "def"))); %!test %! assert (isequal (disjoint (infsupdec (0.0, 0.0, "trv"), infsupdec (-0.0, -0.0, "trv")), false)); %!test %! assert (isequal (disjoint (infsupdec (0.0, -0.0, "trv"), infsupdec (-0.0, 0.0, "trv")), false)); %!test %! assert (isequal (disjoint (infsupdec (3.0, 4.0, "def"), infsupdec (1.0, 7.0, "def")), false)); %!test %! assert (isequal (disjoint (infsupdec (3.0, 4.0, "trv"), infsupdec (-inf, inf, "trv")), false)); %!test %! assert (isequal (disjoint (infsupdec (-inf, inf, "trv"), infsupdec (1.0, 7.0, "trv")), false)); %!test %! assert (isequal (disjoint (infsupdec (-inf, inf, "trv"), infsupdec (-inf, inf, "trv")), false)); interval-1.4.1/inst/test/fi_lib.tst0000644000175000017500000054206012657476051016663 0ustar oliveroliver## DO NOT EDIT! Generated automatically from test/fi_lib.itl ## by the Interval Testing Framework for IEEE 1788. ## https://github.com/nehmeier/ITF1788/tree/635bff73cc64ff8aab0ff2031ee8a53980be0115 ## ## Copyright 1997-2000 Institut fuer Wissenschaftliches Rechnen ## und Mathematische Modellbildung (IWRMM) ## and ## Institut fuer Angewandte Mathematik ## Universitaet Karlsruhe, Germany ## 2000-2005 Wiss. Rechnen/Softwaretechnologie ## Universitaet Wuppertal, Germany ## Copyright 2015-2016 Oliver Heimlich ## ## Original authors: Werner Hofschuster and Walter Kraemer ## (unit tests in FI_LIB version 1.2, original license: LGPLv2+) ## Converted into portable ITL format by Oliver Heimlich. ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## %!#Test library imports %!#Arithmetic library imports pkg load interval %!#Preamble try; error ("__FILE__"); catch test (lasterror.stack.file, "quiet", stdout); end_try_catch; %!function assert_warn (observed_value, expected_value) %! if (not (isequal (observed_value, expected_value))) %! observed_expression = regexprep (argn(1, :), '\s+$', ''); %! expected_expression = regexprep (argn(2, :), '\s+$', ''); %! observed_as_char = disp (observed_value)(1 : end - 1); %! expected_as_char = disp(expected_value)(1 : end - 1); %! warning ([observed_expression, " != ", expected_expression, ... %! "\n ", observed_as_char, " != ", expected_as_char]); %! endif %!endfunction ## FI_LIB.addii %!test %! assert (isequal (infsup (0.000000000000000000e+00, 0.000000000000000000e+00) + infsup (0.000000000000000000e+00, 0.000000000000000000e+00), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (plus (infsup (0.000000000000000000e+00, 0.000000000000000000e+00), infsup (0.000000000000000000e+00, 0.000000000000000000e+00)), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (1.000000000000000000e+00, 1.000000000000000000e+00) + infsup (2.000000000000000000e+00, 2.000000000000000000e+00), infsup (3.000000000000000000e+00, 3.000000000000000000e+00))); %! assert (isequal (plus (infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (2.000000000000000000e+00, 2.000000000000000000e+00)), infsup (3.000000000000000000e+00, 3.000000000000000000e+00))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, -1.000000000000000000e+00) + infsup (-2.000000000000000000e+00, -2.000000000000000000e+00), infsup (-3.000000000000000000e+00, -3.000000000000000000e+00))); %! assert (isequal (plus (infsup (-1.000000000000000000e+00, -1.000000000000000000e+00), infsup (-2.000000000000000000e+00, -2.000000000000000000e+00)), infsup (-3.000000000000000000e+00, -3.000000000000000000e+00))); %!test %! assert (isequal (infsup (1.000000000000000000e+00, 1.000000000000000000e+00) + infsup (-1.000000000000000000e+00, -1.000000000000000000e+00), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (plus (infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00)), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, -1.000000000000000000e+00) + infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (plus (infsup (-1.000000000000000000e+00, -1.000000000000000000e+00), infsup (1.000000000000000000e+00, 1.000000000000000000e+00)), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (9.999888671826830054e-321, 9.999888671826830054e-321) + infsup (9.999888671826830054e-321, 9.999888671826830054e-321), infsup (1.999977734365366011e-320, 1.999977734365366011e-320))); %! assert (isequal (plus (infsup (9.999888671826830054e-321, 9.999888671826830054e-321), infsup (9.999888671826830054e-321, 9.999888671826830054e-321)), infsup (1.999977734365366011e-320, 1.999977734365366011e-320))); %!test %! assert (isequal (infsup (9.999888671826830054e-321, 9.999888671826830054e-321) + infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %! assert (isequal (plus (infsup (9.999888671826830054e-321, 9.999888671826830054e-321), infsup (1.000000000000000000e+00, 1.000000000000000000e+00)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (infsup (-9.999888671826830054e-321, -9.999888671826830054e-321) + infsup (-9.999888671826830054e-321, -9.999888671826830054e-321), infsup (-1.999977734365366011e-320, -1.999977734365366011e-320))); %! assert (isequal (plus (infsup (-9.999888671826830054e-321, -9.999888671826830054e-321), infsup (-9.999888671826830054e-321, -9.999888671826830054e-321)), infsup (-1.999977734365366011e-320, -1.999977734365366011e-320))); %!test %! assert (isequal (infsup (-9.999888671826830054e-321, -9.999888671826830054e-321) + infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %! assert (isequal (plus (infsup (-9.999888671826830054e-321, -9.999888671826830054e-321), infsup (1.000000000000000000e+00, 1.000000000000000000e+00)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (infsup (1.797693134862315708e+308, 1.797693134862315708e+308) + infsup (-1.000000000000000000e+00, -1.000000000000000000e+00), infsup (1.797693134862315509e+308, 1.797693134862315708e+308))); %! assert (isequal (plus (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00)), infsup (1.797693134862315509e+308, 1.797693134862315708e+308))); %!test %! assert (isequal (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308) + infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (-1.797693134862315708e+308, -1.797693134862315509e+308))); %! assert (isequal (plus (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308), infsup (1.000000000000000000e+00, 1.000000000000000000e+00)), infsup (-1.797693134862315708e+308, -1.797693134862315509e+308))); %!test %! assert (isequal (infsup (0.000000000000000000e+00, 1.000000000000000000e+00) + infsup (1.000000000000000000e+00, 2.000000000000000000e+00), infsup (1.000000000000000000e+00, 3.000000000000000000e+00))); %! assert (isequal (plus (infsup (0.000000000000000000e+00, 1.000000000000000000e+00), infsup (1.000000000000000000e+00, 2.000000000000000000e+00)), infsup (1.000000000000000000e+00, 3.000000000000000000e+00))); %!test %! assert (isequal (infsup (1.000000000000000000e+00, 2.000000000000000000e+00) + infsup (0.000000000000000000e+00, 1.000000000000000000e+00), infsup (1.000000000000000000e+00, 3.000000000000000000e+00))); %! assert (isequal (plus (infsup (1.000000000000000000e+00, 2.000000000000000000e+00), infsup (0.000000000000000000e+00, 1.000000000000000000e+00)), infsup (1.000000000000000000e+00, 3.000000000000000000e+00))); %!test %! assert (isequal (infsup (1.000000000000000000e+00, 2.000000000000000000e+00) + infsup (3.000000000000000000e+00, 4.000000000000000000e+00), infsup (4.000000000000000000e+00, 6.000000000000000000e+00))); %! assert (isequal (plus (infsup (1.000000000000000000e+00, 2.000000000000000000e+00), infsup (3.000000000000000000e+00, 4.000000000000000000e+00)), infsup (4.000000000000000000e+00, 6.000000000000000000e+00))); %!test %! assert (isequal (infsup (3.000000000000000000e+00, 4.000000000000000000e+00) + infsup (1.000000000000000000e+00, 2.000000000000000000e+00), infsup (4.000000000000000000e+00, 6.000000000000000000e+00))); %! assert (isequal (plus (infsup (3.000000000000000000e+00, 4.000000000000000000e+00), infsup (1.000000000000000000e+00, 2.000000000000000000e+00)), infsup (4.000000000000000000e+00, 6.000000000000000000e+00))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, 0.000000000000000000e+00) + infsup (-4.000000000000000000e+00, -3.000000000000000000e+00), infsup (-5.000000000000000000e+00, -3.000000000000000000e+00))); %! assert (isequal (plus (infsup (-1.000000000000000000e+00, 0.000000000000000000e+00), infsup (-4.000000000000000000e+00, -3.000000000000000000e+00)), infsup (-5.000000000000000000e+00, -3.000000000000000000e+00))); %!test %! assert (isequal (infsup (-4.000000000000000000e+00, -3.000000000000000000e+00) + infsup (-1.000000000000000000e+00, 0.000000000000000000e+00), infsup (-5.000000000000000000e+00, -3.000000000000000000e+00))); %! assert (isequal (plus (infsup (-4.000000000000000000e+00, -3.000000000000000000e+00), infsup (-1.000000000000000000e+00, 0.000000000000000000e+00)), infsup (-5.000000000000000000e+00, -3.000000000000000000e+00))); %!test %! assert (isequal (infsup (-5.000000000000000000e+00, -4.000000000000000000e+00) + infsup (4.000000000000000000e+00, 5.000000000000000000e+00), infsup (-1.000000000000000000e+00, 1.000000000000000000e+00))); %! assert (isequal (plus (infsup (-5.000000000000000000e+00, -4.000000000000000000e+00), infsup (4.000000000000000000e+00, 5.000000000000000000e+00)), infsup (-1.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (infsup (4.000000000000000000e+00, 5.000000000000000000e+00) + infsup (-5.000000000000000000e+00, -4.000000000000000000e+00), infsup (-1.000000000000000000e+00, 1.000000000000000000e+00))); %! assert (isequal (plus (infsup (4.000000000000000000e+00, 5.000000000000000000e+00), infsup (-5.000000000000000000e+00, -4.000000000000000000e+00)), infsup (-1.000000000000000000e+00, 1.000000000000000000e+00))); ## FI_LIB.subii %!test %! assert (isequal (infsup (0.000000000000000000e+00, 0.000000000000000000e+00) - infsup (0.000000000000000000e+00, 0.000000000000000000e+00), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (minus (infsup (0.000000000000000000e+00, 0.000000000000000000e+00), infsup (0.000000000000000000e+00, 0.000000000000000000e+00)), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (1.000000000000000000e+00, 1.000000000000000000e+00) - infsup (2.000000000000000000e+00, 2.000000000000000000e+00), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00))); %! assert (isequal (minus (infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (2.000000000000000000e+00, 2.000000000000000000e+00)), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, -1.000000000000000000e+00) - infsup (-2.000000000000000000e+00, -2.000000000000000000e+00), infsup (1.000000000000000000e+00, 1.000000000000000000e+00))); %! assert (isequal (minus (infsup (-1.000000000000000000e+00, -1.000000000000000000e+00), infsup (-2.000000000000000000e+00, -2.000000000000000000e+00)), infsup (1.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (infsup (1.000000000000000000e+00, 1.000000000000000000e+00) - infsup (-1.000000000000000000e+00, -1.000000000000000000e+00), infsup (2.000000000000000000e+00, 2.000000000000000000e+00))); %! assert (isequal (minus (infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00)), infsup (2.000000000000000000e+00, 2.000000000000000000e+00))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, -1.000000000000000000e+00) - infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (-2.000000000000000000e+00, -2.000000000000000000e+00))); %! assert (isequal (minus (infsup (-1.000000000000000000e+00, -1.000000000000000000e+00), infsup (1.000000000000000000e+00, 1.000000000000000000e+00)), infsup (-2.000000000000000000e+00, -2.000000000000000000e+00))); %!test %! assert (isequal (infsup (9.999888671826830054e-321, 9.999888671826830054e-321) - infsup (9.999888671826830054e-321, 9.999888671826830054e-321), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (minus (infsup (9.999888671826830054e-321, 9.999888671826830054e-321), infsup (9.999888671826830054e-321, 9.999888671826830054e-321)), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (9.999888671826830054e-321, 9.999888671826830054e-321) - infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (-1.000000000000000000e+00, -9.999999999999998890e-01))); %! assert (isequal (minus (infsup (9.999888671826830054e-321, 9.999888671826830054e-321), infsup (1.000000000000000000e+00, 1.000000000000000000e+00)), infsup (-1.000000000000000000e+00, -9.999999999999998890e-01))); %!test %! assert (isequal (infsup (-9.999888671826830054e-321, -9.999888671826830054e-321) - infsup (-9.999888671826830054e-321, -9.999888671826830054e-321), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (minus (infsup (-9.999888671826830054e-321, -9.999888671826830054e-321), infsup (-9.999888671826830054e-321, -9.999888671826830054e-321)), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (-9.999888671826830054e-321, -9.999888671826830054e-321) - infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (-1.000000000000000222e+00, -1.000000000000000000e+00))); %! assert (isequal (minus (infsup (-9.999888671826830054e-321, -9.999888671826830054e-321), infsup (1.000000000000000000e+00, 1.000000000000000000e+00)), infsup (-1.000000000000000222e+00, -1.000000000000000000e+00))); %!test %! assert (isequal (infsup (1.797693134862315708e+308, 1.797693134862315708e+308) - infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (1.797693134862315509e+308, 1.797693134862315708e+308))); %! assert (isequal (minus (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), infsup (1.000000000000000000e+00, 1.000000000000000000e+00)), infsup (1.797693134862315509e+308, 1.797693134862315708e+308))); %!test %! assert (isequal (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308) - infsup (-1.000000000000000000e+00, -1.000000000000000000e+00), infsup (-1.797693134862315708e+308, -1.797693134862315509e+308))); %! assert (isequal (minus (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00)), infsup (-1.797693134862315708e+308, -1.797693134862315509e+308))); %!test %! assert (isequal (infsup (0.000000000000000000e+00, 1.000000000000000000e+00) - infsup (1.000000000000000000e+00, 2.000000000000000000e+00), infsup (-2.000000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (minus (infsup (0.000000000000000000e+00, 1.000000000000000000e+00), infsup (1.000000000000000000e+00, 2.000000000000000000e+00)), infsup (-2.000000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (1.000000000000000000e+00, 2.000000000000000000e+00) - infsup (0.000000000000000000e+00, 1.000000000000000000e+00), infsup (0.000000000000000000e+00, 2.000000000000000000e+00))); %! assert (isequal (minus (infsup (1.000000000000000000e+00, 2.000000000000000000e+00), infsup (0.000000000000000000e+00, 1.000000000000000000e+00)), infsup (0.000000000000000000e+00, 2.000000000000000000e+00))); %!test %! assert (isequal (infsup (1.000000000000000000e+00, 2.000000000000000000e+00) - infsup (3.000000000000000000e+00, 4.000000000000000000e+00), infsup (-3.000000000000000000e+00, -1.000000000000000000e+00))); %! assert (isequal (minus (infsup (1.000000000000000000e+00, 2.000000000000000000e+00), infsup (3.000000000000000000e+00, 4.000000000000000000e+00)), infsup (-3.000000000000000000e+00, -1.000000000000000000e+00))); %!test %! assert (isequal (infsup (3.000000000000000000e+00, 4.000000000000000000e+00) - infsup (1.000000000000000000e+00, 2.000000000000000000e+00), infsup (1.000000000000000000e+00, 3.000000000000000000e+00))); %! assert (isequal (minus (infsup (3.000000000000000000e+00, 4.000000000000000000e+00), infsup (1.000000000000000000e+00, 2.000000000000000000e+00)), infsup (1.000000000000000000e+00, 3.000000000000000000e+00))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, 0.000000000000000000e+00) - infsup (-4.000000000000000000e+00, -3.000000000000000000e+00), infsup (2.000000000000000000e+00, 4.000000000000000000e+00))); %! assert (isequal (minus (infsup (-1.000000000000000000e+00, 0.000000000000000000e+00), infsup (-4.000000000000000000e+00, -3.000000000000000000e+00)), infsup (2.000000000000000000e+00, 4.000000000000000000e+00))); %!test %! assert (isequal (infsup (-4.000000000000000000e+00, -3.000000000000000000e+00) - infsup (-1.000000000000000000e+00, 0.000000000000000000e+00), infsup (-4.000000000000000000e+00, -2.000000000000000000e+00))); %! assert (isequal (minus (infsup (-4.000000000000000000e+00, -3.000000000000000000e+00), infsup (-1.000000000000000000e+00, 0.000000000000000000e+00)), infsup (-4.000000000000000000e+00, -2.000000000000000000e+00))); %!test %! assert (isequal (infsup (-5.000000000000000000e+00, -4.000000000000000000e+00) - infsup (4.000000000000000000e+00, 5.000000000000000000e+00), infsup (-1.000000000000000000e+01, -8.000000000000000000e+00))); %! assert (isequal (minus (infsup (-5.000000000000000000e+00, -4.000000000000000000e+00), infsup (4.000000000000000000e+00, 5.000000000000000000e+00)), infsup (-1.000000000000000000e+01, -8.000000000000000000e+00))); %!test %! assert (isequal (infsup (4.000000000000000000e+00, 5.000000000000000000e+00) - infsup (-5.000000000000000000e+00, -4.000000000000000000e+00), infsup (8.000000000000000000e+00, 1.000000000000000000e+01))); %! assert (isequal (minus (infsup (4.000000000000000000e+00, 5.000000000000000000e+00), infsup (-5.000000000000000000e+00, -4.000000000000000000e+00)), infsup (8.000000000000000000e+00, 1.000000000000000000e+01))); ## FI_LIB.mulii %!test %! assert (isequal (infsup (0.000000000000000000e+00, 0.000000000000000000e+00) .* infsup (0.000000000000000000e+00, 0.000000000000000000e+00), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (times (infsup (0.000000000000000000e+00, 0.000000000000000000e+00), infsup (0.000000000000000000e+00, 0.000000000000000000e+00)), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, -1.000000000000000000e+00) .* infsup (-1.000000000000000000e+00, -1.000000000000000000e+00), infsup (1.000000000000000000e+00, 1.000000000000000000e+00))); %! assert (isequal (times (infsup (-1.000000000000000000e+00, -1.000000000000000000e+00), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00)), infsup (1.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, -1.000000000000000000e+00) .* infsup (0.000000000000000000e+00, 0.000000000000000000e+00), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (times (infsup (-1.000000000000000000e+00, -1.000000000000000000e+00), infsup (0.000000000000000000e+00, 0.000000000000000000e+00)), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, -1.000000000000000000e+00) .* infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00))); %! assert (isequal (times (infsup (-1.000000000000000000e+00, -1.000000000000000000e+00), infsup (1.000000000000000000e+00, 1.000000000000000000e+00)), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00))); %!test %! assert (isequal (infsup (0.000000000000000000e+00, 0.000000000000000000e+00) .* infsup (-1.000000000000000000e+00, -1.000000000000000000e+00), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (times (infsup (0.000000000000000000e+00, 0.000000000000000000e+00), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00)), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (0.000000000000000000e+00, 0.000000000000000000e+00) .* infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (times (infsup (0.000000000000000000e+00, 0.000000000000000000e+00), infsup (1.000000000000000000e+00, 1.000000000000000000e+00)), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (1.000000000000000000e+00, 1.000000000000000000e+00) .* infsup (-1.000000000000000000e+00, -1.000000000000000000e+00), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00))); %! assert (isequal (times (infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00)), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00))); %!test %! assert (isequal (infsup (1.000000000000000000e+00, 1.000000000000000000e+00) .* infsup (0.000000000000000000e+00, 0.000000000000000000e+00), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (times (infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (0.000000000000000000e+00, 0.000000000000000000e+00)), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (1.000000000000000000e+00, 1.000000000000000000e+00) .* infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (1.000000000000000000e+00, 1.000000000000000000e+00))); %! assert (isequal (times (infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (1.000000000000000000e+00, 1.000000000000000000e+00)), infsup (1.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (infsup (1.797693134862315708e+308, 1.797693134862315708e+308) .* infsup (5.000000000000000000e-01, 5.000000000000000000e-01), infsup (8.988465674311578541e+307, 8.988465674311578541e+307))); %! assert (isequal (times (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), infsup (5.000000000000000000e-01, 5.000000000000000000e-01)), infsup (8.988465674311578541e+307, 8.988465674311578541e+307))); %!test %! assert (isequal (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308) .* infsup (5.000000000000000000e-01, 5.000000000000000000e-01), infsup (-8.988465674311578541e+307, -8.988465674311578541e+307))); %! assert (isequal (times (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308), infsup (5.000000000000000000e-01, 5.000000000000000000e-01)), infsup (-8.988465674311578541e+307, -8.988465674311578541e+307))); %!test %! assert (isequal (infsup (9.999888671826830054e-321, 9.999888671826830054e-321) .* infsup (9.999888671826830054e-321, 9.999888671826830054e-321), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %! assert (isequal (times (infsup (9.999888671826830054e-321, 9.999888671826830054e-321), infsup (9.999888671826830054e-321, 9.999888671826830054e-321)), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %!test %! assert (isequal (infsup (9.999888671826830054e-321, 9.999888671826830054e-321) .* infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (9.999888671826830054e-321, 9.999888671826830054e-321))); %! assert (isequal (times (infsup (9.999888671826830054e-321, 9.999888671826830054e-321), infsup (1.000000000000000000e+00, 1.000000000000000000e+00)), infsup (9.999888671826830054e-321, 9.999888671826830054e-321))); %!test %! assert (isequal (infsup (9.999888671826830054e-321, 9.999888671826830054e-321) .* infsup (-1.000000000000000000e+00, -1.000000000000000000e+00), infsup (-9.999888671826830054e-321, -9.999888671826830054e-321))); %! assert (isequal (times (infsup (9.999888671826830054e-321, 9.999888671826830054e-321), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00)), infsup (-9.999888671826830054e-321, -9.999888671826830054e-321))); %!test %! assert (isequal (infsup (-3.000000000000000000e+00, -2.000000000000000000e+00) .* infsup (-3.000000000000000000e+00, -2.000000000000000000e+00), infsup (4.000000000000000000e+00, 9.000000000000000000e+00))); %! assert (isequal (times (infsup (-3.000000000000000000e+00, -2.000000000000000000e+00), infsup (-3.000000000000000000e+00, -2.000000000000000000e+00)), infsup (4.000000000000000000e+00, 9.000000000000000000e+00))); %!test %! assert (isequal (infsup (-3.000000000000000000e+00, -2.000000000000000000e+00) .* infsup (-1.000000000000000000e+00, 1.000000000000000000e+00), infsup (-3.000000000000000000e+00, 3.000000000000000000e+00))); %! assert (isequal (times (infsup (-3.000000000000000000e+00, -2.000000000000000000e+00), infsup (-1.000000000000000000e+00, 1.000000000000000000e+00)), infsup (-3.000000000000000000e+00, 3.000000000000000000e+00))); %!test %! assert (isequal (infsup (-3.000000000000000000e+00, -2.000000000000000000e+00) .* infsup (2.000000000000000000e+00, 3.000000000000000000e+00), infsup (-9.000000000000000000e+00, -4.000000000000000000e+00))); %! assert (isequal (times (infsup (-3.000000000000000000e+00, -2.000000000000000000e+00), infsup (2.000000000000000000e+00, 3.000000000000000000e+00)), infsup (-9.000000000000000000e+00, -4.000000000000000000e+00))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, 1.000000000000000000e+00) .* infsup (-3.000000000000000000e+00, -2.000000000000000000e+00), infsup (-3.000000000000000000e+00, 3.000000000000000000e+00))); %! assert (isequal (times (infsup (-1.000000000000000000e+00, 1.000000000000000000e+00), infsup (-3.000000000000000000e+00, -2.000000000000000000e+00)), infsup (-3.000000000000000000e+00, 3.000000000000000000e+00))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, 1.000000000000000000e+00) .* infsup (-1.000000000000000000e+00, 1.000000000000000000e+00), infsup (-1.000000000000000000e+00, 1.000000000000000000e+00))); %! assert (isequal (times (infsup (-1.000000000000000000e+00, 1.000000000000000000e+00), infsup (-1.000000000000000000e+00, 1.000000000000000000e+00)), infsup (-1.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, 1.000000000000000000e+00) .* infsup (2.000000000000000000e+00, 3.000000000000000000e+00), infsup (-3.000000000000000000e+00, 3.000000000000000000e+00))); %! assert (isequal (times (infsup (-1.000000000000000000e+00, 1.000000000000000000e+00), infsup (2.000000000000000000e+00, 3.000000000000000000e+00)), infsup (-3.000000000000000000e+00, 3.000000000000000000e+00))); %!test %! assert (isequal (infsup (2.000000000000000000e+00, 3.000000000000000000e+00) .* infsup (-3.000000000000000000e+00, -2.000000000000000000e+00), infsup (-9.000000000000000000e+00, -4.000000000000000000e+00))); %! assert (isequal (times (infsup (2.000000000000000000e+00, 3.000000000000000000e+00), infsup (-3.000000000000000000e+00, -2.000000000000000000e+00)), infsup (-9.000000000000000000e+00, -4.000000000000000000e+00))); %!test %! assert (isequal (infsup (2.000000000000000000e+00, 3.000000000000000000e+00) .* infsup (-1.000000000000000000e+00, 1.000000000000000000e+00), infsup (-3.000000000000000000e+00, 3.000000000000000000e+00))); %! assert (isequal (times (infsup (2.000000000000000000e+00, 3.000000000000000000e+00), infsup (-1.000000000000000000e+00, 1.000000000000000000e+00)), infsup (-3.000000000000000000e+00, 3.000000000000000000e+00))); %!test %! assert (isequal (infsup (2.000000000000000000e+00, 3.000000000000000000e+00) .* infsup (2.000000000000000000e+00, 3.000000000000000000e+00), infsup (4.000000000000000000e+00, 9.000000000000000000e+00))); %! assert (isequal (times (infsup (2.000000000000000000e+00, 3.000000000000000000e+00), infsup (2.000000000000000000e+00, 3.000000000000000000e+00)), infsup (4.000000000000000000e+00, 9.000000000000000000e+00))); %!test %! assert (isequal (infsup (-5.000000000000000000e+00, 2.000000000000000000e+00) .* infsup (-4.000000000000000000e+00, 3.000000000000000000e+00), infsup (-1.500000000000000000e+01, 2.000000000000000000e+01))); %! assert (isequal (times (infsup (-5.000000000000000000e+00, 2.000000000000000000e+00), infsup (-4.000000000000000000e+00, 3.000000000000000000e+00)), infsup (-1.500000000000000000e+01, 2.000000000000000000e+01))); %!test %! assert (isequal (infsup (-5.000000000000000000e+00, 2.000000000000000000e+00) .* infsup (-3.000000000000000000e+00, 8.000000000000000000e+00), infsup (-4.000000000000000000e+01, 1.600000000000000000e+01))); %! assert (isequal (times (infsup (-5.000000000000000000e+00, 2.000000000000000000e+00), infsup (-3.000000000000000000e+00, 8.000000000000000000e+00)), infsup (-4.000000000000000000e+01, 1.600000000000000000e+01))); %!test %! assert (isequal (infsup (-2.000000000000000000e+00, 5.000000000000000000e+00) .* infsup (-4.000000000000000000e+00, 3.000000000000000000e+00), infsup (-2.000000000000000000e+01, 1.500000000000000000e+01))); %! assert (isequal (times (infsup (-2.000000000000000000e+00, 5.000000000000000000e+00), infsup (-4.000000000000000000e+00, 3.000000000000000000e+00)), infsup (-2.000000000000000000e+01, 1.500000000000000000e+01))); %!test %! assert (isequal (infsup (-4.000000000000000000e+00, 5.000000000000000000e+00) .* infsup (-4.000000000000000000e+00, 3.000000000000000000e+00), infsup (-2.000000000000000000e+01, 1.600000000000000000e+01))); %! assert (isequal (times (infsup (-4.000000000000000000e+00, 5.000000000000000000e+00), infsup (-4.000000000000000000e+00, 3.000000000000000000e+00)), infsup (-2.000000000000000000e+01, 1.600000000000000000e+01))); %!test %! assert (isequal (infsup (-3.000000000000000000e+00, 0.000000000000000000e+00) .* infsup (-3.000000000000000000e+00, -2.000000000000000000e+00), infsup (0.000000000000000000e+00, 9.000000000000000000e+00))); %! assert (isequal (times (infsup (-3.000000000000000000e+00, 0.000000000000000000e+00), infsup (-3.000000000000000000e+00, -2.000000000000000000e+00)), infsup (0.000000000000000000e+00, 9.000000000000000000e+00))); %!test %! assert (isequal (infsup (-3.000000000000000000e+00, 0.000000000000000000e+00) .* infsup (-1.000000000000000000e+00, 1.000000000000000000e+00), infsup (-3.000000000000000000e+00, 3.000000000000000000e+00))); %! assert (isequal (times (infsup (-3.000000000000000000e+00, 0.000000000000000000e+00), infsup (-1.000000000000000000e+00, 1.000000000000000000e+00)), infsup (-3.000000000000000000e+00, 3.000000000000000000e+00))); %!test %! assert (isequal (infsup (-3.000000000000000000e+00, 0.000000000000000000e+00) .* infsup (2.000000000000000000e+00, 3.000000000000000000e+00), infsup (-9.000000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (times (infsup (-3.000000000000000000e+00, 0.000000000000000000e+00), infsup (2.000000000000000000e+00, 3.000000000000000000e+00)), infsup (-9.000000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (-3.000000000000000000e+00, -2.000000000000000000e+00) .* infsup (-3.000000000000000000e+00, 0.000000000000000000e+00), infsup (0.000000000000000000e+00, 9.000000000000000000e+00))); %! assert (isequal (times (infsup (-3.000000000000000000e+00, -2.000000000000000000e+00), infsup (-3.000000000000000000e+00, 0.000000000000000000e+00)), infsup (0.000000000000000000e+00, 9.000000000000000000e+00))); %!test %! assert (isequal (infsup (-3.000000000000000000e+00, -2.000000000000000000e+00) .* infsup (0.000000000000000000e+00, 3.000000000000000000e+00), infsup (-9.000000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (times (infsup (-3.000000000000000000e+00, -2.000000000000000000e+00), infsup (0.000000000000000000e+00, 3.000000000000000000e+00)), infsup (-9.000000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, 1.000000000000000000e+00) .* infsup (-3.000000000000000000e+00, 0.000000000000000000e+00), infsup (-3.000000000000000000e+00, 3.000000000000000000e+00))); %! assert (isequal (times (infsup (-1.000000000000000000e+00, 1.000000000000000000e+00), infsup (-3.000000000000000000e+00, 0.000000000000000000e+00)), infsup (-3.000000000000000000e+00, 3.000000000000000000e+00))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, 1.000000000000000000e+00) .* infsup (0.000000000000000000e+00, 3.000000000000000000e+00), infsup (-3.000000000000000000e+00, 3.000000000000000000e+00))); %! assert (isequal (times (infsup (-1.000000000000000000e+00, 1.000000000000000000e+00), infsup (0.000000000000000000e+00, 3.000000000000000000e+00)), infsup (-3.000000000000000000e+00, 3.000000000000000000e+00))); %!test %! assert (isequal (infsup (0.000000000000000000e+00, 3.000000000000000000e+00) .* infsup (-3.000000000000000000e+00, -2.000000000000000000e+00), infsup (-9.000000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (times (infsup (0.000000000000000000e+00, 3.000000000000000000e+00), infsup (-3.000000000000000000e+00, -2.000000000000000000e+00)), infsup (-9.000000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (0.000000000000000000e+00, 3.000000000000000000e+00) .* infsup (-1.000000000000000000e+00, 1.000000000000000000e+00), infsup (-3.000000000000000000e+00, 3.000000000000000000e+00))); %! assert (isequal (times (infsup (0.000000000000000000e+00, 3.000000000000000000e+00), infsup (-1.000000000000000000e+00, 1.000000000000000000e+00)), infsup (-3.000000000000000000e+00, 3.000000000000000000e+00))); %!test %! assert (isequal (infsup (0.000000000000000000e+00, 3.000000000000000000e+00) .* infsup (2.000000000000000000e+00, 3.000000000000000000e+00), infsup (0.000000000000000000e+00, 9.000000000000000000e+00))); %! assert (isequal (times (infsup (0.000000000000000000e+00, 3.000000000000000000e+00), infsup (2.000000000000000000e+00, 3.000000000000000000e+00)), infsup (0.000000000000000000e+00, 9.000000000000000000e+00))); %!test %! assert (isequal (infsup (2.000000000000000000e+00, 3.000000000000000000e+00) .* infsup (-3.000000000000000000e+00, 0.000000000000000000e+00), infsup (-9.000000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (times (infsup (2.000000000000000000e+00, 3.000000000000000000e+00), infsup (-3.000000000000000000e+00, 0.000000000000000000e+00)), infsup (-9.000000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (2.000000000000000000e+00, 3.000000000000000000e+00) .* infsup (-3.000000000000000000e+00, 0.000000000000000000e+00), infsup (-9.000000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (times (infsup (2.000000000000000000e+00, 3.000000000000000000e+00), infsup (-3.000000000000000000e+00, 0.000000000000000000e+00)), infsup (-9.000000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (0.000000000000000000e+00, 2.000000000000000000e+00) .* infsup (-3.000000000000000000e+00, 0.000000000000000000e+00), infsup (-6.000000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (times (infsup (0.000000000000000000e+00, 2.000000000000000000e+00), infsup (-3.000000000000000000e+00, 0.000000000000000000e+00)), infsup (-6.000000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (-9.999888671826830054e-321, -9.999888671826830054e-321) .* infsup (-9.999888671826830054e-321, -9.999888671826830054e-321), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %! assert (isequal (times (infsup (-9.999888671826830054e-321, -9.999888671826830054e-321), infsup (-9.999888671826830054e-321, -9.999888671826830054e-321)), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %!test %! assert (isequal (infsup (-9.999888671826830054e-321, -9.999888671826830054e-321) .* infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (-9.999888671826830054e-321, -9.999888671826830054e-321))); %! assert (isequal (times (infsup (-9.999888671826830054e-321, -9.999888671826830054e-321), infsup (1.000000000000000000e+00, 1.000000000000000000e+00)), infsup (-9.999888671826830054e-321, -9.999888671826830054e-321))); %!test %! assert (isequal (infsup (-9.999888671826830054e-321, -9.999888671826830054e-321) .* infsup (-1.000000000000000000e+00, -1.000000000000000000e+00), infsup (9.999888671826830054e-321, 9.999888671826830054e-321))); %! assert (isequal (times (infsup (-9.999888671826830054e-321, -9.999888671826830054e-321), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00)), infsup (9.999888671826830054e-321, 9.999888671826830054e-321))); %!test %! assert (isequal (infsup (-9.999888671826830054e-321, -9.999888671826830054e-321) .* infsup (9.999888671826830054e-321, 9.999888671826830054e-321), infsup (-4.940656458412465442e-324, 0.000000000000000000e+00))); %! assert (isequal (times (infsup (-9.999888671826830054e-321, -9.999888671826830054e-321), infsup (9.999888671826830054e-321, 9.999888671826830054e-321)), infsup (-4.940656458412465442e-324, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (-9.999888671826830054e-321, -9.999888671826830054e-321) .* infsup (0.000000000000000000e+00, 0.000000000000000000e+00), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (times (infsup (-9.999888671826830054e-321, -9.999888671826830054e-321), infsup (0.000000000000000000e+00, 0.000000000000000000e+00)), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (9.999888671826830054e-321, 9.999888671826830054e-321) .* infsup (0.000000000000000000e+00, 0.000000000000000000e+00), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (times (infsup (9.999888671826830054e-321, 9.999888671826830054e-321), infsup (0.000000000000000000e+00, 0.000000000000000000e+00)), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); ## FI_LIB.divii %!test %! assert (isequal (infsup (-1.000000000000000000e+00, -1.000000000000000000e+00) ./ infsup (-1.000000000000000000e+00, -1.000000000000000000e+00), infsup (1.000000000000000000e+00, 1.000000000000000000e+00))); %! assert (isequal (rdivide (infsup (-1.000000000000000000e+00, -1.000000000000000000e+00), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00)), infsup (1.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, -1.000000000000000000e+00) ./ infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00))); %! assert (isequal (rdivide (infsup (-1.000000000000000000e+00, -1.000000000000000000e+00), infsup (1.000000000000000000e+00, 1.000000000000000000e+00)), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00))); %!test %! assert (isequal (infsup (0.000000000000000000e+00, 0.000000000000000000e+00) ./ infsup (-1.000000000000000000e+00, -1.000000000000000000e+00), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (rdivide (infsup (0.000000000000000000e+00, 0.000000000000000000e+00), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00)), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (0.000000000000000000e+00, 0.000000000000000000e+00) ./ infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (rdivide (infsup (0.000000000000000000e+00, 0.000000000000000000e+00), infsup (1.000000000000000000e+00, 1.000000000000000000e+00)), infsup (0.000000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (1.000000000000000000e+00, 1.000000000000000000e+00) ./ infsup (-1.000000000000000000e+00, -1.000000000000000000e+00), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00))); %! assert (isequal (rdivide (infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00)), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00))); %!test %! assert (isequal (infsup (1.000000000000000000e+00, 1.000000000000000000e+00) ./ infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (1.000000000000000000e+00, 1.000000000000000000e+00))); %! assert (isequal (rdivide (infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (1.000000000000000000e+00, 1.000000000000000000e+00)), infsup (1.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (infsup (1.797693134862315708e+308, 1.797693134862315708e+308) ./ infsup (2.000000000000000000e+00, 2.000000000000000000e+00), infsup (8.988465674311578541e+307, 8.988465674311578541e+307))); %! assert (isequal (rdivide (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), infsup (2.000000000000000000e+00, 2.000000000000000000e+00)), infsup (8.988465674311578541e+307, 8.988465674311578541e+307))); %!test %! assert (isequal (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308) ./ infsup (2.000000000000000000e+00, 2.000000000000000000e+00), infsup (-8.988465674311578541e+307, -8.988465674311578541e+307))); %! assert (isequal (rdivide (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308), infsup (2.000000000000000000e+00, 2.000000000000000000e+00)), infsup (-8.988465674311578541e+307, -8.988465674311578541e+307))); %!test %! assert (isequal (infsup (9.999888671826830054e-321, 9.999888671826830054e-321) ./ infsup (9.999888671826830054e-321, 9.999888671826830054e-321), infsup (1.000000000000000000e+00, 1.000000000000000000e+00))); %! assert (isequal (rdivide (infsup (9.999888671826830054e-321, 9.999888671826830054e-321), infsup (9.999888671826830054e-321, 9.999888671826830054e-321)), infsup (1.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (infsup (9.999888671826830054e-321, 9.999888671826830054e-321) ./ infsup (1.000000000000000000e+00, 1.000000000000000000e+00), infsup (9.999888671826830054e-321, 9.999888671826830054e-321))); %! assert (isequal (rdivide (infsup (9.999888671826830054e-321, 9.999888671826830054e-321), infsup (1.000000000000000000e+00, 1.000000000000000000e+00)), infsup (9.999888671826830054e-321, 9.999888671826830054e-321))); %!test %! assert (isequal (infsup (9.999888671826830054e-321, 9.999888671826830054e-321) ./ infsup (-1.000000000000000000e+00, -1.000000000000000000e+00), infsup (-9.999888671826830054e-321, -9.999888671826830054e-321))); %! assert (isequal (rdivide (infsup (9.999888671826830054e-321, 9.999888671826830054e-321), infsup (-1.000000000000000000e+00, -1.000000000000000000e+00)), infsup (-9.999888671826830054e-321, -9.999888671826830054e-321))); %!test %! assert (isequal (infsup (-3.000000000000000000e+00, -2.000000000000000000e+00) ./ infsup (-3.000000000000000000e+00, -2.000000000000000000e+00), infsup (6.666666666666666297e-01, 1.500000000000000000e+00))); %! assert (isequal (rdivide (infsup (-3.000000000000000000e+00, -2.000000000000000000e+00), infsup (-3.000000000000000000e+00, -2.000000000000000000e+00)), infsup (6.666666666666666297e-01, 1.500000000000000000e+00))); %!test %! assert (isequal (infsup (-3.000000000000000000e+00, -2.000000000000000000e+00) ./ infsup (2.000000000000000000e+00, 3.000000000000000000e+00), infsup (-1.500000000000000000e+00, -6.666666666666666297e-01))); %! assert (isequal (rdivide (infsup (-3.000000000000000000e+00, -2.000000000000000000e+00), infsup (2.000000000000000000e+00, 3.000000000000000000e+00)), infsup (-1.500000000000000000e+00, -6.666666666666666297e-01))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, 1.000000000000000000e+00) ./ infsup (-3.000000000000000000e+00, -2.000000000000000000e+00), infsup (-5.000000000000000000e-01, 5.000000000000000000e-01))); %! assert (isequal (rdivide (infsup (-1.000000000000000000e+00, 1.000000000000000000e+00), infsup (-3.000000000000000000e+00, -2.000000000000000000e+00)), infsup (-5.000000000000000000e-01, 5.000000000000000000e-01))); %!test %! assert (isequal (infsup (-1.000000000000000000e+00, 1.000000000000000000e+00) ./ infsup (2.000000000000000000e+00, 3.000000000000000000e+00), infsup (-5.000000000000000000e-01, 5.000000000000000000e-01))); %! assert (isequal (rdivide (infsup (-1.000000000000000000e+00, 1.000000000000000000e+00), infsup (2.000000000000000000e+00, 3.000000000000000000e+00)), infsup (-5.000000000000000000e-01, 5.000000000000000000e-01))); %!test %! assert (isequal (infsup (2.000000000000000000e+00, 3.000000000000000000e+00) ./ infsup (-3.000000000000000000e+00, -2.000000000000000000e+00), infsup (-1.500000000000000000e+00, -6.666666666666666297e-01))); %! assert (isequal (rdivide (infsup (2.000000000000000000e+00, 3.000000000000000000e+00), infsup (-3.000000000000000000e+00, -2.000000000000000000e+00)), infsup (-1.500000000000000000e+00, -6.666666666666666297e-01))); %!test %! assert (isequal (infsup (2.000000000000000000e+00, 3.000000000000000000e+00) ./ infsup (2.000000000000000000e+00, 3.000000000000000000e+00), infsup (6.666666666666666297e-01, 1.500000000000000000e+00))); %! assert (isequal (rdivide (infsup (2.000000000000000000e+00, 3.000000000000000000e+00), infsup (2.000000000000000000e+00, 3.000000000000000000e+00)), infsup (6.666666666666666297e-01, 1.500000000000000000e+00))); %!test %! assert (isequal (infsup (-3.000000000000000000e+00, 0.000000000000000000e+00) ./ infsup (-3.000000000000000000e+00, -2.000000000000000000e+00), infsup (0.000000000000000000e+00, 1.500000000000000000e+00))); %! assert (isequal (rdivide (infsup (-3.000000000000000000e+00, 0.000000000000000000e+00), infsup (-3.000000000000000000e+00, -2.000000000000000000e+00)), infsup (0.000000000000000000e+00, 1.500000000000000000e+00))); %!test %! assert (isequal (infsup (-3.000000000000000000e+00, 0.000000000000000000e+00) ./ infsup (2.000000000000000000e+00, 3.000000000000000000e+00), infsup (-1.500000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (rdivide (infsup (-3.000000000000000000e+00, 0.000000000000000000e+00), infsup (2.000000000000000000e+00, 3.000000000000000000e+00)), infsup (-1.500000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (0.000000000000000000e+00, 3.000000000000000000e+00) ./ infsup (-3.000000000000000000e+00, -2.000000000000000000e+00), infsup (-1.500000000000000000e+00, 0.000000000000000000e+00))); %! assert (isequal (rdivide (infsup (0.000000000000000000e+00, 3.000000000000000000e+00), infsup (-3.000000000000000000e+00, -2.000000000000000000e+00)), infsup (-1.500000000000000000e+00, 0.000000000000000000e+00))); %!test %! assert (isequal (infsup (0.000000000000000000e+00, 3.000000000000000000e+00) ./ infsup (2.000000000000000000e+00, 3.000000000000000000e+00), infsup (0.000000000000000000e+00, 1.500000000000000000e+00))); %! assert (isequal (rdivide (infsup (0.000000000000000000e+00, 3.000000000000000000e+00), infsup (2.000000000000000000e+00, 3.000000000000000000e+00)), infsup (0.000000000000000000e+00, 1.500000000000000000e+00))); ## FI_LIB.unary_functions %!test %! assert (isequal (exp (infsup (-5.654676730021285758e+33, -2.467054147405823936e-70)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (exp (infsup (-1.339988487076310626e-66, -3.142176739251405931e-153)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (exp (infsup (-1.559745526584455293e+82, -8.494812002392629213e-61)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (exp (infsup (-1.215647583031333080e-125, -2.146363543986120533e-137)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!#exp [-0X6.FF424CB26239CP+292, -0X2.89F6682121BA8P+252] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; %!test %! assert (isequal (exp (infsup (-7.439842988767636755e+100, -1.769170660676674389e+00)), infsup (0.000000000000000000e+00, 1.704743112651300185e-01))); %!test %! assert (isequal (exp (infsup (-7.499234869798133827e+71, -1.740341118088671732e-132)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (exp (infsup (-2.932406654409041728e+52, -5.352481974657761661e-104)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (exp (infsup (-5.017847776764403958e-87, -2.227977792271395082e-227)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (exp (infsup (-1.827668734769395026e-22, -1.326175859067188756e-169)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!#exp [-0X1.582D3AFB2C63DP+312, -0X5.08DC843E57ED4P+180] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; %!test %! assert (isequal (exp (infsup (-5.423963041733560701e+77, -2.059305088062927775e-14)), infsup (0.000000000000000000e+00, 9.999999999999794609e-01))); %!test %! assert (isequal (exp (infsup (-3.360610542799653195e+197, -5.874775479904158146e+02)), infsup (0.000000000000000000e+00, 7.273486979199256744e-256))); %!#exp [-0X3.2FD3FDE325402P+688, -0X2.738623C238270P+48] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; %!test %! assert (isequal (exp (infsup (-3.249456070719769514e+02, -3.915939161035242553e-52)), infsup (7.549460722130907947e-142, 1.000000000000000000e+00))); %!test %! assert (isequal (exp (infsup (-6.756234292039407244e+297, -1.232680690145569154e-163)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (exp (infsup (-3.768432504481998329e-45, -1.425448715493971452e-132)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (exp (infsup (-6.868984884638793653e+105, -1.124545542537290068e-153)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!#exp [-0XD.F2552B8F60978P+236, -0X7.FBDBC320979A4P+188] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; %!test %! assert (isequal (exp (infsup (-4.825221040561267626e-72, -3.741418656433786262e-95)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (exp (infsup (1.000000000000000000e+00, 2.000000000000000000e+00)), infsup (2.718281828459045091e+00, 7.389056098930650407e+00))); %!test %! assert (isequal (exp (infsup (-1.000000000000000000e+00, 2.000000000000000000e+00)), infsup (3.678794411714422785e-01, 7.389056098930650407e+00))); %!test %! assert (isequal (exp (infsup (-5.000000000000000000e+00, -3.000000000000000000e+00)), infsup (6.737946999085467001e-03, 4.978706836786394446e-02))); %!test %! assert (isequal (exp (infsup (-2.000000000000000000e+00, 5.999999999999999778e-01)), infsup (1.353352832366126746e-01, 1.822118800390509108e+00))); %!test %! assert (isequal (exp (infsup (4.940656458412465442e-324, 5.526030376261632760e-318)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (exp (infsup (2.158572806680406152e-320, 1.000000000000000000e+00)), infsup (1.000000000000000000e+00, 2.718281828459045535e+00))); %!test %! assert (isequal (exp (infsup (-3.453765897253233967e-319, 3.453765897253233967e-319)), infsup (9.999999999999998890e-01, 1.000000000000000222e+00))); %!test %! assert (isequal (exp (infsup (-1.348799213146603066e-321, 1.999755859375000000e+00)), infsup (9.999999999999998890e-01, 7.387252350349609920e+00))); %!test %! assert (isequal (exp (infsup (-1.999984741210937500e+00, -1.768329819216851651e-316)), infsup (1.353373483049074844e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (exp (infsup (-1.999999996274709702e+00, 4.668945501635218808e-314)), infsup (1.353352837407758857e-01, 1.000000000000000222e+00))); %!test %! assert (isequal (pow2 (infsup (-5.654676730021285758e+33, -2.467054147405823936e-70)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (pow2 (infsup (-1.339988487076310626e-66, -3.142176739251405931e-153)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (pow2 (infsup (-1.559745526584455293e+82, -8.494812002392629213e-61)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (pow2 (infsup (-1.215647583031333080e-125, -2.146363543986120533e-137)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!#exp2 [-0X6.FF424CB26239CP+292, -0X2.89F6682121BA8P+252] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; %!test %! assert (isequal (pow2 (infsup (-7.439842988767636755e+100, -1.769170660676674389e+00)), infsup (0.000000000000000000e+00, 2.933773380418803201e-01))); %!test %! assert (isequal (pow2 (infsup (-7.499234869798133827e+71, -1.740341118088671732e-132)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (pow2 (infsup (-2.932406654409041728e+52, -5.352481974657761661e-104)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (pow2 (infsup (-5.017847776764403958e-87, -2.227977792271395082e-227)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (pow2 (infsup (-1.827668734769395026e-22, -1.326175859067188756e-169)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!#exp2 [-0X1.582D3AFB2C63DP+312, -0X5.08DC843E57ED4P+180] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; %!test %! assert (isequal (pow2 (infsup (-5.423963041733560701e+77, -2.059305088062927775e-14)), infsup (0.000000000000000000e+00, 9.999999999999857891e-01))); %!test %! assert (isequal (pow2 (infsup (-3.360610542799653195e+197, -5.874775479904158146e+02)), infsup (0.000000000000000000e+00, 1.417869550014210814e-177))); %!#exp2 [-0X3.2FD3FDE325402P+688, -0X2.738623C238270P+48] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; %!test %! assert (isequal (pow2 (infsup (-3.249456070719769514e+02, -3.915939161035242553e-52)), infsup (1.519236241890019241e-98, 1.000000000000000000e+00))); %!test %! assert (isequal (pow2 (infsup (-6.756234292039407244e+297, -1.232680690145569154e-163)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (pow2 (infsup (-3.768432504481998329e-45, -1.425448715493971452e-132)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (pow2 (infsup (-6.868984884638793653e+105, -1.124545542537290068e-153)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!#exp2 [-0XD.F2552B8F60978P+236, -0X7.FBDBC320979A4P+188] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; %!test %! assert (isequal (pow2 (infsup (-4.825221040561267626e-72, -3.741418656433786262e-95)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (pow2 (infsup (1.000000000000000000e+00, 2.000000000000000000e+00)), infsup (2.000000000000000000e+00, 4.000000000000000000e+00))); %!test %! assert (isequal (pow2 (infsup (-1.000000000000000000e+00, 2.000000000000000000e+00)), infsup (5.000000000000000000e-01, 4.000000000000000000e+00))); %!test %! assert (isequal (pow2 (infsup (-5.000000000000000000e+00, -3.000000000000000000e+00)), infsup (3.125000000000000000e-02, 1.250000000000000000e-01))); %!test %! assert (isequal (pow2 (infsup (-2.000000000000000000e+00, 5.999999999999999778e-01)), infsup (2.500000000000000000e-01, 1.515716566510398211e+00))); %!test %! assert (isequal (pow2 (infsup (1.348799213146603066e-321, 8.878353726979450304e-317)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (pow2 (infsup (-3.862967879279826753e-313, 1.508953107040180465e-315)), infsup (9.999999999999998890e-01, 1.000000000000000222e+00))); %!test %! assert (isequal (pow2 (infsup (6.914171912282031536e-314, 1.000000194699774969e+00)), infsup (1.000000000000000000e+00, 2.000000269911218709e+00))); %!test %! assert (isequal (pow2 (infsup (-1.110510763557203341e-312, 1.508971911178661183e-315)), infsup (9.999999999999998890e-01, 1.000000000000000222e+00))); %!test %! assert (isequal (pow2 (infsup (-1.508974781700063520e-315, 1.999999942630529270e+00)), infsup (9.999999999999998890e-01, 3.999999840938055939e+00))); %!test %! assert (isequal (pow2 (infsup (-1.999999999999999778e+00, 9.177083518333092811e-314)), infsup (2.500000000000000000e-01, 1.000000000000000222e+00))); %!test %! assert (isequal (pow10 (infsup (-1.306882282121512488e+34, -2.142051668986572426e-70)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (pow10 (infsup (-3.574174482995173238e-66, -4.502612523763230139e-153)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (pow10 (infsup (-1.977283881120209920e+82, -5.495270555084999106e-61)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (pow10 (infsup (-6.394132238750145602e-126, -1.090326174415294200e-137)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!#exp10 [-0X2.7C064F6929234P+292, -0X1.5444E676976F1P+252] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; %!test %! assert (isequal (pow10 (infsup (-4.308666602899711518e+100, -1.226586363793985335e+00)), infsup (0.000000000000000000e+00, 5.934903149808178069e-02))); %!test %! assert (isequal (pow10 (infsup (-7.949640211843924994e+71, -7.928935505948560140e-133)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (pow10 (infsup (-3.784447147395508652e+52, -3.876504952447015518e-104)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (pow10 (infsup (-2.524795598203051262e-87, -1.735629038886541013e-227)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (pow10 (infsup (-5.840571936196232559e-23, -1.237297234801419434e-169)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!#exp10 [-0X1.F0D19ADCB5D74P+312, -0X1.BA04D452BBB35P+180] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; %!test %! assert (isequal (pow10 (infsup (-3.330274496326268835e+77, -8.586668885039760719e-15)), infsup (0.000000000000000000e+00, 9.999999999999802380e-01))); %!test %! assert (isequal (pow10 (infsup (-2.654076110524515271e+197, -2.089478911258004246e+03)), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %!#exp10 [-0X2.A69A969772FDEP+688, -0X3.436DFE8F08194P+48] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; %!test %! assert (isequal (pow10 (infsup (-3.786643969857242382e+02, -1.042970653496689987e-51)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (pow10 (infsup (-6.699078654119896870e+297, -1.159254403776913034e-163)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (pow10 (infsup (-7.532163773886162862e-45, -9.621666972390800389e-133)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (pow10 (infsup (-1.485368733580681843e+106, -9.139956432627538486e-154)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!#exp10 [-0XD.5E2045CEE9720P+236, -0X6.6978492A3064CP+188] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; %!test %! assert (isequal (pow10 (infsup (-1.230428274874167409e-71, -5.894957732633465837e-95)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!#exp10 [-0XB.A944253373080P+564, -0XD.05E9CCF66CF58P+424] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; %!test %! assert (isequal (pow10 (infsup (-1.376904412228828177e+51, -8.878766165166293762e-17)), infsup (0.000000000000000000e+00, 9.999999999999998890e-01))); %!test %! assert (isequal (pow10 (infsup (-3.440680160407877302e-20, -1.442483959041155224e-103)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (pow10 (infsup (-7.528651283167650945e+03, -5.626945812397601245e-71)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (pow10 (infsup (-8.697059728957016802e+39, -6.144581905264969684e-145)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (pow10 (infsup (-2.952069202447659552e+66, -1.163046489009897174e-57)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (pow10 (infsup (-4.997184174270236677e-42, -7.340119470601840050e-203)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!#exp10 [-0XB.24D19E00C8460P+324, -0X1.D283CF8F05665P+252] = [0X0.0000000000000P+0, 0X0.0000000000000P+0]; %!test %! assert (isequal (pow10 (infsup (-1.845313858239065767e+196, -1.061757227068338186e-97)), infsup (0.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (pow10 (infsup (-4.488799649180782136e-36, -7.269525029365293208e-38)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (log (infsup (4.147420261371489825e-79, 5.379571027897612396e+28)), infsup (-1.804817358293410905e+02, 6.615499124023648392e+01))); %!test %! assert (isequal (log (infsup (1.110880646187224313e-155, 2.373351651082584966e-67)), infsup (-3.567955363383649683e+02, -1.534088980757222771e+02))); %!test %! assert (isequal (log (infsup (5.129079157666995424e-72, 1.751070362531829627e+71)), infsup (-1.641512005539303800e+02, 1.640437688392722464e+02))); %!test %! assert (isequal (log (infsup (6.948997631311531055e-148, 2.928301646694579776e-136)), infsup (-3.388439963396542112e+02, -3.120771500349853795e+02))); %!test %! assert (isequal (log (infsup (1.228976222624138207e+59, 2.234162998792154053e+68)), infsup (1.360587019701163172e+02, 1.573796529843343421e+02))); %!test %! assert (isequal (log (infsup (3.765881959744468747e-13, 4.282127607174989696e+83)), infsup (-2.860762412284734779e+01, 1.925690127090641397e+02))); %!test %! assert (isequal (log (infsup (6.336975772360046338e-144, 9.158993707856365702e+59)), infsup (-3.297258517440119476e+02, 1.380672568020790720e+02))); %!test %! assert (isequal (log (infsup (5.364761505213512494e-113, 4.082352475280499044e+42)), infsup (-2.585122635870604881e+02, 9.811524731508208674e+01))); %!test %! assert (isequal (log (infsup (7.550677903404239041e-232, 3.224750948704370352e-99)), infsup (-5.321781042268580677e+02, -2.267850684843527347e+02))); %!test %! assert (isequal (log (infsup (1.225297990074229138e-174, 4.817234909117431242e-40)), infsup (-4.004466221093460945e+02, -9.053120362661866238e+01))); %!test %! assert (isequal (log (infsup (2.170435512584716658e+35, 4.550722777302786970e+83)), infsup (8.136540609925064871e+01, 1.926298487910074471e+02))); %!test %! assert (isequal (log (infsup (2.535659632151250680e-30, 4.662866785261630365e+61)), infsup (-6.814709897670536520e+01, 1.419973211215928757e+02))); %!test %! assert (isequal (log (infsup (7.582817216007211414e+01, 2.533325420226928244e+179)), infsup (4.328469887979126796e+00, 4.130922644809588746e+02))); %!test %! assert (isequal (log (infsup (2.679384856388388202e+06, 3.456099944072672956e+189)), infsup (1.480109779494235944e+01, 4.364287233454008401e+02))); %!test %! assert (isequal (log (infsup (2.298466163925377139e-53, 3.422642591789022920e-07)), infsup (-1.212047679134660427e+02, -1.488768271059561599e+01))); %!test %! assert (isequal (log (infsup (8.331537116545182766e-169, 1.276575089856515728e+278)), infsup (-3.870168327490416118e+02, 6.403628366331134885e+02))); %!test %! assert (isequal (log (infsup (3.718156390017819207e-141, 1.084633607212178861e-48)), infsup (-3.233512701608040061e+02, -1.104428422229569691e+02))); %!test %! assert (isequal (log (infsup (3.157294329035461405e-160, 9.898300388558577825e+97)), infsup (-3.672638994432072650e+02, 2.256431170849012631e+02))); %!test %! assert (isequal (log (infsup (1.083356361649631714e+44, 3.415036575780023082e+59)), infsup (1.013938080560929649e+02, 1.370807086899449985e+02))); %!test %! assert (isequal (log (infsup (8.455584990678977241e-99, 6.051563441903092353e-73)), infsup (-2.258210970377273554e+02, -1.662883951297580438e+02))); %!test %! assert (isequal (log (infsup (2.360349141715971707e+109, 8.567792987486366378e+158)), infsup (2.518405846858512973e+02, 3.659564548647884408e+02))); %!test %! assert (isequal (log (infsup (2.012916824299288793e-32, 2.822293342336804668e+41)), infsup (-7.298313814928054910e+01, 9.544353860916723420e+01))); %!test %! assert (isequal (log (infsup (4.831139778854605785e-107, 2.083134309679031648e-23)), infsup (-2.448015225314781844e+02, -5.222558349970032054e+01))); %!test %! assert (isequal (log (infsup (8.466268199564697371e-76, 1.680782691923963737e-10)), infsup (-1.728603772463421535e+02, -2.250659135696745139e+01))); %!test %! assert (isequal (log (infsup (2.283702426861795342e-151, 2.158830003381976904e+22)), infsup (-3.468645510447575475e+02, 5.142643845571060979e+01))); %!test %! assert (isequal (log (infsup (1.114428406645123204e-64, 1.137441975089809242e+58)), infsup (-1.472571043179317201e+02, 1.336787172532864645e+02))); %!test %! assert (isequal (log (infsup (1.463767593806767211e-207, 3.684178239990781413e-44)), infsup (-4.762541005942298398e+02, -1.000096965923245591e+02))); %!test %! assert (isequal (log (infsup (1.806590984564742948e+58, 4.476357965164357790e+78)), infsup (1.341413770290983223e+02, 1.811004470151316070e+02))); %!test %! assert (isequal (log (infsup (2.504949335867761681e-102, 4.444462712533866271e+177)), infsup (-2.339454109762628775e+02, 4.090492204470355091e+02))); %!test %! assert (isequal (log (infsup (1.027829701532525701e-53, 1.755408547816880709e-45)), infsup (-1.220095604353624026e+02, -1.030536275641269413e+02))); %!test %! assert (isequal (log2 (infsup (4.147420261371489825e-79, 5.379571027897612396e+28)), infsup (-2.603801052520223038e+02, 9.544147779234198481e+01))); %!test %! assert (isequal (log2 (infsup (1.110880646187224313e-155, 2.373351651082584966e-67)), infsup (-5.147471508866771046e+02, -2.213222564820849811e+02))); %!test %! assert (isequal (log2 (infsup (5.129079157666995424e-72, 1.751070362531829627e+71)), infsup (-2.368201229951249900e+02, 2.366651317931535345e+02))); %!test %! assert (isequal (log2 (infsup (6.948997631311531055e-148, 2.928301646694579776e-136)), infsup (-4.888485531542171429e+02, -4.502321567302344079e+02))); %!test %! assert (isequal (log2 (infsup (1.228976222624138207e+59, 2.234162998792154053e+68)), infsup (1.962912146020762520e+02, 2.270508448973251063e+02))); %!test %! assert (isequal (log2 (infsup (3.765881959744468747e-13, 4.282127607174989696e+83)), infsup (-4.127207745364734848e+01, 2.778183596642506359e+02))); %!test %! assert (isequal (log2 (infsup (6.336975772360046338e-144, 9.158993707856365702e+59)), infsup (-4.756938511639755802e+02, 1.991889466975024732e+02))); %!test %! assert (isequal (log2 (infsup (5.364761505213512494e-113, 4.082352475280499044e+42)), infsup (-3.729543606860327145e+02, 1.415503807370631080e+02))); %!test %! assert (isequal (log2 (infsup (7.550677903404239041e-232, 3.224750948704370352e-99)), infsup (-7.677707118377780944e+02, -3.271816936500396196e+02))); %!test %! assert (isequal (log2 (infsup (1.225297990074229138e-174, 4.817234909117431242e-40)), infsup (-5.777223558578903067e+02, -1.306089185178316825e+02))); %!test %! assert (isequal (log2 (infsup (2.170435512584716658e+35, 4.550722777302786970e+83)), infsup (1.173854678793055371e+02, 2.779061275779773723e+02))); %!test %! assert (isequal (log2 (infsup (2.535659632151250680e-30, 4.662866785261630365e+61)), infsup (-9.831548174466217915e+01, 2.048588310016397145e+02))); %!test %! assert (isequal (log2 (infsup (7.582817216007211414e+01, 2.533325420226928244e+179)), infsup (6.244662042024692994e+00, 5.959661613962714455e+02))); %!test %! assert (isequal (log2 (infsup (2.679384856388388202e+06, 3.456099944072672956e+189)), infsup (2.135347038847591250e+01, 6.296335548719112012e+02))); %!test %! assert (isequal (log2 (infsup (2.298466163925377139e-53, 3.422642591789022920e-07)), infsup (-1.748615176008552226e+02, -2.147838601690465765e+01))); %!test %! assert (isequal (log2 (infsup (8.331537116545182766e-169, 1.276575089856515728e+278)), infsup (-5.583472653475956804e+02, 9.238482887801823153e+02))); %!test %! assert (isequal (log2 (infsup (3.718156390017819207e-141, 1.084633607212178861e-48)), infsup (-4.664972739261393144e+02, -1.593353407767422425e+02))); %!test %! assert (isequal (log2 (infsup (3.157294329035461405e-160, 9.898300388558577825e+97)), infsup (-5.298498064242580767e+02, 3.255342060291147845e+02))); %!test %! assert (isequal (log2 (infsup (1.083356361649631714e+44, 3.415036575780023082e+59)), infsup (1.462803440593727373e+02, 1.977656586285282856e+02))); %!test %! assert (isequal (log2 (infsup (8.455584990678977241e-99, 6.051563441903092353e-73)), infsup (-3.257909768244346083e+02, -2.399034430110863809e+02))); %!test %! assert (isequal (log2 (infsup (2.360349141715971707e+109, 8.567792987486366378e+158)), infsup (3.633291626208546745e+02, 5.279635626147360199e+02))); %!test %! assert (isequal (log2 (infsup (2.012916824299288793e-32, 2.822293342336804668e+41)), infsup (-1.052924114764811634e+02, 1.376959198363398968e+02))); %!test %! assert (isequal (log2 (infsup (4.831139778854605785e-107, 2.083134309679031648e-23)), infsup (-3.531739425582314311e+02, -7.534559032255012312e+01))); %!test %! assert (isequal (log2 (infsup (8.466268199564697371e-76, 1.680782691923963737e-10)), infsup (-2.493848090194932183e+02, -3.247014773801134879e+01))); %!test %! assert (isequal (log2 (infsup (2.283702426861795342e-151, 2.158830003381976904e+22)), infsup (-5.004197676524483995e+02, 7.419266773063517917e+01))); %!test %! assert (isequal (log2 (infsup (1.114428406645123204e-64, 1.137441975089809242e+58)), infsup (-2.124470941351488307e+02, 1.928576224537142991e+02))); %!test %! assert (isequal (log2 (infsup (1.463767593806767211e-207, 3.684178239990781413e-44)), infsup (-6.870894291303288810e+02, -1.442834933145564946e+02))); %!test %! assert (isequal (log2 (infsup (1.806590984564742948e+58, 4.476357965164357790e+78)), infsup (1.935250994178968824e+02, 2.612727168115048926e+02))); %!test %! assert (isequal (log2 (infsup (2.504949335867761681e-102, 4.444462712533866271e+177)), infsup (-3.375118842541849062e+02, 5.901332818184345115e+02))); %!test %! assert (isequal (log2 (infsup (1.027829701532525701e-53, 1.755408547816880709e-45)), infsup (-1.760225877811396060e+02, -1.486749574323841045e+02))); %!test %! assert (isequal (log10 (infsup (4.147420261371489825e-79, 5.379571027897612396e+28)), infsup (-7.838222195500324574e+01, 2.873074764599266473e+01))); %!test %! assert (isequal (log10 (infsup (1.110880646187224313e-155, 2.373351651082584966e-67)), infsup (-1.549543325994630720e+02, -6.662463790914456752e+01))); %!test %! assert (isequal (log10 (infsup (5.129079157666995424e-72, 1.751070362531829627e+71)), infsup (-7.128996059836597965e+01, 7.124330359750855735e+01))); %!test %! assert (isequal (log10 (infsup (6.948997631311531055e-148, 2.928301646694579776e-136)), infsup (-1.471580778363574780e+02, -1.355333841882873571e+02))); %!test %! assert (isequal (log10 (infsup (1.228976222624138207e+59, 2.234162998792154053e+68)), infsup (5.908954348054061967e+01, 6.834911485494504291e+01))); %!test %! assert (isequal (log10 (infsup (3.765881959744468747e-13, 4.282127607174989696e+83)), infsup (-1.242413329691495782e+01, 8.363165960510373509e+01))); %!test %! assert (isequal (log10 (infsup (6.336975772360046338e-144, 9.158993707856365702e+59)), infsup (-1.431981179532740782e+02, 5.996184776066215250e+01))); %!test %! assert (isequal (log10 (infsup (5.364761505213512494e-113, 4.082352475280499044e+42)), infsup (-1.122704495801793030e+02, 4.261091049951299681e+01))); %!test %! assert (isequal (log10 (infsup (7.550677903404239041e-232, 3.224750948704370352e-99)), infsup (-2.311220140554580951e+02, -9.849150382080546251e+01))); %!test %! assert (isequal (log10 (infsup (1.225297990074229138e-174, 4.817234909117431242e-40)), infsup (-1.739117582788857135e+02, -3.931720217510014947e+01))); %!test %! assert (isequal (log10 (infsup (2.170435512584716658e+35, 4.550722777302786970e+83)), infsup (3.533654688672174871e+01, 8.365808037979232381e+01))); %!test %! assert (isequal (log10 (infsup (2.535659632151250680e-30, 4.662866785261630365e+61)), infsup (-2.959590904329787620e+01, 6.166865300815185691e+01))); %!test %! assert (isequal (log10 (infsup (7.582817216007211414e+01, 2.533325420226928244e+179)), infsup (1.879830587433721334e+00, 1.794036909809991016e+02))); %!test %! assert (isequal (log10 (infsup (2.679384856388388202e+06, 3.456099944072672956e+189)), infsup (6.428035098453854346e+00, 1.895385862929884695e+02))); %!test %! assert (isequal (log10 (infsup (2.298466163925377139e-53, 3.422642591789022920e-07)), infsup (-5.263856188518261803e+01, -6.465638449538123389e+00))); %!test %! assert (isequal (log10 (infsup (8.331537116545182766e-169, 1.276575089856515728e+278)), infsup (-1.680792748665824945e+02, 2.781060463656747288e+02))); %!test %! assert (isequal (log10 (infsup (3.718156390017819207e-141, 1.084633607212178861e-48)), infsup (-1.404296723472447752e+02, -4.796471694314168133e+01))); %!test %! assert (isequal (log10 (infsup (3.157294329035461405e-160, 9.898300388558577825e+97)), infsup (-1.595006849304556908e+02, 9.799556062942198764e+01))); %!test %! assert (isequal (log10 (infsup (1.083356361649631714e+44, 3.415036575780023082e+59)), infsup (4.403477133791865583e+01, 5.953339535943025851e+01))); %!test %! assert (isequal (log10 (infsup (8.455584990678977241e-99, 6.051563441903092353e-73)), infsup (-9.807285634082376191e+01, -7.221813240940149115e+01))); %!test %! assert (isequal (log10 (infsup (2.360349141715971707e+109, 8.567792987486366378e+158)), infsup (1.093729762483538082e+02, 1.589328689646540624e+02))); %!test %! assert (isequal (log10 (infsup (2.012916824299288793e-32, 2.822293342336804668e+41)), infsup (-3.169617417021524730e+01, 4.145060215128129499e+01))); %!test %! assert (isequal (log10 (infsup (4.831139778854605785e-107, 2.083134309679031648e-23)), infsup (-1.063159503969355484e+02, -2.268128272809736856e+01))); %!test %! assert (isequal (log10 (infsup (8.466268199564697371e-76, 1.680782691923963737e-10)), infsup (-7.507230797780081843e+01, -9.774488432782383995e+00))); %!test %! assert (isequal (log10 (infsup (2.283702426861795342e-151, 2.158830003381976904e+22)), infsup (-1.506413604865870184e+02, 2.233421844525230426e+01))); %!test %! assert (isequal (log10 (infsup (1.114428406645123204e-64, 1.137441975089809242e+58)), infsup (-6.395294782632925745e+01, 5.805592925100733481e+01))); %!test %! assert (isequal (log10 (infsup (1.463767593806767211e-207, 3.684178239990781413e-44)), infsup (-2.068345278718702218e+02, -4.343365936686500106e+01))); %!test %! assert (isequal (log10 (infsup (1.806590984564742948e+58, 4.476357965164357790e+78)), infsup (5.825685983864102724e+01, 7.865092480888390014e+01))); %!test %! assert (isequal (log10 (infsup (2.504949335867761681e-102, 4.444462712533866271e+177)), infsup (-1.016012010535794019e+02, 1.776478192669743237e+02))); %!test %! assert (isequal (log10 (infsup (1.027829701532525701e-53, 1.755408547816880709e-45)), infsup (-5.298807883651920747e+01, -4.475562179121317996e+01))); %!test %! assert (isequal (sin (infsup (-1.820250631842705497e-45, -9.117403206523163851e-284)), infsup (-1.820250631842705497e-45, -9.117403206523162656e-284))); %!test %! assert (isequal (sin (infsup (-9.132843019095516065e-132, -9.836586939929288236e-188)), infsup (-9.132843019095516065e-132, -9.836586939929286960e-188))); %!test %! assert (isequal (sin (infsup (-8.631384205445317548e+01, -2.269091389186822222e-289)), infsup (-1.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (sin (infsup (-1.654017949299359065e-112, 1.159376035639006975e-176)), infsup (-1.654017949299359065e-112, 1.159376035639006975e-176))); %!test %! assert (isequal (sin (infsup (-2.261578927830210317e-107, -2.921845682025291002e-170)), infsup (-2.261578927830210317e-107, -2.921845682025290634e-170))); %!test %! assert (isequal (sin (infsup (-1.469458391712281360e-99, -1.976254011990074054e-124)), infsup (-1.469458391712281360e-99, -1.976254011990073634e-124))); %!test %! assert (isequal (sin (infsup (-1.088588131986426258e-12, -3.239993862505298994e-238)), infsup (-1.088588131986426258e-12, -3.239993862505298312e-238))); %!test %! assert (isequal (sin (infsup (-3.114600191344484305e-60, -1.151057432815240852e-61)), infsup (-3.114600191344484305e-60, -1.151057432815240680e-61))); %!test %! assert (isequal (sin (infsup (3.215755734598088570e-80, 2.860247434645490115e-24)), infsup (3.215755734598088196e-80, 2.860247434645490115e-24))); %!test %! assert (isequal (sin (infsup (-7.599545156767026148e-113, -3.620806299549831939e-276)), infsup (-7.599545156767026148e-113, -3.620806299549831137e-276))); %!test %! assert (isequal (sin (infsup (-8.378054792460110690e-178, 2.171929406448802147e-04)), infsup (-8.378054792460110690e-178, 2.171929389372813358e-04))); %!test %! assert (isequal (sin (infsup (-6.977305240208117095e-101, -5.652987073406890307e-174)), infsup (-6.977305240208117095e-101, -5.652987073406889409e-174))); %!test %! assert (isequal (sin (infsup (-5.464129729164141708e-282, 9.669182275976748412e-117)), infsup (-5.464129729164141708e-282, 9.669182275976748412e-117))); %!test %! assert (isequal (sin (infsup (-2.609094333453398954e-148, 5.011306988287881225e-06)), infsup (-2.609094333453398954e-148, 5.011306988266906995e-06))); %!test %! assert (isequal (sin (infsup (-2.520164184091732485e-91, -6.923225182185906259e-252)), infsup (-2.520164184091732485e-91, -6.923225182185905290e-252))); %!test %! assert (isequal (sin (infsup (-2.058411222963202619e-150, -1.691080271454051769e-229)), infsup (-2.058411222963202619e-150, -1.691080271454051403e-229))); %!test %! assert (isequal (sin (infsup (-1.194912260770650641e-171, -3.063641562993914407e-235)), infsup (-1.194912260770650641e-171, -3.063641562993914058e-235))); %!test %! assert (isequal (sin (infsup (-1.410213021759318257e-164, 2.113307206456483530e-235)), infsup (-1.410213021759318257e-164, 2.113307206456483530e-235))); %!test %! assert (isequal (sin (infsup (-2.734402476279937437e-15, 2.214286456252711975e-200)), infsup (-2.734402476279937437e-15, 2.214286456252711975e-200))); %!test %! assert (isequal (sin (infsup (-4.736813689297963792e-37, -3.757820326147841254e-165)), infsup (-4.736813689297963792e-37, -3.757820326147840772e-165))); %!test %! assert (isequal (sin (infsup (-1.178872317111653867e-269, -3.697079530478824433e-304)), infsup (-1.178872317111653867e-269, -3.697079530478823624e-304))); %!test %! assert (isequal (sin (infsup (-3.170977600535302060e-50, 1.773732353250808790e-223)), infsup (-3.170977600535302060e-50, 1.773732353250808790e-223))); %!test %! assert (isequal (sin (infsup (-9.582715182984806788e-234, -6.481946913158783102e-280)), infsup (-9.582715182984806788e-234, -6.481946913158782124e-280))); %!test %! assert (isequal (sin (infsup (1.510030059283921314e-212, 1.357381528725581723e-08)), infsup (1.510030059283921050e-212, 1.357381528725581723e-08))); %!test %! assert (isequal (sin (infsup (-1.323507196051687166e-113, 8.782017701712098963e-233)), infsup (-1.323507196051687166e-113, 8.782017701712098963e-233))); %!test %! assert (isequal (sin (infsup (-7.715995104235895070e-26, -1.871718785128404206e-162)), infsup (-7.715995104235895070e-26, -1.871718785128403959e-162))); %!test %! assert (isequal (sin (infsup (-3.395185885371617857e-83, -1.892322506995032646e-149)), infsup (-3.395185885371617857e-83, -1.892322506995032429e-149))); %!test %! assert (isequal (sin (infsup (-1.449285613317172764e-98, -5.707789272110613126e-264)), infsup (-1.449285613317172764e-98, -5.707789272110612244e-264))); %!test %! assert (isequal (sin (infsup (-1.045711771041448932e-76, 2.500374714085601101e-183)), infsup (-1.045711771041448932e-76, 2.500374714085601101e-183))); %!test %! assert (isequal (sin (infsup (-1.069106323474023944e-70, -1.300019611184126890e-129)), infsup (-1.069106323474023944e-70, -1.300019611184126730e-129))); %!test %! assert (isequal (cos (infsup (-1.820250631842705497e-45, -9.117403206523163851e-284)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-9.132843019095516065e-132, -9.836586939929288236e-188)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-8.631384205445317548e+01, -2.269091389186822222e-289)), infsup (-1.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-1.654017949299359065e-112, 1.159376035639006975e-176)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-2.261578927830210317e-107, -2.921845682025291002e-170)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-1.469458391712281360e-99, -1.976254011990074054e-124)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-1.088588131986426258e-12, -3.239993862505298994e-238)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-3.114600191344484305e-60, -1.151057432815240852e-61)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (3.215755734598088570e-80, 2.860247434645490115e-24)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-7.599545156767026148e-113, -3.620806299549831939e-276)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-8.378054792460110690e-178, 2.171929406448802147e-04)), infsup (9.999999764136132674e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-6.977305240208117095e-101, -5.652987073406890307e-174)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-5.464129729164141708e-282, 9.669182275976748412e-117)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-2.609094333453398954e-148, 5.011306988287881225e-06)), infsup (9.999999999874433776e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-2.520164184091732485e-91, -6.923225182185906259e-252)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-2.058411222963202619e-150, -1.691080271454051769e-229)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-1.194912260770650641e-171, -3.063641562993914407e-235)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-1.410213021759318257e-164, 2.113307206456483530e-235)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-2.734402476279937437e-15, 2.214286456252711975e-200)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-4.736813689297963792e-37, -3.757820326147841254e-165)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-1.178872317111653867e-269, -3.697079530478824433e-304)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-3.170977600535302060e-50, 1.773732353250808790e-223)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-9.582715182984806788e-234, -6.481946913158783102e-280)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (1.510030059283921314e-212, 1.357381528725581723e-08)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-1.323507196051687166e-113, 8.782017701712098963e-233)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-7.715995104235895070e-26, -1.871718785128404206e-162)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-3.395185885371617857e-83, -1.892322506995032646e-149)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-1.449285613317172764e-98, -5.707789272110613126e-264)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-1.045711771041448932e-76, 2.500374714085601101e-183)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (cos (infsup (-1.069106323474023944e-70, -1.300019611184126890e-129)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (tan (infsup (7.068583836474448390e+01, 7.075330512586873510e+01)), infsup (-2.733006473448547767e+05, -1.479881285214991671e+01))); %!test %! assert (isequal (tan (infsup (1.555088363530945514e+02, 1.555132637869551502e+02)), infsup (-2.501337356624831200e+09, -2.258629732531564116e+02))); %!test %! assert (isequal (tan (infsup (1.413716780550254626e+01, 1.413722739196949441e+01)), infsup (-1.156940779064804548e+06, -1.654237402347945317e+04))); %!test %! assert (isequal (tan (infsup (5.811952623508042848e+01, 5.812260122540014606e+01)), infsup (-1.609174370815468137e+04, -3.187612397101500505e+02))); %!test %! assert (isequal (tan (infsup (1.104269817737113499e+03, 1.104269843933251650e+03)), infsup (-3.320322546736923695e+09, -3.817312678644171683e+04))); %!test %! assert (isequal (tan (infsup (7.853981742281575862e+00, 1.079991165038144985e+01)), infsup (-9.233005655163565651e+06, 5.045449840129903940e+00))); %!test %! assert (isequal (tan (infsup (5.239391148189279193e+04, 5.239399492445894430e+04)), infsup (-6.064225515766228782e+05, -1.195622657457963633e+01))); %!test %! assert (isequal (tan (infsup (7.586946266951879352e+02, 7.586949897443035979e+02)), infsup (-1.171985512609519530e+06, -2.747989687166772001e+03))); %!test %! assert (isequal (tan (infsup (3.011216624054200111e+03, 3.011217034712601162e+03)), infsup (-1.524660234605764526e+04, -2.099751551658140215e+03))); %!test %! assert (isequal (tan (infsup (4.712389001448225478e+00, 4.712393345839713810e+00)), infsup (-4.747541049162796140e+07, -2.290711952149188728e+05))); %!test %! assert (isequal (tan (infsup (9.660397409977252892e+02, 9.660408736798588052e+02)), infsup (-5.301139629714514315e+07, -8.828451415145300416e+02))); %!test %! assert (isequal (tan (infsup (7.853981635987763887e+00, 7.854153626675180355e+00)), infsup (-4.967017041818811297e+08, -5.814200172946292696e+03))); %!test %! assert (isequal (tan (infsup (5.811946410445683142e+01, 5.821150187298621859e+01)), infsup (-7.665386554086588323e+07, -1.083440665308985906e+01))); %!test %! assert (isequal (tan (infsup (7.853981655490968272e+00, 8.893108173179410159e+00)), infsup (-4.647599232951004803e+07, -5.881622348891323293e-01))); %!test %! assert (isequal (tan (infsup (1.352469666641228059e+03, 1.352470270671131857e+03)), infsup (-7.127486560119896808e+01, -6.833240428001097655e+01))); %!test %! assert (isequal (tan (infsup (2.670354408912840682e+01, 2.672430666491903750e+01)), infsup (-1.530546221103163844e+05, -4.814150626430674151e+01))); %!test %! assert (isequal (tan (infsup (1.003220490034101676e+05, 1.003220547796015017e+05)), infsup (-1.979169548332780600e+09, -1.731225184926742315e+02))); %!test %! assert (isequal (tan (infsup (1.545333850137601839e+05, 1.545336486881895107e+05)), infsup (-7.586811168897187940e+01, -3.519246594516249438e+00))); %!test %! assert (isequal (tan (infsup (4.256858100226353940e+02, 4.256861391324387682e+02)), infsup (-1.831093219268073444e+05, -2.988901899973172021e+03))); %!test %! assert (isequal (tan (infsup (1.892809573788563739e+03, 1.892817290399498461e+03)), infsup (-1.401909320127509832e+09, -1.295879845757753230e+02))); %!test %! assert (isequal (tan (infsup (2.673196896903307643e+05, 2.673216347431440372e+05)), infsup (-2.063441696743329614e+07, 3.927681680442902667e-01))); %!test %! assert (isequal (tan (infsup (3.926990817370413822e+01, 3.926991071421139168e+01)), infsup (-2.609792168562986851e+08, -3.930293916624513222e+05))); %!test %! assert (isequal (tan (infsup (2.984513044884169730e+01, 2.984607373920065143e+01)), infsup (-4.171208738684172742e+06, -1.059849289150749428e+03))); %!test %! assert (isequal (tan (infsup (2.670353946608568307e+01, 2.736226360891474840e+01)), infsup (-5.234033417295927648e+05, -1.291880114820135095e+00))); %!test %! assert (isequal (tan (infsup (4.500331685768444004e+03, 4.500332498243393275e+03)), infsup (-4.773245350635401337e+03, -9.784962051021077514e+02))); %!test %! assert (isequal (tan (infsup (1.220508745920102228e+03, 1.220511210335735768e+03)), infsup (-2.138784586246906519e+09, -4.057748101491103512e+02))); %!test %! assert (isequal (tan (infsup (2.984514872583801903e+01, 2.984530664322180371e+01)), infsup (-5.400520128356148052e+04, -5.667837925038271351e+03))); %!test %! assert (isequal (tan (infsup (1.944567312807089183e+05, 1.944582117162205104e+05)), infsup (-1.947536722055554565e+05, -9.060237858764001728e-02))); %!test %! assert (isequal (tan (infsup (2.356194490664901053e+01, 2.356194490664901053e+01)), infsup (-2.116150755620213449e+08, -2.116150755620213151e+08))); %!test %! assert (isequal (tan (infsup (2.356194490664901053e+01, 2.357580376726279070e+01)), infsup (-2.116150755620213449e+08, -7.215135957959719804e+01))); %!test %! assert (isequal (cot (infsup (6.911504203794957846e+01, 6.918250879907382966e+01)), infsup (1.479881285215185649e+01, 2.733006480036904104e+05))); %!test %! assert (isequal (cot (infsup (1.539380400262996602e+02, 1.539424674601602590e+02)), infsup (2.258629732528814316e+02, 2.501303631633254051e+09))); %!test %! assert (isequal (cot (infsup (1.256637147870764970e+01, 1.256643106517459785e+01)), infsup (1.654237402346269664e+04, 1.156940778982844437e+06))); %!test %! assert (isequal (cot (infsup (5.654872990828553725e+01, 5.655180489860525483e+01)), infsup (3.187612397096023642e+02, 1.609174370675889440e+04))); %!test %! assert (isequal (cot (infsup (1.102699021410318664e+03, 1.102699047606456816e+03)), infsup (3.817312669575550535e+04, 3.319636590212901592e+09))); %!test %! assert (isequal (cot (infsup (6.283185415486680192e+00, 9.229115323586553288e+00)), infsup (-5.045449840129905716e+00, 9.233005574227824807e+06))); %!test %! assert (isequal (cot (infsup (5.239234068556599232e+04, 5.239242412813214469e+04)), infsup (1.195622657525802346e+01, 6.064242846372171771e+05))); %!test %! assert (isequal (cot (infsup (7.571238303683931008e+02, 7.571241934175087636e+02)), infsup (2.747989686696816989e+03, 1.171985427128394833e+06))); %!test %! assert (isequal (cot (infsup (3.009645827727405049e+03, 3.009646238385806100e+03)), infsup (2.099751552386235289e+03, 1.524660238444589413e+04))); %!test %! assert (isequal (cot (infsup (3.141592674653329809e+00, 3.141597019044817252e+00)), infsup (2.290711952117057808e+05, 4.747540835173728317e+07))); %!test %! assert (isequal (cot (infsup (9.644689446709303411e+02, 9.644700773530638571e+02)), infsup (8.828451415546335284e+02, 5.301154089150482416e+07))); %!test %! assert (isequal (cot (infsup (6.283185309192868218e+00, 6.283357299880284685e+00)), infsup (5.814200172914197537e+03, 4.967014699504108429e+08))); %!test %! assert (isequal (cot (infsup (5.654866777766194019e+01, 5.664070554619132736e+01)), infsup (1.083440665308922135e+01, 7.665383386845602095e+07))); %!test %! assert (isequal (cot (infsup (6.283185328696072602e+00, 7.322311846384514489e+00)), infsup (5.881622348891311081e-01, 4.647599027876593918e+07))); %!test %! assert (isequal (cot (infsup (1.350898870314433225e+03, 1.350899474344337023e+03)), infsup (6.833240427972033615e+01, 7.127486560088274814e+01))); %!test %! assert (isequal (cot (infsup (2.513274776233351204e+01, 2.515351033812414272e+01)), infsup (4.814150626430247826e+01, 1.530546220672695199e+05))); %!test %! assert (isequal (cot (infsup (1.003204782070833753e+05, 1.003204839832747093e+05)), infsup (1.731225184158446382e+02, 1.969179325263058186e+09))); %!test %! assert (isequal (cot (infsup (1.545318142174333916e+05, 1.545320778918627184e+05)), infsup (3.519246594481938661e+00, 7.586811167421478785e+01))); %!test %! assert (isequal (cot (infsup (4.241150136958405028e+02, 4.241153428056438770e+02)), infsup (2.988901899925017460e+03, 1.831093217460757296e+05))); %!test %! assert (isequal (cot (infsup (1.891238777461768905e+03, 1.891246494072703626e+03)), infsup (1.295879845747301715e+02, 1.401787019768815756e+09))); %!test %! assert (isequal (cot (infsup (2.673181188940039719e+05, 2.673200639468172449e+05)), infsup (-3.927681680472490666e-01, 2.063332560662991926e+07))); %!test %! assert (isequal (cot (infsup (3.769911184690924699e+01, 3.769911438741650045e+01)), infsup (3.930293908297998714e+05, 2.609788497224701643e+08))); %!test %! assert (isequal (cot (infsup (2.827433412204680252e+01, 2.827527741240575665e+01)), infsup (1.059849289148685102e+03, 4.171208706711991224e+06))); %!test %! assert (isequal (cot (infsup (2.513274313929078829e+01, 2.579146728211985362e+01)), infsup (1.291880114820130210e+00, 5.234033412261832273e+05))); %!test %! assert (isequal (cot (infsup (4.498760889441648942e+03, 4.498761701916598213e+03)), infsup (9.784962052602219273e+02, 4.773245354397929077e+03))); %!test %! assert (isequal (cot (infsup (1.218937949593307394e+03, 1.218940414008940934e+03)), infsup (4.057748101388633017e+02, 2.138499942228402615e+09))); %!test %! assert (isequal (cot (infsup (2.827435239904312425e+01, 2.827451031642690893e+01)), infsup (5.667837924979239688e+03, 5.400520127820203925e+04))); %!test %! assert (isequal (cot (infsup (1.944551604843821260e+05, 1.944566409198937181e+05)), infsup (9.060237858505562625e-02, 1.947535749805420055e+05))); %!test %! assert (isequal (cot (infsup (8.230986922511164039e+02, 8.231133959538416320e+02)), infsup (6.202662085179850493e+01, 7.057105552665587993e+02))); %!test %! assert (isequal (cot (infsup (2.199114857985411220e+01, 2.200500744046789237e+01)), infsup (7.215135957960613666e+01, 2.116151523669368625e+08))); %!test %! assert (isequal (asin (infsup (-1.312389047028587488e-49, -2.435356662074063942e-204)), infsup (-1.312389047028587678e-49, -2.435356662074063942e-204))); %!test %! assert (isequal (asin (infsup (-2.826769732140076133e-84, -5.561386920473982459e-193)), infsup (-2.826769732140076591e-84, -5.561386920473982459e-193))); %!test %! assert (isequal (asin (infsup (-1.165983769138532228e-88, -1.428974577546032222e-230)), infsup (-1.165983769138532367e-88, -1.428974577546032222e-230))); %!test %! assert (isequal (asin (infsup (-9.442195953730013721e-285, -2.740460328962132443e-294)), infsup (-9.442195953730015214e-285, -2.740460328962132443e-294))); %!test %! assert (isequal (asin (infsup (2.046759423140378801e-219, 9.256656556116300803e-185)), infsup (2.046759423140378801e-219, 9.256656556116302109e-185))); %!test %! assert (isequal (asin (infsup (-3.808509373683396527e-193, 7.757841386304002834e-162)), infsup (-3.808509373683397013e-193, 7.757841386304003821e-162))); %!test %! assert (isequal (asin (infsup (-1.187397361107265637e-112, -2.668312821848315349e-303)), infsup (-1.187397361107265868e-112, -2.668312821848315349e-303))); %!test %! assert (isequal (asin (infsup (-1.263586867414290315e-101, -2.961257846195185529e-240)), infsup (-1.263586867414290474e-101, -2.961257846195185529e-240))); %!test %! assert (isequal (asin (infsup (-3.901714394731276617e-270, -3.330134658353580222e-294)), infsup (-3.901714394731277458e-270, -3.330134658353580222e-294))); %!test %! assert (isequal (asin (infsup (-2.366650777764918445e-246, 1.071483042175132919e-285)), infsup (-2.366650777764918953e-246, 1.071483042175133106e-285))); %!test %! assert (isequal (asin (infsup (-4.636590066075016366e-69, 5.524052139366596165e-240)), infsup (-4.636590066075017395e-69, 5.524052139366597231e-240))); %!test %! assert (isequal (asin (infsup (1.178822725995249352e-253, 3.080763910515160059e-167)), infsup (1.178822725995249352e-253, 3.080763910515160435e-167))); %!test %! assert (isequal (asin (infsup (-1.102346734829299702e-19, 6.850446591467340374e-81)), infsup (-1.102346734829299943e-19, 6.850446591467341310e-81))); %!test %! assert (isequal (asin (infsup (-3.809307924483539467e-117, 2.162545233549648523e-70)), infsup (-3.809307924483540172e-117, 2.162545233549648845e-70))); %!test %! assert (isequal (asin (infsup (-3.325515536019971910e-77, -2.504008447335657004e-137)), infsup (-3.325515536019972294e-77, -2.504008447335657004e-137))); %!test %! assert (isequal (asin (infsup (-1.559805661433223275e-242, 7.909368633706727513e-07)), infsup (-1.559805661433223483e-242, 7.909368633707552311e-07))); %!test %! assert (isequal (asin (infsup (-5.969914231928147727e-104, -6.050096414444652455e-262)), infsup (-5.969914231928148967e-104, -6.050096414444652455e-262))); %!test %! assert (isequal (asin (infsup (-1.312550047541150255e-20, -6.354261176220087715e-253)), infsup (-1.312550047541150406e-20, -6.354261176220087715e-253))); %!test %! assert (isequal (asin (infsup (4.567490786574823890e-149, 4.198196690886986340e-123)), infsup (4.567490786574823890e-149, 4.198196690886987012e-123))); %!test %! assert (isequal (asin (infsup (-9.884682253430382309e-92, -5.579479013164953220e-154)), infsup (-9.884682253430383672e-92, -5.579479013164953220e-154))); %!test %! assert (isequal (asin (infsup (-1.522662321416928111e-13, 2.644958365616577639e-170)), infsup (-1.522662321416928363e-13, 2.644958365616578006e-170))); %!test %! assert (isequal (asin (infsup (-8.948553501584778180e-99, 2.114326410545258721e-257)), infsup (-8.948553501584779804e-99, 2.114326410545259090e-257))); %!test %! assert (isequal (asin (infsup (-9.422591232382868792e-70, -6.531943700592087501e-157)), infsup (-9.422591232382870079e-70, -6.531943700592087501e-157))); %!test %! assert (isequal (asin (infsup (-4.183491534989001599e-145, 7.226922481530353777e-207)), infsup (-4.183491534989002310e-145, 7.226922481530355161e-207))); %!test %! assert (isequal (asin (infsup (-1.261760095202863281e-243, 1.140396740717171993e-231)), infsup (-1.261760095202863541e-243, 1.140396740717172136e-231))); %!test %! assert (isequal (asin (infsup (-6.921640701718756344e-64, -1.404179941832861768e-165)), infsup (-6.921640701718757694e-64, -1.404179941832861768e-165))); %!test %! assert (isequal (asin (infsup (-7.429895589392232365e-75, -7.756983358701570246e-275)), infsup (-7.429895589392233347e-75, -7.756983358701570246e-275))); %!test %! assert (isequal (asin (infsup (6.867158476684655683e-209, 1.563441271274809437e-199)), infsup (6.867158476684655683e-209, 1.563441271274809669e-199))); %!test %! assert (isequal (asin (infsup (-9.032911858299409062e-169, 3.060735534879519294e-91)), infsup (-9.032911858299410238e-169, 3.060735534879519839e-91))); %!test %! assert (isequal (asin (infsup (-5.007253407091102708e-155, 2.431811725358315428e-307)), infsup (-5.007253407091103536e-155, 2.431811725358315824e-307))); %!test %! assert (isequal (acos (infsup (-1.312389047028587488e-49, -2.435356662074063942e-204)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-2.826769732140076133e-84, -5.561386920473982459e-193)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-1.165983769138532228e-88, -1.428974577546032222e-230)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-9.442195953730013721e-285, -2.740460328962132443e-294)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (2.046759423140378801e-219, 9.256656556116300803e-185)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-3.808509373683396527e-193, 7.757841386304002834e-162)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-1.187397361107265637e-112, -2.668312821848315349e-303)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-1.263586867414290315e-101, -2.961257846195185529e-240)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-3.901714394731276617e-270, -3.330134658353580222e-294)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-2.366650777764918445e-246, 1.071483042175132919e-285)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-4.636590066075016366e-69, 5.524052139366596165e-240)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (1.178822725995249352e-253, 3.080763910515160059e-167)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-1.102346734829299702e-19, 6.850446591467340374e-81)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-3.809307924483539467e-117, 2.162545233549648523e-70)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-3.325515536019971910e-77, -2.504008447335657004e-137)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-1.559805661433223275e-242, 7.909368633706727513e-07)), infsup (1.570795535858033221e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-5.969914231928147727e-104, -6.050096414444652455e-262)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-1.312550047541150255e-20, -6.354261176220087715e-253)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (4.567490786574823890e-149, 4.198196690886986340e-123)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-9.884682253430382309e-92, -5.579479013164953220e-154)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-1.522662321416928111e-13, 2.644958365616577639e-170)), infsup (1.570796326794896558e+00, 1.570796326795049103e+00))); %!test %! assert (isequal (acos (infsup (-8.948553501584778180e-99, 2.114326410545258721e-257)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-9.422591232382868792e-70, -6.531943700592087501e-157)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-4.183491534989001599e-145, 7.226922481530353777e-207)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-1.261760095202863281e-243, 1.140396740717171993e-231)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-6.921640701718756344e-64, -1.404179941832861768e-165)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-7.429895589392232365e-75, -7.756983358701570246e-275)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (6.867158476684655683e-209, 1.563441271274809437e-199)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-9.032911858299409062e-169, 3.060735534879519294e-91)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-5.007253407091102708e-155, 2.431811725358315428e-307)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (2.142051668986572426e-70, 1.306882282121512488e+34)), infsup (2.142051668986572104e-70, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (4.502612523763230139e-153, 3.574174482995173238e-66)), infsup (4.502612523763229609e-153, 3.574174482995173238e-66))); %!test %! assert (isequal (atan (infsup (5.495270555084999106e-61, 1.977283881120209920e+82)), infsup (5.495270555084998415e-61, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (1.090326174415294200e-137, 6.394132238750145602e-126)), infsup (1.090326174415293961e-137, 6.394132238750145602e-126))); %!test %! assert (isequal (atan (infsup (9.619256544849800952e+75, 1.976936481141943109e+88)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (1.226586363793985335e+00, 4.308666602899711518e+100)), infsup (8.868130567036106582e-01, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (7.928935505948560140e-133, 7.949640211843924994e+71)), infsup (7.928935505948558576e-133, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (3.876504952447015518e-104, 3.784447147395508652e+52)), infsup (3.876504952447014898e-104, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (1.735629038886541013e-227, 2.524795598203051262e-87)), infsup (1.735629038886540779e-227, 2.524795598203051262e-87))); %!test %! assert (isequal (atan (infsup (1.237297234801419434e-169, 5.840571936196232559e-23)), infsup (1.237297234801419286e-169, 5.840571936196232559e-23))); %!test %! assert (isequal (atan (infsup (2.646062262797938974e+54, 1.619260330717682242e+94)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (8.586668885039760719e-15, 3.330274496326268835e+77)), infsup (8.586668885039759141e-15, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (2.089478911258004246e+03, 2.654076110524515271e+197)), infsup (1.570317738608022262e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (9.185646314148092500e+14, 3.404186753017747637e+207)), infsup (1.570796326794895448e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (1.042970653496689987e-51, 3.786643969857242382e+02)), infsup (1.042970653496689839e-51, 1.568155472034706621e+00))); %!test %! assert (isequal (atan (infsup (1.159254403776913034e-163, 6.699078654119896870e+297)), infsup (1.159254403776912880e-163, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (9.621666972390800389e-133, 7.532163773886162862e-45)), infsup (9.621666972390798825e-133, 7.532163773886162862e-45))); %!test %! assert (isequal (atan (infsup (9.139956432627538486e-154, 1.485368733580681843e+106)), infsup (9.139956432627537161e-154, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (2.515545250733326100e+57, 1.476165379292337505e+72)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (5.894957732633465837e-95, 1.230428274874167409e-71)), infsup (5.894957732633465172e-95, 1.230428274874167409e-71))); %!test %! assert (isequal (atan (infsup (5.641992385637192390e+128, 7.041426524450171694e+170)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (8.878766165166293762e-17, 1.376904412228828177e+51)), infsup (8.878766165166292529e-17, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (1.442483959041155224e-103, 3.440680160407877302e-20)), infsup (1.442483959041154976e-103, 3.440680160407877302e-20))); %!test %! assert (isequal (atan (infsup (5.626945812397601245e-71, 7.528651283167650945e+03)), infsup (5.626945812397600441e-71, 1.570663500880067120e+00))); %!test %! assert (isequal (atan (infsup (6.144581905264969684e-145, 8.697059728957016802e+39)), infsup (6.144581905264968972e-145, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (1.163046489009897174e-57, 2.952069202447659552e+66)), infsup (1.163046489009897032e-57, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (7.340119470601840050e-203, 4.997184174270236677e-42)), infsup (7.340119470601838917e-203, 4.997184174270236677e-42))); %!test %! assert (isequal (atan (infsup (1.318816730766393217e+76, 3.808490005836893230e+98)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (1.061757227068338186e-97, 1.845313858239065767e+196)), infsup (1.061757227068338056e-97, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (7.269525029365293208e-38, 4.488799649180782136e-36)), infsup (7.269525029365292164e-38, 4.488799649180782136e-36))); %!test %! assert (isequal (sinh (infsup (-2.276825735402380789e-48, -1.247591758624133168e-288)), infsup (-2.276825735402381093e-48, -1.247591758624133168e-288))); %!test %! assert (isequal (sinh (infsup (-1.555899708023971053e-136, -2.066488754605661877e-191)), infsup (-1.555899708023971244e-136, -2.066488754605661877e-191))); %!test %! assert (isequal (sinh (infsup (-1.013218050883979648e+00, -8.114288896805143833e-293)), infsup (-1.195700971165398974e+00, -8.114288896805143833e-293))); %!test %! assert (isequal (sinh (infsup (-5.223236923356957882e-115, 2.450356733437761473e-182)), infsup (-5.223236923356958784e-115, 2.450356733437761807e-182))); %!test %! assert (isequal (sinh (infsup (-4.510932062945640269e-111, -9.719284552905501027e-172)), infsup (-4.510932062945641008e-111, -9.719284552905501027e-172))); %!test %! assert (isequal (sinh (infsup (-5.243225148031154877e-101, -2.926946402493516021e-125)), infsup (-5.243225148031155512e-101, -2.926946402493516021e-125))); %!test %! assert (isequal (sinh (infsup (-3.572423176829176112e-14, -6.433836389930062741e-244)), infsup (-3.572423176829176744e-14, -6.433836389930062741e-244))); %!test %! assert (isequal (sinh (infsup (-2.694213038264476014e-63, -7.562777816273446350e-67)), infsup (-2.694213038264476553e-63, -7.562777816273446350e-67))); %!test %! assert (isequal (sinh (infsup (1.088038949658882158e-80, 1.955415113914635483e-29)), infsup (1.088038949658882158e-80, 1.955415113914635764e-29))); %!test %! assert (isequal (sinh (infsup (-7.367961367144991472e-116, -3.479600132086108765e-281)), infsup (-7.367961367144992599e-116, -3.479600132086108765e-281))); %!test %! assert (isequal (sinh (infsup (-8.240014447403598921e-179, 4.244031804302998196e-06)), infsup (-8.240014447403600291e-179, 4.244031804315739266e-06))); %!test %! assert (isequal (sinh (infsup (-4.940835347719680012e-103, -3.209929124440609153e-180)), infsup (-4.940835347719681003e-103, -3.209929124440609153e-180))); %!test %! assert (isequal (sinh (infsup (-1.085358240794141589e-286, 3.362095038805252608e-121)), infsup (-1.085358240794141823e-286, 3.362095038805253038e-121))); %!test %! assert (isequal (sinh (infsup (-2.773142512496348467e-152, 5.052868105777038456e-09)), infsup (-2.773142512496348891e-152, 5.052868105777039283e-09))); %!test %! assert (isequal (sinh (infsup (-1.515739064210033408e-96, -4.584256552639734730e-257)), infsup (-1.515739064210033616e-96, -4.584256552639734730e-257))); %!test %! assert (isequal (sinh (infsup (-5.745505217333493514e-155, -4.839121225948962742e-233)), infsup (-5.745505217333494342e-155, -4.839121225948962742e-233))); %!test %! assert (isequal (sinh (infsup (-5.901539399340708264e-177, -4.071613085569532874e-241)), infsup (-5.901539399340709140e-177, -4.071613085569532874e-241))); %!test %! assert (isequal (sinh (infsup (-2.800078795581776764e-165, 3.959032834373606979e-236)), infsup (-2.800078795581777246e-165, 3.959032834373607852e-236))); %!test %! assert (isequal (sinh (infsup (-5.299801768007807772e-20, 2.412268889562441467e-206)), infsup (-5.299801768007808374e-20, 2.412268889562441744e-206))); %!test %! assert (isequal (sinh (infsup (-4.504594176548485258e-37, -1.093025376211848040e-167)), infsup (-4.504594176548486093e-37, -1.093025376211848040e-167))); %!test %! assert (isequal (sinh (infsup (-1.148387419014246691e-274, -5.607529106307211921e-306)), infsup (-1.148387419014246819e-274, -5.607529106307211921e-306))); %!test %! assert (isequal (sinh (infsup (-8.179611867336581810e-53, 3.261973107060699204e-227)), infsup (-8.179611867336582738e-53, 3.261973107060699673e-227))); %!test %! assert (isequal (sinh (infsup (-5.612415357146817830e-236, -1.379963883993877056e-283)), infsup (-5.612415357146818703e-236, -1.379963883993877056e-283))); %!test %! assert (isequal (sinh (infsup (6.353125060297895407e-217, 1.401675477619655357e-13)), infsup (6.353125060297895407e-217, 1.401675477619655609e-13))); %!test %! assert (isequal (sinh (infsup (-5.247726734531364136e-115, 1.461755126469774210e-238)), infsup (-5.247726734531365037e-115, 1.461755126469774380e-238))); %!test %! assert (isequal (sinh (infsup (-1.600607820612694866e-27, -1.050621484395105629e-166)), infsup (-1.600607820612695045e-27, -1.050621484395105629e-166))); %!test %! assert (isequal (sinh (infsup (-1.052337857345041679e-89, -1.584198096209285781e-155)), infsup (-1.052337857345041853e-89, -1.584198096209285781e-155))); %!test %! assert (isequal (sinh (infsup (-2.798033560470428915e-102, -9.926975697028544915e-270)), infsup (-2.798033560470429312e-102, -9.926975697028544915e-270))); %!test %! assert (isequal (sinh (infsup (-1.807789234464845648e-80, 1.364469289790188620e-184)), infsup (-1.807789234464846022e-80, 1.364469289790188881e-184))); %!test %! assert (isequal (sinh (infsup (-1.581262363552952774e-73, -1.558035095719158102e-130)), infsup (-1.581262363552953088e-73, -1.558035095719158102e-130))); %!test %! assert (isequal (cosh (infsup (-2.276825735402380789e-48, -1.247591758624133168e-288)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-1.555899708023971053e-136, -2.066488754605661877e-191)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-1.013218050883979648e+00, -8.114288896805143833e-293)), infsup (1.000000000000000000e+00, 1.558749759405235080e+00))); %!test %! assert (isequal (cosh (infsup (-5.223236923356957882e-115, 2.450356733437761473e-182)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-4.510932062945640269e-111, -9.719284552905501027e-172)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-5.243225148031154877e-101, -2.926946402493516021e-125)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-3.572423176829176112e-14, -6.433836389930062741e-244)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-2.694213038264476014e-63, -7.562777816273446350e-67)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (1.088038949658882158e-80, 1.955415113914635483e-29)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-7.367961367144991472e-116, -3.479600132086108765e-281)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-8.240014447403598921e-179, 4.244031804302998196e-06)), infsup (1.000000000000000000e+00, 1.000000000009005907e+00))); %!test %! assert (isequal (cosh (infsup (-4.940835347719680012e-103, -3.209929124440609153e-180)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-1.085358240794141589e-286, 3.362095038805252608e-121)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-2.773142512496348467e-152, 5.052868105777038456e-09)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-1.515739064210033408e-96, -4.584256552639734730e-257)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-5.745505217333493514e-155, -4.839121225948962742e-233)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-5.901539399340708264e-177, -4.071613085569532874e-241)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-2.800078795581776764e-165, 3.959032834373606979e-236)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-5.299801768007807772e-20, 2.412268889562441467e-206)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-4.504594176548485258e-37, -1.093025376211848040e-167)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-1.148387419014246691e-274, -5.607529106307211921e-306)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-8.179611867336581810e-53, 3.261973107060699204e-227)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-5.612415357146817830e-236, -1.379963883993877056e-283)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (6.353125060297895407e-217, 1.401675477619655357e-13)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-5.247726734531364136e-115, 1.461755126469774210e-238)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-1.600607820612694866e-27, -1.050621484395105629e-166)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-1.052337857345041679e-89, -1.584198096209285781e-155)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-2.798033560470428915e-102, -9.926975697028544915e-270)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-1.807789234464845648e-80, 1.364469289790188620e-184)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (cosh (infsup (-1.581262363552952774e-73, -1.558035095719158102e-130)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (tanh (infsup (2.142051668986572426e-70, 1.306882282121512488e+34)), infsup (2.142051668986572104e-70, 1.000000000000000000e+00))); %!test %! assert (isequal (tanh (infsup (4.502612523763230139e-153, 3.574174482995173238e-66)), infsup (4.502612523763229609e-153, 3.574174482995173238e-66))); %!test %! assert (isequal (tanh (infsup (5.495270555084999106e-61, 1.977283881120209920e+82)), infsup (5.495270555084998415e-61, 1.000000000000000000e+00))); %!test %! assert (isequal (tanh (infsup (1.090326174415294200e-137, 6.394132238750145602e-126)), infsup (1.090326174415293961e-137, 6.394132238750145602e-126))); %!test %! assert (isequal (tanh (infsup (9.619256544849800952e+75, 1.976936481141943109e+88)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (tanh (infsup (1.226586363793985335e+00, 4.308666602899711518e+100)), infsup (8.415863137654880921e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (tanh (infsup (7.928935505948560140e-133, 7.949640211843924994e+71)), infsup (7.928935505948558576e-133, 1.000000000000000000e+00))); %!test %! assert (isequal (tanh (infsup (3.876504952447015518e-104, 3.784447147395508652e+52)), infsup (3.876504952447014898e-104, 1.000000000000000000e+00))); %!test %! assert (isequal (tanh (infsup (1.735629038886541013e-227, 2.524795598203051262e-87)), infsup (1.735629038886540779e-227, 2.524795598203051262e-87))); %!test %! assert (isequal (tanh (infsup (1.237297234801419434e-169, 5.840571936196232559e-23)), infsup (1.237297234801419286e-169, 5.840571936196232559e-23))); %!test %! assert (isequal (tanh (infsup (2.646062262797938974e+54, 1.619260330717682242e+94)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (tanh (infsup (8.586668885039760719e-15, 3.330274496326268835e+77)), infsup (8.586668885039759141e-15, 1.000000000000000000e+00))); %!test %! assert (isequal (tanh (infsup (2.089478911258004246e+03, 2.654076110524515271e+197)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (tanh (infsup (9.185646314148092500e+14, 3.404186753017747637e+207)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (tanh (infsup (1.042970653496689987e-51, 3.786643969857242382e+02)), infsup (1.042970653496689839e-51, 1.000000000000000000e+00))); %!test %! assert (isequal (tanh (infsup (1.159254403776913034e-163, 6.699078654119896870e+297)), infsup (1.159254403776912880e-163, 1.000000000000000000e+00))); %!test %! assert (isequal (tanh (infsup (9.621666972390800389e-133, 7.532163773886162862e-45)), infsup (9.621666972390798825e-133, 7.532163773886162862e-45))); %!test %! assert (isequal (tanh (infsup (9.139956432627538486e-154, 1.485368733580681843e+106)), infsup (9.139956432627537161e-154, 1.000000000000000000e+00))); %!test %! assert (isequal (tanh (infsup (2.515545250733326100e+57, 1.476165379292337505e+72)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (tanh (infsup (5.894957732633465837e-95, 1.230428274874167409e-71)), infsup (5.894957732633465172e-95, 1.230428274874167409e-71))); %!test %! assert (isequal (tanh (infsup (5.641992385637192390e+128, 7.041426524450171694e+170)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (tanh (infsup (8.878766165166293762e-17, 1.376904412228828177e+51)), infsup (8.878766165166292529e-17, 1.000000000000000000e+00))); %!test %! assert (isequal (tanh (infsup (1.442483959041155224e-103, 3.440680160407877302e-20)), infsup (1.442483959041154976e-103, 3.440680160407877302e-20))); %!test %! assert (isequal (tanh (infsup (5.626945812397601245e-71, 7.528651283167650945e+03)), infsup (5.626945812397600441e-71, 1.000000000000000000e+00))); %!test %! assert (isequal (tanh (infsup (6.144581905264969684e-145, 8.697059728957016802e+39)), infsup (6.144581905264968972e-145, 1.000000000000000000e+00))); %!test %! assert (isequal (tanh (infsup (1.163046489009897174e-57, 2.952069202447659552e+66)), infsup (1.163046489009897032e-57, 1.000000000000000000e+00))); %!test %! assert (isequal (tanh (infsup (7.340119470601840050e-203, 4.997184174270236677e-42)), infsup (7.340119470601838917e-203, 4.997184174270236677e-42))); %!test %! assert (isequal (tanh (infsup (1.318816730766393217e+76, 3.808490005836893230e+98)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (tanh (infsup (1.061757227068338186e-97, 1.845313858239065767e+196)), infsup (1.061757227068338056e-97, 1.000000000000000000e+00))); %!test %! assert (isequal (tanh (infsup (7.269525029365293208e-38, 4.488799649180782136e-36)), infsup (7.269525029365292164e-38, 4.488799649180782136e-36))); %!test %! assert (isequal (coth (infsup (1.894295696760237533e-79, 1.950216651182638040e+28)), infsup (1.000000000000000000e+00, 5.279006871579093604e+78))); %!test %! assert (isequal (coth (infsup (-1.950216651182638040e+28, -1.894295696760237533e-79)), infsup (-5.279006871579093604e+78, -1.000000000000000000e+00))); %!test %! assert (isequal (coth (infsup (3.320841342139927716e-156, 6.424290443627079857e-68)), infsup (1.556592138501464494e+67, 3.011285084025142904e+155))); %!test %! assert (isequal (coth (infsup (-6.424290443627079857e-68, -3.320841342139927716e-156)), infsup (-3.011285084025142904e+155, -1.556592138501464494e+67))); %!test %! assert (isequal (coth (infsup (2.751499933051732237e-72, 9.408527432646626663e+70)), infsup (1.000000000000000000e+00, 3.634381335022909468e+71))); %!test %! assert (isequal (coth (infsup (-9.408527432646626663e+70, -2.751499933051732237e-72)), infsup (-3.634381335022909468e+71, -1.000000000000000000e+00))); %!test %! assert (isequal (coth (infsup (3.517997538706998525e-148, 1.497328258663174781e-136)), infsup (6.678562260574758313e+135, 2.842526150167629525e+147))); %!test %! assert (isequal (coth (infsup (-1.497328258663174781e-136, -3.517997538706998525e-148)), infsup (-2.842526150167629525e+147, -6.678562260574758313e+135))); %!test %! assert (isequal (coth (infsup (9.905525909214206329e+58, 2.225938119842340464e+68)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (coth (infsup (-2.225938119842340464e+68, -9.905525909214206329e+58)), infsup (-1.000000000000000222e+00, -1.000000000000000000e+00))); %!test %! assert (isequal (coth (infsup (2.239285535837240642e-13, 3.477625899530847479e+83)), infsup (1.000000000000000000e+00, 4.465710084739652344e+12))); %!test %! assert (isequal (coth (infsup (-3.477625899530847479e+83, -2.239285535837240642e-13)), infsup (-4.465710084739652344e+12, -1.000000000000000000e+00))); %!test %! assert (isequal (coth (infsup (3.415418494751353181e-144, 5.233267885617046715e+59)), infsup (1.000000000000000000e+00, 2.927898884241420862e+143))); %!test %! assert (isequal (coth (infsup (-5.233267885617046715e+59, -3.415418494751353181e-144)), infsup (-2.927898884241420862e+143, -1.000000000000000000e+00))); %!test %! assert (isequal (coth (infsup (2.475241261380885882e-113, 2.034195705081105309e+42)), infsup (1.000000000000000000e+00, 4.040010222850441763e+112))); %!test %! assert (isequal (coth (infsup (-2.034195705081105309e+42, -2.475241261380885882e-113)), infsup (-4.040010222850441763e+112, -1.000000000000000000e+00))); %!test %! assert (isequal (coth (infsup (2.549437728230459203e-232, 1.836840579504975127e-99)), infsup (5.444130596622043095e+98, 3.922433519072814253e+231))); %!test %! assert (isequal (coth (infsup (-1.836840579504975127e-99, -2.549437728230459203e-232)), infsup (-3.922433519072814253e+231, -5.444130596622043095e+98))); %!test %! assert (isequal (coth (infsup (4.325945854917056393e-175, 3.934256418924328452e-40)), infsup (2.541776370217911761e+39, 2.311633186216043598e+174))); %!test %! assert (isequal (coth (infsup (-3.934256418924328452e-40, -4.325945854917056393e-175)), infsup (-2.311633186216043598e+174, -2.541776370217911761e+39))); %!test %! assert (isequal (coth (infsup (2.036990759412397446e+35, 2.361435323577135193e+83)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (coth (infsup (-2.361435323577135193e+83, -2.036990759412397446e+35)), infsup (-1.000000000000000222e+00, -1.000000000000000000e+00))); %!test %! assert (isequal (coth (infsup (1.859092626033397846e-30, 3.496514376215051672e+61)), infsup (1.000000000000000000e+00, 5.378968137448980910e+29))); %!test %! assert (isequal (coth (infsup (-3.496514376215051672e+61, -1.859092626033397846e-30)), infsup (-5.378968137448980910e+29, -1.000000000000000000e+00))); %!test %! assert (isequal (coth (infsup (2.090285002199718534e+01, 2.207982549862724136e+179)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (coth (infsup (-2.207982549862724136e+179, -2.090285002199718534e+01)), infsup (-1.000000000000000222e+00, -1.000000000000000000e+00))); %!test %! assert (isequal (coth (infsup (1.208755205351178767e+06, 3.006650875502725685e+189)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (coth (infsup (-3.006650875502725685e+189, -1.208755205351178767e+06)), infsup (-1.000000000000000222e+00, -1.000000000000000000e+00))); %!test %! assert (isequal (coth (infsup (6.431982815787139811e-54, 1.599583732850823968e-07)), infsup (6.251626466704432853e+06, 1.554730521893692440e+53))); %!test %! assert (isequal (coth (infsup (-1.599583732850823968e-07, -6.431982815787139811e-54)), infsup (-1.554730521893692440e+53, -6.251626466704432853e+06))); %!test %! assert (isequal (asinh (infsup (2.142051668986572426e-70, 1.306882282121512488e+34)), infsup (2.142051668986572104e-70, 7.924868470570649492e+01))); %!test %! assert (isequal (asinh (infsup (4.502612523763230139e-153, 3.574174482995173238e-66)), infsup (4.502612523763229609e-153, 3.574174482995173238e-66))); %!test %! assert (isequal (asinh (infsup (5.495270555084999106e-61, 1.977283881120209920e+82)), infsup (5.495270555084998415e-61, 1.901868489318184174e+02))); %!test %! assert (isequal (asinh (infsup (1.090326174415294200e-137, 6.394132238750145602e-126)), infsup (1.090326174415293961e-137, 6.394132238750145602e-126))); %!test %! assert (isequal (asinh (infsup (9.619256544849800952e+75, 1.976936481141943109e+88)), infsup (1.756507961345643878e+02, 2.040021837787967911e+02))); %!test %! assert (isequal (asinh (infsup (1.226586363793985335e+00, 4.308666602899711518e+100)), infsup (1.032882671369447447e+00, 2.324122849633374130e+02))); %!test %! assert (isequal (asinh (infsup (7.928935505948560140e-133, 7.949640211843924994e+71)), infsup (7.928935505948558576e-133, 1.662498154544074964e+02))); %!test %! assert (isequal (asinh (infsup (3.876504952447015518e-104, 3.784447147395508652e+52)), infsup (3.876504952447014898e-104, 1.217584718283750362e+02))); %!test %! assert (isequal (asinh (infsup (1.735629038886541013e-227, 2.524795598203051262e-87)), infsup (1.735629038886540779e-227, 2.524795598203051262e-87))); %!test %! assert (isequal (asinh (infsup (1.237297234801419434e-169, 5.840571936196232559e-23)), infsup (1.237297234801419286e-169, 5.840571936196232559e-23))); %!test %! assert (isequal (asinh (infsup (2.646062262797938974e+54, 1.619260330717682242e+94)), infsup (1.260058147985681245e+02, 2.176181153810006776e+02))); %!test %! assert (isequal (asinh (infsup (8.586668885039760719e-15, 3.330274496326268835e+77)), infsup (8.586668885039759141e-15, 1.791952540730257510e+02))); %!#asinh [0X8.297A99ED9ED08P+8, 0XE.33C49CF5B8790P+652] = [0X8.567B3095B8380P+0, 0X1.C7474C3E00682P+8]; %!#asinh [0X3.436DFE8F08194P+48, 0X2.A69A969772FDEP+688] = [0X2.325A084AF897EP+4, 0X1.DE8DA2F064858P+8]; %!test %! assert (isequal (asinh (infsup (1.042970653496689987e-51, 3.786643969857242382e+02)), infsup (1.042970653496689839e-51, 6.629799240811253824e+00))); %!test %! assert (isequal (asinh (infsup (1.159254403776913034e-163, 6.699078654119896870e+297)), infsup (1.159254403776912880e-163, 6.864628898024220689e+02))); %!test %! assert (isequal (asinh (infsup (9.621666972390800389e-133, 7.532163773886162862e-45)), infsup (9.621666972390798825e-133, 7.532163773886162862e-45))); %!test %! assert (isequal (asinh (infsup (9.139956432627538486e-154, 1.485368733580681843e+106)), infsup (9.139956432627537161e-154, 2.451628300848022946e+02))); %!test %! assert (isequal (asinh (infsup (2.515545250733326100e+57, 1.476165379292337505e+72)), infsup (1.328629870607709620e+02, 1.668687216416238925e+02))); %!test %! assert (isequal (asinh (infsup (5.894957732633465837e-95, 1.230428274874167409e-71)), infsup (5.894957732633465172e-95, 1.230428274874167409e-71))); %!#asinh [0XD.05E9CCF66CF58P+424, 0XB.A944253373080P+564] = [0X1.29277EA798036P+8, 0X1.8A159CCBD552AP+8]; %!test %! assert (isequal (asinh (infsup (8.878766165166293762e-17, 1.376904412228828177e+51)), infsup (8.878766165166292529e-17, 1.184448247231850360e+02))); %!test %! assert (isequal (asinh (infsup (1.442483959041155224e-103, 3.440680160407877302e-20)), infsup (1.442483959041154976e-103, 3.440680160407877302e-20))); %!test %! assert (isequal (asinh (infsup (5.626945812397601245e-71, 7.528651283167650945e+03)), infsup (5.626945812397600441e-71, 9.619618377260879427e+00))); %!test %! assert (isequal (asinh (infsup (6.144581905264969684e-145, 8.697059728957016802e+39)), infsup (6.144581905264968972e-145, 9.265695081367732655e+01))); %!test %! assert (isequal (asinh (infsup (1.163046489009897174e-57, 2.952069202447659552e+66)), infsup (1.163046489009897032e-57, 1.537462696671939852e+02))); %!test %! assert (isequal (asinh (infsup (7.340119470601840050e-203, 4.997184174270236677e-42)), infsup (7.340119470601838917e-203, 4.997184174270236677e-42))); %!test %! assert (isequal (asinh (infsup (1.318816730766393217e+76, 3.808490005836893230e+98)), infsup (1.759663491665984338e+02, 2.276837190806306239e+02))); %!#asinh [0X3.A0EE84451C92CP-324, 0XF.CC937FA330E40P+648] = [0X3.A0EE84451C92AP-324, 0X1.C49CCB25BBD50P+8]; %!test %! assert (isequal (asinh (infsup (7.269525029365293208e-38, 4.488799649180782136e-36)), infsup (7.269525029365292164e-38, 4.488799649180782136e-36))); %!test %! assert (isequal (acosh (infsup (4.308689365264194681e+82, 1.870190767041050574e+259)), infsup (1.909657585723560658e+02, 5.976887267061416651e+02))); %!test %! assert (isequal (acosh (infsup (1.663490370649616415e+104, 1.013015541347756766e+134)), infsup (2.406709148797917237e+02, 3.092524812088139470e+02))); %!test %! assert (isequal (acosh (infsup (4.740352466070305280e+17, 3.416343854883929839e+224)), infsup (4.139320525433158338e+01, 5.177007789421815005e+02))); %!test %! assert (isequal (acosh (infsup (5.649987645498339448e+39, 4.009451878894758553e+115)), infsup (9.222561916584621144e+01, 2.668790874182960238e+02))); %!test %! assert (isequal (acosh (infsup (8.616687911287559235e+77, 5.944690784478971107e+169)), infsup (1.801459001189113280e+02, 3.916125264126404204e+02))); %!test %! assert (isequal (acosh (infsup (1.337707751915661292e+170, 1.380110451090683299e+220)), infsup (3.924235705058085273e+02, 5.075840311722385536e+02))); %!test %! assert (isequal (acosh (infsup (1.220751226792469375e+14, 7.832127768107454054e+156)), infsup (3.312880491138550809e+01, 3.619546559063252289e+02))); %!test %! assert (isequal (acosh (infsup (4.401102955082982275e+23, 1.287462777714444441e+159)), infsup (5.513445950054409650e+01, 3.670568504092379953e+02))); %!test %! assert (isequal (acosh (infsup (1.301393744352418326e+89, 2.720259598242152528e+307)), infsup (2.058866562582371955e+02, 7.085874980460159804e+02))); %!test %! assert (isequal (acosh (infsup (6.939444977341106986e+123, 1.984966170027903415e+260)), infsup (2.858483354157015697e+02, 6.000508732301987038e+02))); %!test %! assert (isequal (acosh (infsup (6.485225963939702296e+146, 9.590094226342687312e+261)), infsup (3.387400974189444014e+02, 6.039285871663319085e+02))); %!test %! assert (isequal (acosh (infsup (2.743579466422469183e+115, 4.645309981121623107e+192)), infsup (2.664996963173169888e+02, 4.443253431398200632e+02))); %!test %! assert (isequal (acosh (infsup (6.315691036069834079e+183, 1.254000664372473335e+196)), infsup (4.239092563760087842e+02, 4.522261643794061001e+02))); %!test %! assert (isequal (acosh (infsup (1.138781729534858459e+05, 6.522252952647259925e+170)), infsup (1.233603167819211954e+01, 3.940078328506839398e+02))); %!test %! assert (isequal (acosh (infsup (1.705317527179950542e+68, 1.807502842596086102e+136)), infsup (1.578026848305014198e+02, 3.144366660754669738e+02))); %!test %! assert (isequal (acosh (infsup (2.320700483702952407e+153, 1.406262907030544946e+207)), infsup (3.538305354813851977e+02, 4.776691971955887084e+02))); %!test %! assert (isequal (acosh (infsup (1.484021313157366875e+14, 6.690353456676457891e+66)), infsup (3.332409398908451692e+01, 1.545644300244953797e+02))); %!test %! assert (isequal (acosh (infsup (1.949448535585448881e+38, 1.286062297009824876e+183)), infsup (8.885892724464935100e+01, 4.223178042655773083e+02))); %!test %! assert (isequal (acosh (infsup (1.323970487459108229e+62, 5.603597588316931976e+76)), infsup (1.437340581130183921e+02, 1.774130230660661312e+02))); %!test %! assert (isequal (acosh (infsup (4.971908888084823723e+22, 1.705737433846073186e+263)), infsup (5.295382307490645246e+01, 6.068070241677426111e+02))); %!test %! assert (isequal (acosh (infsup (3.185265905903948048e+68, 1.396714687103404512e+294)), infsup (1.584274692766343264e+02, 6.779872873476585937e+02))); %!test %! assert (isequal (acosh (infsup (2.419365169286764294e+162, 6.023839510485900011e+239)), infsup (3.745954374246092016e+02, 5.528067092545940113e+02))); %!test %! assert (isequal (acosh (infsup (6.369713416360370450e+54, 1.746916684461024567e+239)), infsup (1.268842966812280508e+02, 5.515688367455168191e+02))); %!test %! assert (isequal (acosh (infsup (2.510121874915821578e+141, 1.760590294900778378e+244)), infsup (3.262779766004285875e+02, 5.630895590187549260e+02))); %!test %! assert (isequal (acosh (infsup (8.413476455681521536e+227, 4.905680962443388553e+277)), infsup (5.255097980504410771e+02, 6.400996118535556434e+02))); %!test %! assert (isequal (acosh (infsup (5.329335402634341777e+21, 1.810944547265758752e+289)), infsup (5.072066067390094446e+01, 6.667340876143190371e+02))); %!test %! assert (isequal (acosh (infsup (2.791850949318598675e+238, 1.892476551972181292e+277)), infsup (5.497351041117033219e+02, 6.391471042561882996e+02))); %!test %! assert (isequal (acosh (infsup (1.811273674489520570e+131, 3.937972452864056384e+191)), infsup (3.029258246481488754e+02, 4.418575659274054033e+02))); %!test %! assert (isequal (acosh (infsup (1.297701720686003170e+139, 2.351832189572987335e+171)), infsup (3.210130698994429395e+02, 3.952903927620620834e+02))); %!test %! assert (isequal (acosh (infsup (1.177543487203761135e+25, 4.156461555557113578e+231)), infsup (5.842120498344542057e+01, 5.340149677868963636e+02))); %!test %! assert (isequal (atanh (infsup (-1.312389047028587488e-49, -2.435356662074063942e-204)), infsup (-1.312389047028587678e-49, -2.435356662074063942e-204))); %!test %! assert (isequal (atanh (infsup (-2.826769732140076133e-84, -5.561386920473982459e-193)), infsup (-2.826769732140076591e-84, -5.561386920473982459e-193))); %!test %! assert (isequal (atanh (infsup (-1.165983769138532228e-88, -1.428974577546032222e-230)), infsup (-1.165983769138532367e-88, -1.428974577546032222e-230))); %!test %! assert (isequal (atanh (infsup (-9.442195953730013721e-285, -2.740460328962132443e-294)), infsup (-9.442195953730015214e-285, -2.740460328962132443e-294))); %!test %! assert (isequal (atanh (infsup (2.046759423140378801e-219, 9.256656556116300803e-185)), infsup (2.046759423140378801e-219, 9.256656556116302109e-185))); %!test %! assert (isequal (atanh (infsup (-3.808509373683396527e-193, 7.757841386304002834e-162)), infsup (-3.808509373683397013e-193, 7.757841386304003821e-162))); %!test %! assert (isequal (atanh (infsup (-1.187397361107265637e-112, -2.668312821848315349e-303)), infsup (-1.187397361107265868e-112, -2.668312821848315349e-303))); %!test %! assert (isequal (atanh (infsup (-1.263586867414290315e-101, -2.961257846195185529e-240)), infsup (-1.263586867414290474e-101, -2.961257846195185529e-240))); %!test %! assert (isequal (atanh (infsup (-3.901714394731276617e-270, -3.330134658353580222e-294)), infsup (-3.901714394731277458e-270, -3.330134658353580222e-294))); %!test %! assert (isequal (atanh (infsup (-2.366650777764918445e-246, 1.071483042175132919e-285)), infsup (-2.366650777764918953e-246, 1.071483042175133106e-285))); %!test %! assert (isequal (atanh (infsup (-4.636590066075016366e-69, 5.524052139366596165e-240)), infsup (-4.636590066075017395e-69, 5.524052139366597231e-240))); %!test %! assert (isequal (atanh (infsup (1.178822725995249352e-253, 3.080763910515160059e-167)), infsup (1.178822725995249352e-253, 3.080763910515160435e-167))); %!test %! assert (isequal (atanh (infsup (-1.102346734829299702e-19, 6.850446591467340374e-81)), infsup (-1.102346734829299943e-19, 6.850446591467341310e-81))); %!test %! assert (isequal (atanh (infsup (-3.809307924483539467e-117, 2.162545233549648523e-70)), infsup (-3.809307924483540172e-117, 2.162545233549648845e-70))); %!test %! assert (isequal (atanh (infsup (-3.325515536019971910e-77, -2.504008447335657004e-137)), infsup (-3.325515536019972294e-77, -2.504008447335657004e-137))); %!test %! assert (isequal (atanh (infsup (-1.559805661433223275e-242, 7.909368633706727513e-07)), infsup (-1.559805661433223483e-242, 7.909368633708377109e-07))); %!test %! assert (isequal (atanh (infsup (-5.969914231928147727e-104, -6.050096414444652455e-262)), infsup (-5.969914231928148967e-104, -6.050096414444652455e-262))); %!test %! assert (isequal (atanh (infsup (-1.312550047541150255e-20, -6.354261176220087715e-253)), infsup (-1.312550047541150406e-20, -6.354261176220087715e-253))); %!test %! assert (isequal (atanh (infsup (4.567490786574823890e-149, 4.198196690886986340e-123)), infsup (4.567490786574823890e-149, 4.198196690886987012e-123))); %!test %! assert (isequal (atanh (infsup (-9.884682253430382309e-92, -5.579479013164953220e-154)), infsup (-9.884682253430383672e-92, -5.579479013164953220e-154))); %!test %! assert (isequal (atanh (infsup (-1.522662321416928111e-13, 2.644958365616577639e-170)), infsup (-1.522662321416928363e-13, 2.644958365616578006e-170))); %!test %! assert (isequal (atanh (infsup (-8.948553501584778180e-99, 2.114326410545258721e-257)), infsup (-8.948553501584779804e-99, 2.114326410545259090e-257))); %!test %! assert (isequal (atanh (infsup (-9.422591232382868792e-70, -6.531943700592087501e-157)), infsup (-9.422591232382870079e-70, -6.531943700592087501e-157))); %!test %! assert (isequal (atanh (infsup (-4.183491534989001599e-145, 7.226922481530353777e-207)), infsup (-4.183491534989002310e-145, 7.226922481530355161e-207))); %!test %! assert (isequal (atanh (infsup (-1.261760095202863281e-243, 1.140396740717171993e-231)), infsup (-1.261760095202863541e-243, 1.140396740717172136e-231))); %!test %! assert (isequal (atanh (infsup (-6.921640701718756344e-64, -1.404179941832861768e-165)), infsup (-6.921640701718757694e-64, -1.404179941832861768e-165))); %!test %! assert (isequal (atanh (infsup (-7.429895589392232365e-75, -7.756983358701570246e-275)), infsup (-7.429895589392233347e-75, -7.756983358701570246e-275))); %!test %! assert (isequal (atanh (infsup (6.867158476684655683e-209, 1.563441271274809437e-199)), infsup (6.867158476684655683e-209, 1.563441271274809669e-199))); %!test %! assert (isequal (atanh (infsup (-9.032911858299409062e-169, 3.060735534879519294e-91)), infsup (-9.032911858299410238e-169, 3.060735534879519839e-91))); %!test %! assert (isequal (atanh (infsup (-5.007253407091102708e-155, 2.431811725358315428e-307)), infsup (-5.007253407091103536e-155, 2.431811725358315824e-307))); %!test %! assert (isequal (expm1 (infsup (-5.654676730021285758e+33, -2.467054147405823936e-70)), infsup (-1.000000000000000000e+00, -2.467054147405823614e-70))); %!test %! assert (isequal (expm1 (infsup (-1.339988487076310626e-66, -3.142176739251405931e-153)), infsup (-1.339988487076310626e-66, -3.142176739251405401e-153))); %!test %! assert (isequal (expm1 (infsup (-1.559745526584455293e+82, -8.494812002392629213e-61)), infsup (-1.000000000000000000e+00, -8.494812002392627831e-61))); %!test %! assert (isequal (expm1 (infsup (-1.215647583031333080e-125, -2.146363543986120533e-137)), infsup (-1.215647583031333080e-125, -2.146363543986120294e-137))); %!#expm1 [-0X6.FF424CB26239CP+292, -0X2.89F6682121BA8P+252] = [-0X1.0000000000000P+0, -0X1.0000000000000P+0]; %!test %! assert (isequal (expm1 (infsup (-7.439842988767636755e+100, -1.769170660676674389e+00)), infsup (-1.000000000000000000e+00, -8.295256887348699815e-01))); %!test %! assert (isequal (expm1 (infsup (-7.499234869798133827e+71, -1.740341118088671732e-132)), infsup (-1.000000000000000000e+00, -1.740341118088671419e-132))); %!test %! assert (isequal (expm1 (infsup (-2.932406654409041728e+52, -5.352481974657761661e-104)), infsup (-1.000000000000000000e+00, -5.352481974657761041e-104))); %!test %! assert (isequal (expm1 (infsup (-5.017847776764403958e-87, -2.227977792271395082e-227)), infsup (-5.017847776764403958e-87, -2.227977792271394613e-227))); %!test %! assert (isequal (expm1 (infsup (-1.827668734769395026e-22, -1.326175859067188756e-169)), infsup (-1.827668734769395026e-22, -1.326175859067188461e-169))); %!#expm1 [-0X1.582D3AFB2C63DP+312, -0X5.08DC843E57ED4P+180] = [-0X1.0000000000000P+0, -0X1.0000000000000P+0]; %!test %! assert (isequal (expm1 (infsup (-5.423963041733560701e+77, -2.059305088062927775e-14)), infsup (-1.000000000000000000e+00, -2.059305088062906318e-14))); %!test %! assert (isequal (expm1 (infsup (-3.360610542799653195e+197, -5.874775479904158146e+02)), infsup (-1.000000000000000000e+00, -9.999999999999998890e-01))); %!#expm1 [-0X3.2FD3FDE325402P+688, -0X2.738623C238270P+48] = [-0X1.0000000000000P+0, -0X1.0000000000000P+0]; %!test %! assert (isequal (expm1 (infsup (-3.249456070719769514e+02, -3.915939161035242553e-52)), infsup (-1.000000000000000000e+00, -3.915939161035241811e-52))); %!test %! assert (isequal (expm1 (infsup (-6.756234292039407244e+297, -1.232680690145569154e-163)), infsup (-1.000000000000000000e+00, -1.232680690145569000e-163))); %!test %! assert (isequal (expm1 (infsup (-3.768432504481998329e-45, -1.425448715493971452e-132)), infsup (-3.768432504481998329e-45, -1.425448715493971139e-132))); %!test %! assert (isequal (expm1 (infsup (-6.868984884638793653e+105, -1.124545542537290068e-153)), infsup (-1.000000000000000000e+00, -1.124545542537289935e-153))); %!#expm1 [-0XD.F2552B8F60978P+236, -0X7.FBDBC320979A4P+188] = [-0X1.0000000000000P+0, -0X1.0000000000000P+0]; %!test %! assert (isequal (expm1 (infsup (-4.825221040561267626e-72, -3.741418656433786262e-95)), infsup (-4.825221040561267626e-72, -3.741418656433785596e-95))); %!test %! assert (isequal (expm1 (infsup (1.000000000000000000e+00, 2.000000000000000000e+00)), infsup (1.718281828459045091e+00, 6.389056098930650407e+00))); %!test %! assert (isequal (expm1 (infsup (-1.000000000000000000e+00, 2.000000000000000000e+00)), infsup (-6.321205588285577770e-01, 6.389056098930650407e+00))); %!test %! assert (isequal (expm1 (infsup (-5.000000000000000000e+00, -3.000000000000000000e+00)), infsup (-9.932620530009146353e-01, -9.502129316321360486e-01))); %!test %! assert (isequal (expm1 (infsup (-2.000000000000000000e+00, 5.999999999999999778e-01)), infsup (-8.646647167633874087e-01, 8.221188003905089969e-01))); %!test %! assert (isequal (expm1 (infsup (4.940656458412465442e-324, 5.526030376261632760e-318)), infsup (4.940656458412465442e-324, 5.526035316918091172e-318))); %!test %! assert (isequal (expm1 (infsup (2.158572806680406152e-320, 1.000000000000000000e+00)), infsup (2.158572806680406152e-320, 1.718281828459045313e+00))); %!test %! assert (isequal (expm1 (infsup (-3.453765897253233967e-319, 3.453765897253233967e-319)), infsup (-3.453765897253233967e-319, 3.453815303817818092e-319))); %!test %! assert (isequal (expm1 (infsup (-1.348799213146603066e-321, 1.999755859375000000e+00)), infsup (-1.348799213146603066e-321, 6.387252350349609920e+00))); %!test %! assert (isequal (expm1 (infsup (-1.999984741210937500e+00, -1.768329819216851651e-316)), infsup (-8.646626516950925989e-01, -1.768329769810287067e-316))); %!test %! assert (isequal (expm1 (infsup (-1.999999996274709702e+00, 4.668945501635218808e-314)), infsup (-8.646647162592241420e-01, 4.668945502129284454e-314))); %!test %! assert (isequal (log1p (infsup (4.147420261371489825e-79, 5.379571027897612396e+28)), infsup (4.147420261371489226e-79, 6.615499124023648392e+01))); %!test %! assert (isequal (log1p (infsup (1.110880646187224313e-155, 2.373351651082584966e-67)), infsup (1.110880646187224105e-155, 2.373351651082584966e-67))); %!test %! assert (isequal (log1p (infsup (5.129079157666995424e-72, 1.751070362531829627e+71)), infsup (5.129079157666994419e-72, 1.640437688392722464e+02))); %!test %! assert (isequal (log1p (infsup (6.948997631311531055e-148, 2.928301646694579776e-136)), infsup (6.948997631311529665e-148, 2.928301646694579776e-136))); %!test %! assert (isequal (log1p (infsup (1.228976222624138207e+59, 2.234162998792154053e+68)), infsup (1.360587019701163172e+02, 1.573796529843343421e+02))); %!test %! assert (isequal (log1p (infsup (3.765881959744468747e-13, 4.282127607174989696e+83)), infsup (3.765881959743759404e-13, 1.925690127090641397e+02))); %!test %! assert (isequal (log1p (infsup (6.336975772360046338e-144, 9.158993707856365702e+59)), infsup (6.336975772360045200e-144, 1.380672568020790720e+02))); %!test %! assert (isequal (log1p (infsup (5.364761505213512494e-113, 4.082352475280499044e+42)), infsup (5.364761505213511340e-113, 9.811524731508208674e+01))); %!test %! assert (isequal (log1p (infsup (7.550677903404239041e-232, 3.224750948704370352e-99)), infsup (7.550677903404237611e-232, 3.224750948704370352e-99))); %!test %! assert (isequal (log1p (infsup (1.225297990074229138e-174, 4.817234909117431242e-40)), infsup (1.225297990074228914e-174, 4.817234909117431242e-40))); %!test %! assert (isequal (log1p (infsup (2.170435512584716658e+35, 4.550722777302786970e+83)), infsup (8.136540609925064871e+01, 1.926298487910074471e+02))); %!test %! assert (isequal (log1p (infsup (2.535659632151250680e-30, 4.662866785261630365e+61)), infsup (2.535659632151250329e-30, 1.419973211215928757e+02))); %!test %! assert (isequal (log1p (infsup (7.582817216007211414e+01, 2.533325420226928244e+179)), infsup (4.341571397890723105e+00, 4.130922644809588746e+02))); %!test %! assert (isequal (log1p (infsup (2.679384856388388202e+06, 3.456099944072672956e+189)), infsup (1.480109816816228374e+01, 4.364287233454008401e+02))); %!test %! assert (isequal (log1p (infsup (2.298466163925377139e-53, 3.422642591789022920e-07)), infsup (2.298466163925376675e-53, 3.422642006065041091e-07))); %!test %! assert (isequal (log1p (infsup (8.331537116545182766e-169, 1.276575089856515728e+278)), infsup (8.331537116545181589e-169, 6.403628366331134885e+02))); %!test %! assert (isequal (log1p (infsup (3.718156390017819207e-141, 1.084633607212178861e-48)), infsup (3.718156390017818625e-141, 1.084633607212178861e-48))); %!test %! assert (isequal (log1p (infsup (3.157294329035461405e-160, 9.898300388558577825e+97)), infsup (3.157294329035460773e-160, 2.256431170849012631e+02))); %!test %! assert (isequal (log1p (infsup (1.083356361649631714e+44, 3.415036575780023082e+59)), infsup (1.013938080560929649e+02, 1.370807086899449985e+02))); %!test %! assert (isequal (log1p (infsup (8.455584990678977241e-99, 6.051563441903092353e-73)), infsup (8.455584990678975617e-99, 6.051563441903092353e-73))); %!test %! assert (isequal (log1p (infsup (2.360349141715971707e+109, 8.567792987486366378e+158)), infsup (2.518405846858512973e+02, 3.659564548647884408e+02))); %!test %! assert (isequal (log1p (infsup (2.012916824299288793e-32, 2.822293342336804668e+41)), infsup (2.012916824299288519e-32, 9.544353860916723420e+01))); %!test %! assert (isequal (log1p (infsup (4.831139778854605785e-107, 2.083134309679031648e-23)), infsup (4.831139778854605180e-107, 2.083134309679031648e-23))); %!test %! assert (isequal (log1p (infsup (8.466268199564697371e-76, 1.680782691923963737e-10)), infsup (8.466268199564696144e-76, 1.680782691782712307e-10))); %!test %! assert (isequal (log1p (infsup (2.283702426861795342e-151, 2.158830003381976904e+22)), infsup (2.283702426861795002e-151, 5.142643845571060979e+01))); %!test %! assert (isequal (log1p (infsup (1.114428406645123204e-64, 1.137441975089809242e+58)), infsup (1.114428406645123036e-64, 1.336787172532864645e+02))); %!test %! assert (isequal (log1p (infsup (1.463767593806767211e-207, 3.684178239990781413e-44)), infsup (1.463767593806767038e-207, 3.684178239990781413e-44))); %!test %! assert (isequal (log1p (infsup (1.806590984564742948e+58, 4.476357965164357790e+78)), infsup (1.341413770290983223e+02, 1.811004470151316070e+02))); %!test %! assert (isequal (log1p (infsup (2.504949335867761681e-102, 4.444462712533866271e+177)), infsup (2.504949335867761285e-102, 4.090492204470355091e+02))); %!test %! assert (isequal (log1p (infsup (1.027829701532525701e-53, 1.755408547816880709e-45)), infsup (1.027829701532525585e-53, 1.755408547816880709e-45))); %!test %! assert (isequal (realsqrt (infsup (4.147420261371489825e-79, 5.379571027897612396e+28)), infsup (6.440046786609154008e-40, 2.319390227602421562e+14))); %!test %! assert (isequal (realsqrt (infsup (1.110880646187224313e-155, 2.373351651082584966e-67)), infsup (3.332987618019641001e-78, 4.871705708561002190e-34))); %!test %! assert (isequal (realsqrt (infsup (5.129079157666995424e-72, 1.751070362531829627e+71)), infsup (2.264747040547132332e-36, 4.184579265029914561e+35))); %!test %! assert (isequal (realsqrt (infsup (6.948997631311531055e-148, 2.928301646694579776e-136)), infsup (2.636095148379802032e-74, 1.711228110654620020e-68))); %!test %! assert (isequal (realsqrt (infsup (1.228976222624138207e+59, 2.234162998792154053e+68)), infsup (3.505675716069781836e+29, 1.494711677479022891e+34))); %!test %! assert (isequal (realsqrt (infsup (3.765881959744468747e-13, 4.282127607174989696e+83)), infsup (6.136678221761727970e-07, 6.543796762717337107e+41))); %!test %! assert (isequal (realsqrt (infsup (6.336975772360046338e-144, 9.158993707856365702e+59)), infsup (2.517335053654964799e-72, 9.570263166630459163e+29))); %!test %! assert (isequal (realsqrt (infsup (5.364761505213512494e-113, 4.082352475280499044e+42)), infsup (7.324453225472541740e-57, 2.020483228161149501e+21))); %!test %! assert (isequal (realsqrt (infsup (7.550677903404239041e-232, 3.224750948704370352e-99)), infsup (2.747849687192557654e-116, 5.678689064127715303e-50))); %!test %! assert (isequal (realsqrt (infsup (1.225297990074229138e-174, 4.817234909117431242e-40)), infsup (1.106931791066743519e-87, 2.194820017476930231e-20))); %!test %! assert (isequal (realsqrt (infsup (2.170435512584716658e+35, 4.550722777302786970e+83)), infsup (4.658793312205121280e+17, 6.745904518522914642e+41))); %!test %! assert (isequal (realsqrt (infsup (2.535659632151250680e-30, 4.662866785261630365e+61)), infsup (1.592375468333787993e-15, 6.828518715842866868e+30))); %!test %! assert (isequal (realsqrt (infsup (7.582817216007211414e+01, 2.533325420226928244e+179)), infsup (8.707937308000792243e+00, 5.033215095966919400e+89))); %!test %! assert (isequal (realsqrt (infsup (2.679384856388388202e+06, 3.456099944072672956e+189)), infsup (1.636882664209132599e+03, 5.878860386225099984e+94))); %!test %! assert (isequal (realsqrt (infsup (2.298466163925377139e-53, 3.422642591789022920e-07)), infsup (4.794232121962157468e-27, 5.850335538914860564e-04))); %!test %! assert (isequal (realsqrt (infsup (8.331537116545182766e-169, 1.276575089856515728e+278)), infsup (9.127725410278938219e-85, 1.129856225303253353e+139))); %!test %! assert (isequal (realsqrt (infsup (3.718156390017819207e-141, 1.084633607212178861e-48)), infsup (6.097668726667445732e-71, 1.041457443783556123e-24))); %!test %! assert (isequal (realsqrt (infsup (3.157294329035461405e-160, 9.898300388558577825e+97)), infsup (1.776877691073716194e-80, 9.949020247521149013e+48))); %!test %! assert (isequal (realsqrt (infsup (1.083356361649631714e+44, 3.415036575780023082e+59)), infsup (1.040844062119600901e+22, 5.843831427907570747e+29))); %!test %! assert (isequal (realsqrt (infsup (8.455584990678977241e-99, 6.051563441903092353e-73)), infsup (9.195425488077740187e-50, 7.779179546650850484e-37))); %!test %! assert (isequal (realsqrt (infsup (2.360349141715971707e+109, 8.567792987486366378e+158)), infsup (4.858342455731143318e+54, 2.927079258832320626e+79))); %!test %! assert (isequal (realsqrt (infsup (2.012916824299288793e-32, 2.822293342336804668e+41)), infsup (1.418772999566628592e-16, 5.312526086841179177e+20))); %!test %! assert (isequal (realsqrt (infsup (4.831139778854605785e-107, 2.083134309679031648e-23)), infsup (6.950640099195617068e-54, 4.564136621179335194e-12))); %!test %! assert (isequal (realsqrt (infsup (8.466268199564697371e-76, 1.680782691923963737e-10)), infsup (2.909685240634233473e-38, 1.296450034488010588e-05))); %!test %! assert (isequal (realsqrt (infsup (2.283702426861795342e-151, 2.158830003381976904e+22)), infsup (4.778809921792030281e-76, 1.469295750821452942e+11))); %!test %! assert (isequal (realsqrt (infsup (1.114428406645123204e-64, 1.137441975089809242e+58)), infsup (1.055664912102852335e-32, 1.066509247540690319e+29))); %!test %! assert (isequal (realsqrt (infsup (1.463767593806767211e-207, 3.684178239990781413e-44)), infsup (3.825921580229744811e-104, 1.919421329461247340e-22))); %!test %! assert (isequal (realsqrt (infsup (1.806590984564742948e+58, 4.476357965164357790e+78)), infsup (1.344094856981732069e+29, 2.115740524063468000e+39))); %!test %! assert (isequal (realsqrt (infsup (2.504949335867761681e-102, 4.444462712533866271e+177)), infsup (1.582703173645570547e-51, 6.666680367719655103e+88))); %!test %! assert (isequal (realsqrt (infsup (1.027829701532525701e-53, 1.755408547816880709e-45)), infsup (3.205978324213258952e-27, 4.189759596703468421e-23))); %!test %! assert (isequal (pown (infsup (-1.820250631842705497e-45, -9.117403206523163851e-284), 2), infsup (0.000000000000000000e+00, 3.313312362723768996e-90))); %! assert (isequal (infsup (-1.820250631842705497e-45, -9.117403206523163851e-284) .^ 2, infsup (0.000000000000000000e+00, 3.313312362723768996e-90))); %! assert (isequal (power (infsup (-1.820250631842705497e-45, -9.117403206523163851e-284), 2), infsup (0.000000000000000000e+00, 3.313312362723768996e-90))); %! assert (isequal (infsup (-1.820250631842705497e-45, -9.117403206523163851e-284) ^ 2, infsup (0.000000000000000000e+00, 3.313312362723768996e-90))); %! assert (isequal (mpower (infsup (-1.820250631842705497e-45, -9.117403206523163851e-284), 2), infsup (0.000000000000000000e+00, 3.313312362723768996e-90))); %!test %! assert (isequal (pown (infsup (-9.132843019095516065e-132, -9.836586939929288236e-188), 2), infsup (0.000000000000000000e+00, 8.340882161144170744e-263))); %! assert (isequal (infsup (-9.132843019095516065e-132, -9.836586939929288236e-188) .^ 2, infsup (0.000000000000000000e+00, 8.340882161144170744e-263))); %! assert (isequal (power (infsup (-9.132843019095516065e-132, -9.836586939929288236e-188), 2), infsup (0.000000000000000000e+00, 8.340882161144170744e-263))); %! assert (isequal (infsup (-9.132843019095516065e-132, -9.836586939929288236e-188) ^ 2, infsup (0.000000000000000000e+00, 8.340882161144170744e-263))); %! assert (isequal (mpower (infsup (-9.132843019095516065e-132, -9.836586939929288236e-188), 2), infsup (0.000000000000000000e+00, 8.340882161144170744e-263))); %!test %! assert (isequal (pown (infsup (-8.631384205445317548e+01, -2.269091389186822222e-289), 2), infsup (0.000000000000000000e+00, 7.450079330201089761e+03))); %! assert (isequal (infsup (-8.631384205445317548e+01, -2.269091389186822222e-289) .^ 2, infsup (0.000000000000000000e+00, 7.450079330201089761e+03))); %! assert (isequal (power (infsup (-8.631384205445317548e+01, -2.269091389186822222e-289), 2), infsup (0.000000000000000000e+00, 7.450079330201089761e+03))); %! assert (isequal (infsup (-8.631384205445317548e+01, -2.269091389186822222e-289) ^ 2, infsup (0.000000000000000000e+00, 7.450079330201089761e+03))); %! assert (isequal (mpower (infsup (-8.631384205445317548e+01, -2.269091389186822222e-289), 2), infsup (0.000000000000000000e+00, 7.450079330201089761e+03))); %!test %! assert (isequal (pown (infsup (-1.654017949299359065e-112, 1.159376035639006975e-176), 2), infsup (0.000000000000000000e+00, 2.735775376604457287e-224))); %! assert (isequal (infsup (-1.654017949299359065e-112, 1.159376035639006975e-176) .^ 2, infsup (0.000000000000000000e+00, 2.735775376604457287e-224))); %! assert (isequal (power (infsup (-1.654017949299359065e-112, 1.159376035639006975e-176), 2), infsup (0.000000000000000000e+00, 2.735775376604457287e-224))); %! assert (isequal (infsup (-1.654017949299359065e-112, 1.159376035639006975e-176) ^ 2, infsup (0.000000000000000000e+00, 2.735775376604457287e-224))); %! assert (isequal (mpower (infsup (-1.654017949299359065e-112, 1.159376035639006975e-176), 2), infsup (0.000000000000000000e+00, 2.735775376604457287e-224))); %!test %! assert (isequal (pown (infsup (-2.261578927830210317e-107, -2.921845682025291002e-170), 2), infsup (0.000000000000000000e+00, 5.114739246805643826e-214))); %! assert (isequal (infsup (-2.261578927830210317e-107, -2.921845682025291002e-170) .^ 2, infsup (0.000000000000000000e+00, 5.114739246805643826e-214))); %! assert (isequal (power (infsup (-2.261578927830210317e-107, -2.921845682025291002e-170), 2), infsup (0.000000000000000000e+00, 5.114739246805643826e-214))); %! assert (isequal (infsup (-2.261578927830210317e-107, -2.921845682025291002e-170) ^ 2, infsup (0.000000000000000000e+00, 5.114739246805643826e-214))); %! assert (isequal (mpower (infsup (-2.261578927830210317e-107, -2.921845682025291002e-170), 2), infsup (0.000000000000000000e+00, 5.114739246805643826e-214))); %!test %! assert (isequal (pown (infsup (-1.469458391712281360e-99, -1.976254011990074054e-124), 2), infsup (3.905579919906863034e-248, 2.159307964973644752e-198))); %! assert (isequal (infsup (-1.469458391712281360e-99, -1.976254011990074054e-124) .^ 2, infsup (3.905579919906863034e-248, 2.159307964973644752e-198))); %! assert (isequal (power (infsup (-1.469458391712281360e-99, -1.976254011990074054e-124), 2), infsup (3.905579919906863034e-248, 2.159307964973644752e-198))); %! assert (isequal (infsup (-1.469458391712281360e-99, -1.976254011990074054e-124) ^ 2, infsup (3.905579919906863034e-248, 2.159307964973644752e-198))); %! assert (isequal (mpower (infsup (-1.469458391712281360e-99, -1.976254011990074054e-124), 2), infsup (3.905579919906863034e-248, 2.159307964973644752e-198))); %!test %! assert (isequal (pown (infsup (-1.088588131986426258e-12, -3.239993862505298994e-238), 2), infsup (0.000000000000000000e+00, 1.185024121101697110e-24))); %! assert (isequal (infsup (-1.088588131986426258e-12, -3.239993862505298994e-238) .^ 2, infsup (0.000000000000000000e+00, 1.185024121101697110e-24))); %! assert (isequal (power (infsup (-1.088588131986426258e-12, -3.239993862505298994e-238), 2), infsup (0.000000000000000000e+00, 1.185024121101697110e-24))); %! assert (isequal (infsup (-1.088588131986426258e-12, -3.239993862505298994e-238) ^ 2, infsup (0.000000000000000000e+00, 1.185024121101697110e-24))); %! assert (isequal (mpower (infsup (-1.088588131986426258e-12, -3.239993862505298994e-238), 2), infsup (0.000000000000000000e+00, 1.185024121101697110e-24))); %!test %! assert (isequal (pown (infsup (-3.114600191344484305e-60, -1.151057432815240852e-61), 2), infsup (1.324933213639212643e-122, 9.700734351923098806e-120))); %! assert (isequal (infsup (-3.114600191344484305e-60, -1.151057432815240852e-61) .^ 2, infsup (1.324933213639212643e-122, 9.700734351923098806e-120))); %! assert (isequal (power (infsup (-3.114600191344484305e-60, -1.151057432815240852e-61), 2), infsup (1.324933213639212643e-122, 9.700734351923098806e-120))); %! assert (isequal (infsup (-3.114600191344484305e-60, -1.151057432815240852e-61) ^ 2, infsup (1.324933213639212643e-122, 9.700734351923098806e-120))); %! assert (isequal (mpower (infsup (-3.114600191344484305e-60, -1.151057432815240852e-61), 2), infsup (1.324933213639212643e-122, 9.700734351923098806e-120))); %!test %! assert (isequal (pown (infsup (3.215755734598088570e-80, 2.860247434645490115e-24), 2), infsup (1.034108494460049166e-159, 8.181015387396108212e-48))); %! assert (isequal (infsup (3.215755734598088570e-80, 2.860247434645490115e-24) .^ 2, infsup (1.034108494460049166e-159, 8.181015387396108212e-48))); %! assert (isequal (power (infsup (3.215755734598088570e-80, 2.860247434645490115e-24), 2), infsup (1.034108494460049166e-159, 8.181015387396108212e-48))); %! assert (isequal (infsup (3.215755734598088570e-80, 2.860247434645490115e-24) ^ 2, infsup (1.034108494460049166e-159, 8.181015387396108212e-48))); %! assert (isequal (mpower (infsup (3.215755734598088570e-80, 2.860247434645490115e-24), 2), infsup (1.034108494460049166e-159, 8.181015387396108212e-48))); %!test %! assert (isequal (pown (infsup (-7.599545156767026148e-113, -3.620806299549831939e-276), 2), infsup (0.000000000000000000e+00, 5.775308658974116928e-225))); %! assert (isequal (infsup (-7.599545156767026148e-113, -3.620806299549831939e-276) .^ 2, infsup (0.000000000000000000e+00, 5.775308658974116928e-225))); %! assert (isequal (power (infsup (-7.599545156767026148e-113, -3.620806299549831939e-276), 2), infsup (0.000000000000000000e+00, 5.775308658974116928e-225))); %! assert (isequal (infsup (-7.599545156767026148e-113, -3.620806299549831939e-276) ^ 2, infsup (0.000000000000000000e+00, 5.775308658974116928e-225))); %! assert (isequal (mpower (infsup (-7.599545156767026148e-113, -3.620806299549831939e-276), 2), infsup (0.000000000000000000e+00, 5.775308658974116928e-225))); %!test %! assert (isequal (pown (infsup (-8.378054792460110690e-178, 2.171929406448802147e-04), 2), infsup (0.000000000000000000e+00, 4.717277346597046512e-08))); %! assert (isequal (infsup (-8.378054792460110690e-178, 2.171929406448802147e-04) .^ 2, infsup (0.000000000000000000e+00, 4.717277346597046512e-08))); %! assert (isequal (power (infsup (-8.378054792460110690e-178, 2.171929406448802147e-04), 2), infsup (0.000000000000000000e+00, 4.717277346597046512e-08))); %! assert (isequal (infsup (-8.378054792460110690e-178, 2.171929406448802147e-04) ^ 2, infsup (0.000000000000000000e+00, 4.717277346597046512e-08))); %! assert (isequal (mpower (infsup (-8.378054792460110690e-178, 2.171929406448802147e-04), 2), infsup (0.000000000000000000e+00, 4.717277346597046512e-08))); %!test %! assert (isequal (pown (infsup (-6.977305240208117095e-101, -5.652987073406890307e-174), 2), infsup (0.000000000000000000e+00, 4.868278841503565141e-201))); %! assert (isequal (infsup (-6.977305240208117095e-101, -5.652987073406890307e-174) .^ 2, infsup (0.000000000000000000e+00, 4.868278841503565141e-201))); %! assert (isequal (power (infsup (-6.977305240208117095e-101, -5.652987073406890307e-174), 2), infsup (0.000000000000000000e+00, 4.868278841503565141e-201))); %! assert (isequal (infsup (-6.977305240208117095e-101, -5.652987073406890307e-174) ^ 2, infsup (0.000000000000000000e+00, 4.868278841503565141e-201))); %! assert (isequal (mpower (infsup (-6.977305240208117095e-101, -5.652987073406890307e-174), 2), infsup (0.000000000000000000e+00, 4.868278841503565141e-201))); %!test %! assert (isequal (pown (infsup (-5.464129729164141708e-282, 9.669182275976748412e-117), 2), infsup (0.000000000000000000e+00, 9.349308588606289563e-233))); %! assert (isequal (infsup (-5.464129729164141708e-282, 9.669182275976748412e-117) .^ 2, infsup (0.000000000000000000e+00, 9.349308588606289563e-233))); %! assert (isequal (power (infsup (-5.464129729164141708e-282, 9.669182275976748412e-117), 2), infsup (0.000000000000000000e+00, 9.349308588606289563e-233))); %! assert (isequal (infsup (-5.464129729164141708e-282, 9.669182275976748412e-117) ^ 2, infsup (0.000000000000000000e+00, 9.349308588606289563e-233))); %! assert (isequal (mpower (infsup (-5.464129729164141708e-282, 9.669182275976748412e-117), 2), infsup (0.000000000000000000e+00, 9.349308588606289563e-233))); %!test %! assert (isequal (pown (infsup (-2.609094333453398954e-148, 5.011306988287881225e-06), 2), infsup (0.000000000000000000e+00, 2.511319773086295719e-11))); %! assert (isequal (infsup (-2.609094333453398954e-148, 5.011306988287881225e-06) .^ 2, infsup (0.000000000000000000e+00, 2.511319773086295719e-11))); %! assert (isequal (power (infsup (-2.609094333453398954e-148, 5.011306988287881225e-06), 2), infsup (0.000000000000000000e+00, 2.511319773086295719e-11))); %! assert (isequal (infsup (-2.609094333453398954e-148, 5.011306988287881225e-06) ^ 2, infsup (0.000000000000000000e+00, 2.511319773086295719e-11))); %! assert (isequal (mpower (infsup (-2.609094333453398954e-148, 5.011306988287881225e-06), 2), infsup (0.000000000000000000e+00, 2.511319773086295719e-11))); %!test %! assert (isequal (pown (infsup (-2.520164184091732485e-91, -6.923225182185906259e-252), 2), infsup (0.000000000000000000e+00, 6.351227514778747876e-182))); %! assert (isequal (infsup (-2.520164184091732485e-91, -6.923225182185906259e-252) .^ 2, infsup (0.000000000000000000e+00, 6.351227514778747876e-182))); %! assert (isequal (power (infsup (-2.520164184091732485e-91, -6.923225182185906259e-252), 2), infsup (0.000000000000000000e+00, 6.351227514778747876e-182))); %! assert (isequal (infsup (-2.520164184091732485e-91, -6.923225182185906259e-252) ^ 2, infsup (0.000000000000000000e+00, 6.351227514778747876e-182))); %! assert (isequal (mpower (infsup (-2.520164184091732485e-91, -6.923225182185906259e-252), 2), infsup (0.000000000000000000e+00, 6.351227514778747876e-182))); %!test %! assert (isequal (pown (infsup (-2.058411222963202619e-150, -1.691080271454051769e-229), 2), infsup (0.000000000000000000e+00, 4.237056762820867958e-300))); %! assert (isequal (infsup (-2.058411222963202619e-150, -1.691080271454051769e-229) .^ 2, infsup (0.000000000000000000e+00, 4.237056762820867958e-300))); %! assert (isequal (power (infsup (-2.058411222963202619e-150, -1.691080271454051769e-229), 2), infsup (0.000000000000000000e+00, 4.237056762820867958e-300))); %! assert (isequal (infsup (-2.058411222963202619e-150, -1.691080271454051769e-229) ^ 2, infsup (0.000000000000000000e+00, 4.237056762820867958e-300))); %! assert (isequal (mpower (infsup (-2.058411222963202619e-150, -1.691080271454051769e-229), 2), infsup (0.000000000000000000e+00, 4.237056762820867958e-300))); %!test %! assert (isequal (pown (infsup (-1.194912260770650641e-171, -3.063641562993914407e-235), 2), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %! assert (isequal (infsup (-1.194912260770650641e-171, -3.063641562993914407e-235) .^ 2, infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %! assert (isequal (power (infsup (-1.194912260770650641e-171, -3.063641562993914407e-235), 2), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %! assert (isequal (infsup (-1.194912260770650641e-171, -3.063641562993914407e-235) ^ 2, infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %! assert (isequal (mpower (infsup (-1.194912260770650641e-171, -3.063641562993914407e-235), 2), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %!test %! assert (isequal (pown (infsup (-1.410213021759318257e-164, 2.113307206456483530e-235), 2), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %! assert (isequal (infsup (-1.410213021759318257e-164, 2.113307206456483530e-235) .^ 2, infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %! assert (isequal (power (infsup (-1.410213021759318257e-164, 2.113307206456483530e-235), 2), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %! assert (isequal (infsup (-1.410213021759318257e-164, 2.113307206456483530e-235) ^ 2, infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %! assert (isequal (mpower (infsup (-1.410213021759318257e-164, 2.113307206456483530e-235), 2), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %!test %! assert (isequal (pown (infsup (-2.734402476279937437e-15, 2.214286456252711975e-200), 2), infsup (0.000000000000000000e+00, 7.476956902285853824e-30))); %! assert (isequal (infsup (-2.734402476279937437e-15, 2.214286456252711975e-200) .^ 2, infsup (0.000000000000000000e+00, 7.476956902285853824e-30))); %! assert (isequal (power (infsup (-2.734402476279937437e-15, 2.214286456252711975e-200), 2), infsup (0.000000000000000000e+00, 7.476956902285853824e-30))); %! assert (isequal (infsup (-2.734402476279937437e-15, 2.214286456252711975e-200) ^ 2, infsup (0.000000000000000000e+00, 7.476956902285853824e-30))); %! assert (isequal (mpower (infsup (-2.734402476279937437e-15, 2.214286456252711975e-200), 2), infsup (0.000000000000000000e+00, 7.476956902285853824e-30))); %!test %! assert (isequal (pown (infsup (-4.736813689297963792e-37, -3.757820326147841254e-165), 2), infsup (0.000000000000000000e+00, 2.243740392712058757e-73))); %! assert (isequal (infsup (-4.736813689297963792e-37, -3.757820326147841254e-165) .^ 2, infsup (0.000000000000000000e+00, 2.243740392712058757e-73))); %! assert (isequal (power (infsup (-4.736813689297963792e-37, -3.757820326147841254e-165), 2), infsup (0.000000000000000000e+00, 2.243740392712058757e-73))); %! assert (isequal (infsup (-4.736813689297963792e-37, -3.757820326147841254e-165) ^ 2, infsup (0.000000000000000000e+00, 2.243740392712058757e-73))); %! assert (isequal (mpower (infsup (-4.736813689297963792e-37, -3.757820326147841254e-165), 2), infsup (0.000000000000000000e+00, 2.243740392712058757e-73))); %!test %! assert (isequal (pown (infsup (-1.178872317111653867e-269, -3.697079530478824433e-304), 2), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %! assert (isequal (infsup (-1.178872317111653867e-269, -3.697079530478824433e-304) .^ 2, infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %! assert (isequal (power (infsup (-1.178872317111653867e-269, -3.697079530478824433e-304), 2), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %! assert (isequal (infsup (-1.178872317111653867e-269, -3.697079530478824433e-304) ^ 2, infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %! assert (isequal (mpower (infsup (-1.178872317111653867e-269, -3.697079530478824433e-304), 2), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %!test %! assert (isequal (pown (infsup (-3.170977600535302060e-50, 1.773732353250808790e-223), 2), infsup (0.000000000000000000e+00, 1.005509894309662304e-99))); %! assert (isequal (infsup (-3.170977600535302060e-50, 1.773732353250808790e-223) .^ 2, infsup (0.000000000000000000e+00, 1.005509894309662304e-99))); %! assert (isequal (power (infsup (-3.170977600535302060e-50, 1.773732353250808790e-223), 2), infsup (0.000000000000000000e+00, 1.005509894309662304e-99))); %! assert (isequal (infsup (-3.170977600535302060e-50, 1.773732353250808790e-223) ^ 2, infsup (0.000000000000000000e+00, 1.005509894309662304e-99))); %! assert (isequal (mpower (infsup (-3.170977600535302060e-50, 1.773732353250808790e-223), 2), infsup (0.000000000000000000e+00, 1.005509894309662304e-99))); %!test %! assert (isequal (pown (infsup (-9.582715182984806788e-234, -6.481946913158783102e-280), 2), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %! assert (isequal (infsup (-9.582715182984806788e-234, -6.481946913158783102e-280) .^ 2, infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %! assert (isequal (power (infsup (-9.582715182984806788e-234, -6.481946913158783102e-280), 2), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %! assert (isequal (infsup (-9.582715182984806788e-234, -6.481946913158783102e-280) ^ 2, infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %! assert (isequal (mpower (infsup (-9.582715182984806788e-234, -6.481946913158783102e-280), 2), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %!test %! assert (isequal (pown (infsup (1.510030059283921314e-212, 1.357381528725581723e-08), 2), infsup (0.000000000000000000e+00, 1.842484614525397339e-16))); %! assert (isequal (infsup (1.510030059283921314e-212, 1.357381528725581723e-08) .^ 2, infsup (0.000000000000000000e+00, 1.842484614525397339e-16))); %! assert (isequal (power (infsup (1.510030059283921314e-212, 1.357381528725581723e-08), 2), infsup (0.000000000000000000e+00, 1.842484614525397339e-16))); %! assert (isequal (infsup (1.510030059283921314e-212, 1.357381528725581723e-08) ^ 2, infsup (0.000000000000000000e+00, 1.842484614525397339e-16))); %! assert (isequal (mpower (infsup (1.510030059283921314e-212, 1.357381528725581723e-08), 2), infsup (0.000000000000000000e+00, 1.842484614525397339e-16))); %!test %! assert (isequal (pown (infsup (-1.323507196051687166e-113, 8.782017701712098963e-233), 2), infsup (0.000000000000000000e+00, 1.751671298000599397e-226))); %! assert (isequal (infsup (-1.323507196051687166e-113, 8.782017701712098963e-233) .^ 2, infsup (0.000000000000000000e+00, 1.751671298000599397e-226))); %! assert (isequal (power (infsup (-1.323507196051687166e-113, 8.782017701712098963e-233), 2), infsup (0.000000000000000000e+00, 1.751671298000599397e-226))); %! assert (isequal (infsup (-1.323507196051687166e-113, 8.782017701712098963e-233) ^ 2, infsup (0.000000000000000000e+00, 1.751671298000599397e-226))); %! assert (isequal (mpower (infsup (-1.323507196051687166e-113, 8.782017701712098963e-233), 2), infsup (0.000000000000000000e+00, 1.751671298000599397e-226))); %!test %! assert (isequal (pown (infsup (-7.715995104235895070e-26, -1.871718785128404206e-162), 2), infsup (0.000000000000000000e+00, 5.953658044859230885e-51))); %! assert (isequal (infsup (-7.715995104235895070e-26, -1.871718785128404206e-162) .^ 2, infsup (0.000000000000000000e+00, 5.953658044859230885e-51))); %! assert (isequal (power (infsup (-7.715995104235895070e-26, -1.871718785128404206e-162), 2), infsup (0.000000000000000000e+00, 5.953658044859230885e-51))); %! assert (isequal (infsup (-7.715995104235895070e-26, -1.871718785128404206e-162) ^ 2, infsup (0.000000000000000000e+00, 5.953658044859230885e-51))); %! assert (isequal (mpower (infsup (-7.715995104235895070e-26, -1.871718785128404206e-162), 2), infsup (0.000000000000000000e+00, 5.953658044859230885e-51))); %!test %! assert (isequal (pown (infsup (-3.395185885371617857e-83, -1.892322506995032646e-149), 2), infsup (3.580884470479965241e-298, 1.152728719622665870e-165))); %! assert (isequal (infsup (-3.395185885371617857e-83, -1.892322506995032646e-149) .^ 2, infsup (3.580884470479965241e-298, 1.152728719622665870e-165))); %! assert (isequal (power (infsup (-3.395185885371617857e-83, -1.892322506995032646e-149), 2), infsup (3.580884470479965241e-298, 1.152728719622665870e-165))); %! assert (isequal (infsup (-3.395185885371617857e-83, -1.892322506995032646e-149) ^ 2, infsup (3.580884470479965241e-298, 1.152728719622665870e-165))); %! assert (isequal (mpower (infsup (-3.395185885371617857e-83, -1.892322506995032646e-149), 2), infsup (3.580884470479965241e-298, 1.152728719622665870e-165))); %!test %! assert (isequal (pown (infsup (-1.449285613317172764e-98, -5.707789272110613126e-264), 2), infsup (0.000000000000000000e+00, 2.100428788968133734e-196))); %! assert (isequal (infsup (-1.449285613317172764e-98, -5.707789272110613126e-264) .^ 2, infsup (0.000000000000000000e+00, 2.100428788968133734e-196))); %! assert (isequal (power (infsup (-1.449285613317172764e-98, -5.707789272110613126e-264), 2), infsup (0.000000000000000000e+00, 2.100428788968133734e-196))); %! assert (isequal (infsup (-1.449285613317172764e-98, -5.707789272110613126e-264) ^ 2, infsup (0.000000000000000000e+00, 2.100428788968133734e-196))); %! assert (isequal (mpower (infsup (-1.449285613317172764e-98, -5.707789272110613126e-264), 2), infsup (0.000000000000000000e+00, 2.100428788968133734e-196))); %!test %! assert (isequal (pown (infsup (-1.045711771041448932e-76, 2.500374714085601101e-183), 2), infsup (0.000000000000000000e+00, 1.093513108094643860e-152))); %! assert (isequal (infsup (-1.045711771041448932e-76, 2.500374714085601101e-183) .^ 2, infsup (0.000000000000000000e+00, 1.093513108094643860e-152))); %! assert (isequal (power (infsup (-1.045711771041448932e-76, 2.500374714085601101e-183), 2), infsup (0.000000000000000000e+00, 1.093513108094643860e-152))); %! assert (isequal (infsup (-1.045711771041448932e-76, 2.500374714085601101e-183) ^ 2, infsup (0.000000000000000000e+00, 1.093513108094643860e-152))); %! assert (isequal (mpower (infsup (-1.045711771041448932e-76, 2.500374714085601101e-183), 2), infsup (0.000000000000000000e+00, 1.093513108094643860e-152))); %!test %! assert (isequal (pown (infsup (-1.069106323474023944e-70, -1.300019611184126890e-129), 2), infsup (1.690050989463328240e-258, 1.142988330892144404e-140))); %! assert (isequal (infsup (-1.069106323474023944e-70, -1.300019611184126890e-129) .^ 2, infsup (1.690050989463328240e-258, 1.142988330892144404e-140))); %! assert (isequal (power (infsup (-1.069106323474023944e-70, -1.300019611184126890e-129), 2), infsup (1.690050989463328240e-258, 1.142988330892144404e-140))); %! assert (isequal (infsup (-1.069106323474023944e-70, -1.300019611184126890e-129) ^ 2, infsup (1.690050989463328240e-258, 1.142988330892144404e-140))); %! assert (isequal (mpower (infsup (-1.069106323474023944e-70, -1.300019611184126890e-129), 2), infsup (1.690050989463328240e-258, 1.142988330892144404e-140))); interval-1.4.1/inst/test/libieeep1788_tests_elem.tst0000644000175000017500000213242212657476055021774 0ustar oliveroliver## DO NOT EDIT! Generated automatically from test/libieeep1788_tests_elem.itl ## by the Interval Testing Framework for IEEE 1788. ## https://github.com/nehmeier/ITF1788/tree/635bff73cc64ff8aab0ff2031ee8a53980be0115 ## ## Copyright 2013-2015 Marco Nehmeier (nehmeier@informatik.uni-wuerzburg.de) ## Copyright 2015-2016 Oliver Heimlich ## ## Original author: Marco Nehmeier (unit tests in libieeep1788, ## original license: Apache License 2.0) ## Converted into portable ITL format by Oliver Heimlich with minor corrections. ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## %!#Test library imports %!#Arithmetic library imports pkg load interval %!#Preamble try; error ("__FILE__"); catch test (lasterror.stack.file, "quiet", stdout); end_try_catch; %!function assert_warn (observed_value, expected_value) %! if (not (isequal (observed_value, expected_value))) %! observed_expression = regexprep (argn(1, :), '\s+$', ''); %! expected_expression = regexprep (argn(2, :), '\s+$', ''); %! observed_as_char = disp (observed_value)(1 : end - 1); %! expected_as_char = disp(expected_value)(1 : end - 1); %! warning ([observed_expression, " != ", expected_expression, ... %! "\n ", observed_as_char, " != ", expected_as_char]); %! endif %!endfunction ## minimal_pos_test %!test %! assert (isequal (+infsup (1.0, 2.0), infsup (1.0, 2.0))); %! assert (isequal (uplus (infsup (1.0, 2.0)), infsup (1.0, 2.0))); %!test %! assert (isequal (+infsup, infsup)); %! assert (isequal (uplus (infsup), infsup)); %!test %! assert (isequal (+infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (uplus (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (+infsup (1.0, inf), infsup (1.0, inf))); %! assert (isequal (uplus (infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (+infsup (-inf, -1.0), infsup (-inf, -1.0))); %! assert (isequal (uplus (infsup (-inf, -1.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (+infsup (0.0, 2.0), infsup (0.0, 2.0))); %! assert (isequal (uplus (infsup (0.0, 2.0)), infsup (0.0, 2.0))); %!test %! assert (isequal (+infsup (-0.0, 2.0), infsup (0.0, 2.0))); %! assert (isequal (uplus (infsup (-0.0, 2.0)), infsup (0.0, 2.0))); %!test %! assert (isequal (+infsup (-2.5, -0.0), infsup (-2.5, 0.0))); %! assert (isequal (uplus (infsup (-2.5, -0.0)), infsup (-2.5, 0.0))); %!test %! assert (isequal (+infsup (-2.5, 0.0), infsup (-2.5, 0.0))); %! assert (isequal (uplus (infsup (-2.5, 0.0)), infsup (-2.5, 0.0))); %!test %! assert (isequal (+infsup (-0.0, -0.0), infsup (0.0, 0.0))); %! assert (isequal (uplus (infsup (-0.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (+infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (uplus (infsup (0.0, 0.0)), infsup (0.0, 0.0))); ## minimal_pos_dec_test %!test %! assert (isequal (+infsupdec (empty, "trv"), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (+infsupdec (empty, "trv")){1}, decorationpart (infsupdec (empty, "trv")){1})); %! assert (isequal (uplus (infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (uplus (infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (+infsupdec (entire, "def"), infsupdec (entire, "def"))); %! assert (isequal (decorationpart (+infsupdec (entire, "def")){1}, decorationpart (infsupdec (entire, "def")){1})); %! assert (isequal (uplus (infsupdec (entire, "def")), infsupdec (entire, "def"))); %! assert (isequal (decorationpart (uplus (infsupdec (entire, "def"))){1}, decorationpart (infsupdec (entire, "def")){1})); %!test %! assert (isequal (+infsupdec (1.0, 2.0, "com"), infsupdec (1.0, 2.0, "com"))); %! assert (isequal (decorationpart (+infsupdec (1.0, 2.0, "com")){1}, decorationpart (infsupdec (1.0, 2.0, "com")){1})); %! assert (isequal (uplus (infsupdec (1.0, 2.0, "com")), infsupdec (1.0, 2.0, "com"))); %! assert (isequal (decorationpart (uplus (infsupdec (1.0, 2.0, "com"))){1}, decorationpart (infsupdec (1.0, 2.0, "com")){1})); ## minimal_neg_test %!test %! assert (isequal (-infsup (1.0, 2.0), infsup (-2.0, -1.0))); %! assert (isequal (uminus (infsup (1.0, 2.0)), infsup (-2.0, -1.0))); %!test %! assert (isequal (-infsup, infsup)); %! assert (isequal (uminus (infsup), infsup)); %!test %! assert (isequal (-infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (uminus (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (-infsup (1.0, inf), infsup (-inf, -1.0))); %! assert (isequal (uminus (infsup (1.0, inf)), infsup (-inf, -1.0))); %!test %! assert (isequal (-infsup (-inf, 1.0), infsup (-1.0, inf))); %! assert (isequal (uminus (infsup (-inf, 1.0)), infsup (-1.0, inf))); %!test %! assert (isequal (-infsup (0.0, 2.0), infsup (-2.0, 0.0))); %! assert (isequal (uminus (infsup (0.0, 2.0)), infsup (-2.0, 0.0))); %!test %! assert (isequal (-infsup (-0.0, 2.0), infsup (-2.0, 0.0))); %! assert (isequal (uminus (infsup (-0.0, 2.0)), infsup (-2.0, 0.0))); %!test %! assert (isequal (-infsup (-2.0, 0.0), infsup (0.0, 2.0))); %! assert (isequal (uminus (infsup (-2.0, 0.0)), infsup (0.0, 2.0))); %!test %! assert (isequal (-infsup (-2.0, -0.0), infsup (0.0, 2.0))); %! assert (isequal (uminus (infsup (-2.0, -0.0)), infsup (0.0, 2.0))); %!test %! assert (isequal (-infsup (0.0, -0.0), infsup (0.0, 0.0))); %! assert (isequal (uminus (infsup (0.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (-infsup (-0.0, -0.0), infsup (0.0, 0.0))); %! assert (isequal (uminus (infsup (-0.0, -0.0)), infsup (0.0, 0.0))); ## minimal_neg_dec_test %!test %! assert (isequal (-infsupdec (empty, "trv"), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (-infsupdec (empty, "trv")){1}, decorationpart (infsupdec (empty, "trv")){1})); %! assert (isequal (uminus (infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (uminus (infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (-infsupdec (entire, "def"), infsupdec (entire, "def"))); %! assert (isequal (decorationpart (-infsupdec (entire, "def")){1}, decorationpart (infsupdec (entire, "def")){1})); %! assert (isequal (uminus (infsupdec (entire, "def")), infsupdec (entire, "def"))); %! assert (isequal (decorationpart (uminus (infsupdec (entire, "def"))){1}, decorationpart (infsupdec (entire, "def")){1})); %!test %! assert (isequal (-infsupdec (1.0, 2.0, "com"), infsupdec (-2.0, -1.0, "com"))); %! assert (isequal (decorationpart (-infsupdec (1.0, 2.0, "com")){1}, decorationpart (infsupdec (-2.0, -1.0, "com")){1})); %! assert (isequal (uminus (infsupdec (1.0, 2.0, "com")), infsupdec (-2.0, -1.0, "com"))); %! assert (isequal (decorationpart (uminus (infsupdec (1.0, 2.0, "com"))){1}, decorationpart (infsupdec (-2.0, -1.0, "com")){1})); ## minimal_add_test %!test %! assert (isequal (infsup + infsup, infsup)); %! assert (isequal (plus (infsup, infsup), infsup)); %!test %! assert (isequal (infsup (-1.0, 1.0) + infsup, infsup)); %! assert (isequal (plus (infsup (-1.0, 1.0), infsup), infsup)); %!test %! assert (isequal (infsup + infsup (-1.0, 1.0), infsup)); %! assert (isequal (plus (infsup, infsup (-1.0, 1.0)), infsup)); %!test %! assert (isequal (infsup + infsup (-inf, inf), infsup)); %! assert (isequal (plus (infsup, infsup (-inf, inf)), infsup)); %!test %! assert (isequal (infsup (-inf, inf) + infsup, infsup)); %! assert (isequal (plus (infsup (-inf, inf), infsup), infsup)); %!test %! assert (isequal (infsup (-inf, inf) + infsup (-inf, 1.0), infsup (-inf, inf))); %! assert (isequal (plus (infsup (-inf, inf), infsup (-inf, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) + infsup (-1.0, 1.0), infsup (-inf, inf))); %! assert (isequal (plus (infsup (-inf, inf), infsup (-1.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) + infsup (-1.0, inf), infsup (-inf, inf))); %! assert (isequal (plus (infsup (-inf, inf), infsup (-1.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) + infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (plus (infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 1.0) + infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (plus (infsup (-inf, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-1.0, 1.0) + infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (plus (infsup (-1.0, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-1.0, inf) + infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (plus (infsup (-1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 2.0) + infsup (-inf, 4.0), infsup (-inf, 6.0))); %! assert (isequal (plus (infsup (-inf, 2.0), infsup (-inf, 4.0)), infsup (-inf, 6.0))); %!test %! assert (isequal (infsup (-inf, 2.0) + infsup (3.0, 4.0), infsup (-inf, 6.0))); %! assert (isequal (plus (infsup (-inf, 2.0), infsup (3.0, 4.0)), infsup (-inf, 6.0))); %!test %! assert (isequal (infsup (-inf, 2.0) + infsup (3.0, inf), infsup (-inf, inf))); %! assert (isequal (plus (infsup (-inf, 2.0), infsup (3.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (1.0, 2.0) + infsup (-inf, 4.0), infsup (-inf, 6.0))); %! assert (isequal (plus (infsup (1.0, 2.0), infsup (-inf, 4.0)), infsup (-inf, 6.0))); %!test %! assert (isequal (infsup (1.0, 2.0) + infsup (3.0, 4.0), infsup (4.0, 6.0))); %! assert (isequal (plus (infsup (1.0, 2.0), infsup (3.0, 4.0)), infsup (4.0, 6.0))); %!test %! assert (isequal (infsup (1.0, 2.0) + infsup (3.0, inf), infsup (4.0, inf))); %! assert (isequal (plus (infsup (1.0, 2.0), infsup (3.0, inf)), infsup (4.0, inf))); %!test %! assert (isequal (infsup (1.0, inf) + infsup (-inf, 4.0), infsup (-inf, inf))); %! assert (isequal (plus (infsup (1.0, inf), infsup (-inf, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (1.0, inf) + infsup (3.0, 4.0), infsup (4.0, inf))); %! assert (isequal (plus (infsup (1.0, inf), infsup (3.0, 4.0)), infsup (4.0, inf))); %!test %! assert (isequal (infsup (1.0, inf) + infsup (3.0, inf), infsup (4.0, inf))); %! assert (isequal (plus (infsup (1.0, inf), infsup (3.0, inf)), infsup (4.0, inf))); %!test %! assert (isequal (infsup (1.0, 1.797693134862315708e+308) + infsup (3.0, 4.0), infsup (4.0, inf))); %! assert (isequal (plus (infsup (1.0, 1.797693134862315708e+308), infsup (3.0, 4.0)), infsup (4.0, inf))); %!test %! assert (isequal (infsup (-1.797693134862315708e+308, 2.0) + infsup (-3.0, 4.0), infsup (-inf, 6.0))); %! assert (isequal (plus (infsup (-1.797693134862315708e+308, 2.0), infsup (-3.0, 4.0)), infsup (-inf, 6.0))); %!test %! assert (isequal (infsup (-1.797693134862315708e+308, 2.0) + infsup (-3.0, 1.797693134862315708e+308), infsup (-inf, inf))); %! assert (isequal (plus (infsup (-1.797693134862315708e+308, 2.0), infsup (-3.0, 1.797693134862315708e+308)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (1.0, 1.797693134862315708e+308) + infsup (0.0, 0.0), infsup (1.0, 1.797693134862315708e+308))); %! assert (isequal (plus (infsup (1.0, 1.797693134862315708e+308), infsup (0.0, 0.0)), infsup (1.0, 1.797693134862315708e+308))); %!test %! assert (isequal (infsup (1.0, 1.797693134862315708e+308) + infsup (-0.0, -0.0), infsup (1.0, 1.797693134862315708e+308))); %! assert (isequal (plus (infsup (1.0, 1.797693134862315708e+308), infsup (-0.0, -0.0)), infsup (1.0, 1.797693134862315708e+308))); %!test %! assert (isequal (infsup (0.0, 0.0) + infsup (-3.0, 4.0), infsup (-3.0, 4.0))); %! assert (isequal (plus (infsup (0.0, 0.0), infsup (-3.0, 4.0)), infsup (-3.0, 4.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) + infsup (-3.0, 1.797693134862315708e+308), infsup (-3.0, 1.797693134862315708e+308))); %! assert (isequal (plus (infsup (-0.0, -0.0), infsup (-3.0, 1.797693134862315708e+308)), infsup (-3.0, 1.797693134862315708e+308))); %!test %! assert (isequal (infsup (1.999999999999996447e+00, 1.999999999999996447e+00) + infsup (1.000000000000000056e-01, 1.000000000000000056e-01), infsup (2.099999999999996092e+00, 2.099999999999996536e+00))); %! assert (isequal (plus (infsup (1.999999999999996447e+00, 1.999999999999996447e+00), infsup (1.000000000000000056e-01, 1.000000000000000056e-01)), infsup (2.099999999999996092e+00, 2.099999999999996536e+00))); %!test %! assert (isequal (infsup (1.999999999999996447e+00, 1.999999999999996447e+00) + infsup (-1.000000000000000056e-01, -1.000000000000000056e-01), infsup (1.899999999999996358e+00, 1.899999999999996581e+00))); %! assert (isequal (plus (infsup (1.999999999999996447e+00, 1.999999999999996447e+00), infsup (-1.000000000000000056e-01, -1.000000000000000056e-01)), infsup (1.899999999999996358e+00, 1.899999999999996581e+00))); %!test %! assert (isequal (infsup (-1.999999999999996447e+00, 1.999999999999996447e+00) + infsup (1.000000000000000056e-01, 1.000000000000000056e-01), infsup (-1.899999999999996581e+00, 2.099999999999996536e+00))); %! assert (isequal (plus (infsup (-1.999999999999996447e+00, 1.999999999999996447e+00), infsup (1.000000000000000056e-01, 1.000000000000000056e-01)), infsup (-1.899999999999996581e+00, 2.099999999999996536e+00))); ## minimal_add_dec_test %!test %! assert (isequal (infsupdec (1.0, 2.0, "com") + infsupdec (5.0, 7.0, "com"), infsupdec (6.0, 9.0, "com"))); %! assert (isequal (decorationpart (infsupdec (1.0, 2.0, "com") + infsupdec (5.0, 7.0, "com")){1}, decorationpart (infsupdec (6.0, 9.0, "com")){1})); %! assert (isequal (plus (infsupdec (1.0, 2.0, "com"), infsupdec (5.0, 7.0, "com")), infsupdec (6.0, 9.0, "com"))); %! assert (isequal (decorationpart (plus (infsupdec (1.0, 2.0, "com"), infsupdec (5.0, 7.0, "com"))){1}, decorationpart (infsupdec (6.0, 9.0, "com")){1})); %!test %! assert (isequal (infsupdec (1.0, 2.0, "com") + infsupdec (5.0, 7.0, "def"), infsupdec (6.0, 9.0, "def"))); %! assert (isequal (decorationpart (infsupdec (1.0, 2.0, "com") + infsupdec (5.0, 7.0, "def")){1}, decorationpart (infsupdec (6.0, 9.0, "def")){1})); %! assert (isequal (plus (infsupdec (1.0, 2.0, "com"), infsupdec (5.0, 7.0, "def")), infsupdec (6.0, 9.0, "def"))); %! assert (isequal (decorationpart (plus (infsupdec (1.0, 2.0, "com"), infsupdec (5.0, 7.0, "def"))){1}, decorationpart (infsupdec (6.0, 9.0, "def")){1})); %!test %! assert (isequal (infsupdec (1.0, 2.0, "com") + infsupdec (5.0, 1.797693134862315708e+308, "com"), infsupdec (6.0, inf, "dac"))); %! assert (isequal (decorationpart (infsupdec (1.0, 2.0, "com") + infsupdec (5.0, 1.797693134862315708e+308, "com")){1}, decorationpart (infsupdec (6.0, inf, "dac")){1})); %! assert (isequal (plus (infsupdec (1.0, 2.0, "com"), infsupdec (5.0, 1.797693134862315708e+308, "com")), infsupdec (6.0, inf, "dac"))); %! assert (isequal (decorationpart (plus (infsupdec (1.0, 2.0, "com"), infsupdec (5.0, 1.797693134862315708e+308, "com"))){1}, decorationpart (infsupdec (6.0, inf, "dac")){1})); %!test %! assert (isequal (infsupdec (-1.797693134862315708e+308, 2.0, "com") + infsupdec (-0.1, 5.0, "com"), infsupdec (-inf, 7.0, "dac"))); %! assert (isequal (decorationpart (infsupdec (-1.797693134862315708e+308, 2.0, "com") + infsupdec (-0.1, 5.0, "com")){1}, decorationpart (infsupdec (-inf, 7.0, "dac")){1})); %! assert (isequal (plus (infsupdec (-1.797693134862315708e+308, 2.0, "com"), infsupdec (-0.1, 5.0, "com")), infsupdec (-inf, 7.0, "dac"))); %! assert (isequal (decorationpart (plus (infsupdec (-1.797693134862315708e+308, 2.0, "com"), infsupdec (-0.1, 5.0, "com"))){1}, decorationpart (infsupdec (-inf, 7.0, "dac")){1})); %!test %! assert (isequal (infsupdec (1.0, 2.0, "trv") + infsupdec (empty, "trv"), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (infsupdec (1.0, 2.0, "trv") + infsupdec (empty, "trv")){1}, decorationpart (infsupdec (empty, "trv")){1})); %! assert (isequal (plus (infsupdec (1.0, 2.0, "trv"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (plus (infsupdec (1.0, 2.0, "trv"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); ## minimal_sub_test %!test %! assert (isequal (infsup - infsup, infsup)); %! assert (isequal (minus (infsup, infsup), infsup)); %!test %! assert (isequal (infsup (-1.0, 1.0) - infsup, infsup)); %! assert (isequal (minus (infsup (-1.0, 1.0), infsup), infsup)); %!test %! assert (isequal (infsup - infsup (-1.0, 1.0), infsup)); %! assert (isequal (minus (infsup, infsup (-1.0, 1.0)), infsup)); %!test %! assert (isequal (infsup - infsup (-inf, inf), infsup)); %! assert (isequal (minus (infsup, infsup (-inf, inf)), infsup)); %!test %! assert (isequal (infsup (-inf, inf) - infsup, infsup)); %! assert (isequal (minus (infsup (-inf, inf), infsup), infsup)); %!test %! assert (isequal (infsup (-inf, inf) - infsup (-inf, 1.0), infsup (-inf, inf))); %! assert (isequal (minus (infsup (-inf, inf), infsup (-inf, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) - infsup (-1.0, 1.0), infsup (-inf, inf))); %! assert (isequal (minus (infsup (-inf, inf), infsup (-1.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) - infsup (-1.0, inf), infsup (-inf, inf))); %! assert (isequal (minus (infsup (-inf, inf), infsup (-1.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) - infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (minus (infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 1.0) - infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (minus (infsup (-inf, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-1.0, 1.0) - infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (minus (infsup (-1.0, 1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-1.0, inf) - infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (minus (infsup (-1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 2.0) - infsup (-inf, 4.0), infsup (-inf, inf))); %! assert (isequal (minus (infsup (-inf, 2.0), infsup (-inf, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 2.0) - infsup (3.0, 4.0), infsup (-inf, -1.0))); %! assert (isequal (minus (infsup (-inf, 2.0), infsup (3.0, 4.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (infsup (-inf, 2.0) - infsup (3.0, inf), infsup (-inf, -1.0))); %! assert (isequal (minus (infsup (-inf, 2.0), infsup (3.0, inf)), infsup (-inf, -1.0))); %!test %! assert (isequal (infsup (1.0, 2.0) - infsup (-inf, 4.0), infsup (-3.0, inf))); %! assert (isequal (minus (infsup (1.0, 2.0), infsup (-inf, 4.0)), infsup (-3.0, inf))); %!test %! assert (isequal (infsup (1.0, 2.0) - infsup (3.0, 4.0), infsup (-3.0, -1.0))); %! assert (isequal (minus (infsup (1.0, 2.0), infsup (3.0, 4.0)), infsup (-3.0, -1.0))); %!test %! assert (isequal (infsup (1.0, 2.0) - infsup (3.0, inf), infsup (-inf, -1.0))); %! assert (isequal (minus (infsup (1.0, 2.0), infsup (3.0, inf)), infsup (-inf, -1.0))); %!test %! assert (isequal (infsup (1.0, inf) - infsup (-inf, 4.0), infsup (-3.0, inf))); %! assert (isequal (minus (infsup (1.0, inf), infsup (-inf, 4.0)), infsup (-3.0, inf))); %!test %! assert (isequal (infsup (1.0, inf) - infsup (3.0, 4.0), infsup (-3.0, inf))); %! assert (isequal (minus (infsup (1.0, inf), infsup (3.0, 4.0)), infsup (-3.0, inf))); %!test %! assert (isequal (infsup (1.0, inf) - infsup (3.0, inf), infsup (-inf, inf))); %! assert (isequal (minus (infsup (1.0, inf), infsup (3.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (1.0, 1.797693134862315708e+308) - infsup (-3.0, 4.0), infsup (-3.0, inf))); %! assert (isequal (minus (infsup (1.0, 1.797693134862315708e+308), infsup (-3.0, 4.0)), infsup (-3.0, inf))); %!test %! assert (isequal (infsup (-1.797693134862315708e+308, 2.0) - infsup (3.0, 4.0), infsup (-inf, -1.0))); %! assert (isequal (minus (infsup (-1.797693134862315708e+308, 2.0), infsup (3.0, 4.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (infsup (-1.797693134862315708e+308, 2.0) - infsup (-1.797693134862315708e+308, 4.0), infsup (-inf, inf))); %! assert (isequal (minus (infsup (-1.797693134862315708e+308, 2.0), infsup (-1.797693134862315708e+308, 4.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (1.0, 1.797693134862315708e+308) - infsup (0.0, 0.0), infsup (1.0, 1.797693134862315708e+308))); %! assert (isequal (minus (infsup (1.0, 1.797693134862315708e+308), infsup (0.0, 0.0)), infsup (1.0, 1.797693134862315708e+308))); %!test %! assert (isequal (infsup (1.0, 1.797693134862315708e+308) - infsup (-0.0, -0.0), infsup (1.0, 1.797693134862315708e+308))); %! assert (isequal (minus (infsup (1.0, 1.797693134862315708e+308), infsup (-0.0, -0.0)), infsup (1.0, 1.797693134862315708e+308))); %!test %! assert (isequal (infsup (0.0, 0.0) - infsup (-3.0, 4.0), infsup (-4.0, 3.0))); %! assert (isequal (minus (infsup (0.0, 0.0), infsup (-3.0, 4.0)), infsup (-4.0, 3.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) - infsup (-3.0, 1.797693134862315708e+308), infsup (-1.797693134862315708e+308, 3.0))); %! assert (isequal (minus (infsup (-0.0, -0.0), infsup (-3.0, 1.797693134862315708e+308)), infsup (-1.797693134862315708e+308, 3.0))); %!test %! assert (isequal (infsup (1.999999999999996447e+00, 1.999999999999996447e+00) - infsup (1.000000000000000056e-01, 1.000000000000000056e-01), infsup (1.899999999999996358e+00, 1.899999999999996581e+00))); %! assert (isequal (minus (infsup (1.999999999999996447e+00, 1.999999999999996447e+00), infsup (1.000000000000000056e-01, 1.000000000000000056e-01)), infsup (1.899999999999996358e+00, 1.899999999999996581e+00))); %!test %! assert (isequal (infsup (1.999999999999996447e+00, 1.999999999999996447e+00) - infsup (-1.000000000000000056e-01, -1.000000000000000056e-01), infsup (2.099999999999996092e+00, 2.099999999999996536e+00))); %! assert (isequal (minus (infsup (1.999999999999996447e+00, 1.999999999999996447e+00), infsup (-1.000000000000000056e-01, -1.000000000000000056e-01)), infsup (2.099999999999996092e+00, 2.099999999999996536e+00))); %!test %! assert (isequal (infsup (-1.999999999999996447e+00, 1.999999999999996447e+00) - infsup (1.000000000000000056e-01, 1.000000000000000056e-01), infsup (-2.099999999999996536e+00, 1.899999999999996581e+00))); %! assert (isequal (minus (infsup (-1.999999999999996447e+00, 1.999999999999996447e+00), infsup (1.000000000000000056e-01, 1.000000000000000056e-01)), infsup (-2.099999999999996536e+00, 1.899999999999996581e+00))); ## minimal_sub_dec_test %!test %! assert (isequal (infsupdec (1.0, 2.0, "com") - infsupdec (5.0, 7.0, "com"), infsupdec (-6.0, -3.0, "com"))); %! assert (isequal (decorationpart (infsupdec (1.0, 2.0, "com") - infsupdec (5.0, 7.0, "com")){1}, decorationpart (infsupdec (-6.0, -3.0, "com")){1})); %! assert (isequal (minus (infsupdec (1.0, 2.0, "com"), infsupdec (5.0, 7.0, "com")), infsupdec (-6.0, -3.0, "com"))); %! assert (isequal (decorationpart (minus (infsupdec (1.0, 2.0, "com"), infsupdec (5.0, 7.0, "com"))){1}, decorationpart (infsupdec (-6.0, -3.0, "com")){1})); %!test %! assert (isequal (infsupdec (1.0, 2.0, "com") - infsupdec (5.0, 7.0, "def"), infsupdec (-6.0, -3.0, "def"))); %! assert (isequal (decorationpart (infsupdec (1.0, 2.0, "com") - infsupdec (5.0, 7.0, "def")){1}, decorationpart (infsupdec (-6.0, -3.0, "def")){1})); %! assert (isequal (minus (infsupdec (1.0, 2.0, "com"), infsupdec (5.0, 7.0, "def")), infsupdec (-6.0, -3.0, "def"))); %! assert (isequal (decorationpart (minus (infsupdec (1.0, 2.0, "com"), infsupdec (5.0, 7.0, "def"))){1}, decorationpart (infsupdec (-6.0, -3.0, "def")){1})); %!test %! assert (isequal (infsupdec (-1.0, 2.0, "com") - infsupdec (5.0, 1.797693134862315708e+308, "com"), infsupdec (-inf, -3.0, "dac"))); %! assert (isequal (decorationpart (infsupdec (-1.0, 2.0, "com") - infsupdec (5.0, 1.797693134862315708e+308, "com")){1}, decorationpart (infsupdec (-inf, -3.0, "dac")){1})); %! assert (isequal (minus (infsupdec (-1.0, 2.0, "com"), infsupdec (5.0, 1.797693134862315708e+308, "com")), infsupdec (-inf, -3.0, "dac"))); %! assert (isequal (decorationpart (minus (infsupdec (-1.0, 2.0, "com"), infsupdec (5.0, 1.797693134862315708e+308, "com"))){1}, decorationpart (infsupdec (-inf, -3.0, "dac")){1})); %!test %! assert (isequal (infsupdec (-1.797693134862315708e+308, 2.0, "com") - infsupdec (-1.0, 5.0, "com"), infsupdec (-inf, 3.0, "dac"))); %! assert (isequal (decorationpart (infsupdec (-1.797693134862315708e+308, 2.0, "com") - infsupdec (-1.0, 5.0, "com")){1}, decorationpart (infsupdec (-inf, 3.0, "dac")){1})); %! assert (isequal (minus (infsupdec (-1.797693134862315708e+308, 2.0, "com"), infsupdec (-1.0, 5.0, "com")), infsupdec (-inf, 3.0, "dac"))); %! assert (isequal (decorationpart (minus (infsupdec (-1.797693134862315708e+308, 2.0, "com"), infsupdec (-1.0, 5.0, "com"))){1}, decorationpart (infsupdec (-inf, 3.0, "dac")){1})); %!test %! assert (isequal (infsupdec (1.0, 2.0, "trv") - infsupdec (empty, "trv"), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (infsupdec (1.0, 2.0, "trv") - infsupdec (empty, "trv")){1}, decorationpart (infsupdec (empty, "trv")){1})); %! assert (isequal (minus (infsupdec (1.0, 2.0, "trv"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (minus (infsupdec (1.0, 2.0, "trv"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); ## minimal_mul_test %!test %! assert (isequal (infsup .* infsup, infsup)); %! assert (isequal (times (infsup, infsup), infsup)); %!test %! assert (isequal (infsup (-1.0, 1.0) .* infsup, infsup)); %! assert (isequal (times (infsup (-1.0, 1.0), infsup), infsup)); %!test %! assert (isequal (infsup .* infsup (-1.0, 1.0), infsup)); %! assert (isequal (times (infsup, infsup (-1.0, 1.0)), infsup)); %!test %! assert (isequal (infsup .* infsup (-inf, inf), infsup)); %! assert (isequal (times (infsup, infsup (-inf, inf)), infsup)); %!test %! assert (isequal (infsup (-inf, inf) .* infsup, infsup)); %! assert (isequal (times (infsup (-inf, inf), infsup), infsup)); %!test %! assert (isequal (infsup (0.0, 0.0) .* infsup, infsup)); %! assert (isequal (times (infsup (0.0, 0.0), infsup), infsup)); %!test %! assert (isequal (infsup .* infsup (0.0, 0.0), infsup)); %! assert (isequal (times (infsup, infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (-0.0, -0.0) .* infsup, infsup)); %! assert (isequal (times (infsup (-0.0, -0.0), infsup), infsup)); %!test %! assert (isequal (infsup .* infsup (-0.0, -0.0), infsup)); %! assert (isequal (times (infsup, infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (infsup (-inf, inf) .* infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-inf, inf), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-inf, inf) .* infsup (-0.0, -0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-inf, inf), infsup (-0.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-inf, inf) .* infsup (-5.0, -1.0), infsup (-inf, inf))); %! assert (isequal (times (infsup (-inf, inf), infsup (-5.0, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) .* infsup (-5.0, 3.0), infsup (-inf, inf))); %! assert (isequal (times (infsup (-inf, inf), infsup (-5.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) .* infsup (1.0, 3.0), infsup (-inf, inf))); %! assert (isequal (times (infsup (-inf, inf), infsup (1.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) .* infsup (-inf, -1.0), infsup (-inf, inf))); %! assert (isequal (times (infsup (-inf, inf), infsup (-inf, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) .* infsup (-inf, 3.0), infsup (-inf, inf))); %! assert (isequal (times (infsup (-inf, inf), infsup (-inf, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) .* infsup (-5.0, inf), infsup (-inf, inf))); %! assert (isequal (times (infsup (-inf, inf), infsup (-5.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) .* infsup (1.0, inf), infsup (-inf, inf))); %! assert (isequal (times (infsup (-inf, inf), infsup (1.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) .* infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (times (infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (1.0, inf) .* infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (1.0, inf), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (1.0, inf) .* infsup (-0.0, -0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (1.0, inf), infsup (-0.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (1.0, inf) .* infsup (-5.0, -1.0), infsup (-inf, -1.0))); %! assert (isequal (times (infsup (1.0, inf), infsup (-5.0, -1.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (infsup (1.0, inf) .* infsup (-5.0, 3.0), infsup (-inf, inf))); %! assert (isequal (times (infsup (1.0, inf), infsup (-5.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (1.0, inf) .* infsup (1.0, 3.0), infsup (1.0, inf))); %! assert (isequal (times (infsup (1.0, inf), infsup (1.0, 3.0)), infsup (1.0, inf))); %!test %! assert (isequal (infsup (1.0, inf) .* infsup (-inf, -1.0), infsup (-inf, -1.0))); %! assert (isequal (times (infsup (1.0, inf), infsup (-inf, -1.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (infsup (1.0, inf) .* infsup (-inf, 3.0), infsup (-inf, inf))); %! assert (isequal (times (infsup (1.0, inf), infsup (-inf, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (1.0, inf) .* infsup (-5.0, inf), infsup (-inf, inf))); %! assert (isequal (times (infsup (1.0, inf), infsup (-5.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (1.0, inf) .* infsup (1.0, inf), infsup (1.0, inf))); %! assert (isequal (times (infsup (1.0, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (infsup (1.0, inf) .* infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (times (infsup (1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-1.0, inf) .* infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-1.0, inf), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-1.0, inf) .* infsup (-0.0, -0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-1.0, inf), infsup (-0.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-1.0, inf) .* infsup (-5.0, -1.0), infsup (-inf, 5.0))); %! assert (isequal (times (infsup (-1.0, inf), infsup (-5.0, -1.0)), infsup (-inf, 5.0))); %!test %! assert (isequal (infsup (-1.0, inf) .* infsup (-5.0, 3.0), infsup (-inf, inf))); %! assert (isequal (times (infsup (-1.0, inf), infsup (-5.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-1.0, inf) .* infsup (1.0, 3.0), infsup (-3.0, inf))); %! assert (isequal (times (infsup (-1.0, inf), infsup (1.0, 3.0)), infsup (-3.0, inf))); %!test %! assert (isequal (infsup (-1.0, inf) .* infsup (-inf, -1.0), infsup (-inf, inf))); %! assert (isequal (times (infsup (-1.0, inf), infsup (-inf, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-1.0, inf) .* infsup (-inf, 3.0), infsup (-inf, inf))); %! assert (isequal (times (infsup (-1.0, inf), infsup (-inf, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-1.0, inf) .* infsup (-5.0, inf), infsup (-inf, inf))); %! assert (isequal (times (infsup (-1.0, inf), infsup (-5.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-1.0, inf) .* infsup (1.0, inf), infsup (-inf, inf))); %! assert (isequal (times (infsup (-1.0, inf), infsup (1.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-1.0, inf) .* infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (times (infsup (-1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 3.0) .* infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-inf, 3.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-inf, 3.0) .* infsup (-0.0, -0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-inf, 3.0), infsup (-0.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-inf, 3.0) .* infsup (-5.0, -1.0), infsup (-15.0, inf))); %! assert (isequal (times (infsup (-inf, 3.0), infsup (-5.0, -1.0)), infsup (-15.0, inf))); %!test %! assert (isequal (infsup (-inf, 3.0) .* infsup (-5.0, 3.0), infsup (-inf, inf))); %! assert (isequal (times (infsup (-inf, 3.0), infsup (-5.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 3.0) .* infsup (1.0, 3.0), infsup (-inf, 9.0))); %! assert (isequal (times (infsup (-inf, 3.0), infsup (1.0, 3.0)), infsup (-inf, 9.0))); %!test %! assert (isequal (infsup (-inf, 3.0) .* infsup (-inf, -1.0), infsup (-inf, inf))); %! assert (isequal (times (infsup (-inf, 3.0), infsup (-inf, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 3.0) .* infsup (-inf, 3.0), infsup (-inf, inf))); %! assert (isequal (times (infsup (-inf, 3.0), infsup (-inf, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 3.0) .* infsup (-5.0, inf), infsup (-inf, inf))); %! assert (isequal (times (infsup (-inf, 3.0), infsup (-5.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 3.0) .* infsup (1.0, inf), infsup (-inf, inf))); %! assert (isequal (times (infsup (-inf, 3.0), infsup (1.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 3.0) .* infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (times (infsup (-inf, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, -3.0) .* infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-inf, -3.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-inf, -3.0) .* infsup (-0.0, -0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-inf, -3.0), infsup (-0.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-inf, -3.0) .* infsup (-5.0, -1.0), infsup (3.0, inf))); %! assert (isequal (times (infsup (-inf, -3.0), infsup (-5.0, -1.0)), infsup (3.0, inf))); %!test %! assert (isequal (infsup (-inf, -3.0) .* infsup (-5.0, 3.0), infsup (-inf, inf))); %! assert (isequal (times (infsup (-inf, -3.0), infsup (-5.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, -3.0) .* infsup (1.0, 3.0), infsup (-inf, -3.0))); %! assert (isequal (times (infsup (-inf, -3.0), infsup (1.0, 3.0)), infsup (-inf, -3.0))); %!test %! assert (isequal (infsup (-inf, -3.0) .* infsup (-inf, -1.0), infsup (3.0, inf))); %! assert (isequal (times (infsup (-inf, -3.0), infsup (-inf, -1.0)), infsup (3.0, inf))); %!test %! assert (isequal (infsup (-inf, -3.0) .* infsup (-inf, 3.0), infsup (-inf, inf))); %! assert (isequal (times (infsup (-inf, -3.0), infsup (-inf, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, -3.0) .* infsup (-5.0, inf), infsup (-inf, inf))); %! assert (isequal (times (infsup (-inf, -3.0), infsup (-5.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, -3.0) .* infsup (1.0, inf), infsup (-inf, -3.0))); %! assert (isequal (times (infsup (-inf, -3.0), infsup (1.0, inf)), infsup (-inf, -3.0))); %!test %! assert (isequal (infsup (-inf, -3.0) .* infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (times (infsup (-inf, -3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, 0.0) .* infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (0.0, 0.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) .* infsup (-0.0, -0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (0.0, 0.0), infsup (-0.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) .* infsup (-5.0, -1.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (0.0, 0.0), infsup (-5.0, -1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) .* infsup (-5.0, 3.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (0.0, 0.0), infsup (-5.0, 3.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) .* infsup (1.0, 3.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (0.0, 0.0), infsup (1.0, 3.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) .* infsup (-inf, -1.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (0.0, 0.0), infsup (-inf, -1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) .* infsup (-inf, 3.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (0.0, 0.0), infsup (-inf, 3.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) .* infsup (-5.0, inf), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (0.0, 0.0), infsup (-5.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) .* infsup (1.0, inf), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (0.0, 0.0), infsup (1.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) .* infsup (-inf, inf), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (0.0, 0.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) .* infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-0.0, -0.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) .* infsup (-0.0, -0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-0.0, -0.0), infsup (-0.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) .* infsup (-5.0, -1.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-0.0, -0.0), infsup (-5.0, -1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) .* infsup (-5.0, 3.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-0.0, -0.0), infsup (-5.0, 3.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) .* infsup (1.0, 3.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-0.0, -0.0), infsup (1.0, 3.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) .* infsup (-inf, -1.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-0.0, -0.0), infsup (-inf, -1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) .* infsup (-inf, 3.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-0.0, -0.0), infsup (-inf, 3.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) .* infsup (-5.0, inf), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-0.0, -0.0), infsup (-5.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) .* infsup (1.0, inf), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-0.0, -0.0), infsup (1.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) .* infsup (-inf, inf), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-0.0, -0.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (1.0, 5.0) .* infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (1.0, 5.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (1.0, 5.0) .* infsup (-0.0, -0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (1.0, 5.0), infsup (-0.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (1.0, 5.0) .* infsup (-5.0, -1.0), infsup (-25.0, -1.0))); %! assert (isequal (times (infsup (1.0, 5.0), infsup (-5.0, -1.0)), infsup (-25.0, -1.0))); %!test %! assert (isequal (infsup (1.0, 5.0) .* infsup (-5.0, 3.0), infsup (-25.0, 15.0))); %! assert (isequal (times (infsup (1.0, 5.0), infsup (-5.0, 3.0)), infsup (-25.0, 15.0))); %!test %! assert (isequal (infsup (1.0, 5.0) .* infsup (1.0, 3.0), infsup (1.0, 15.0))); %! assert (isequal (times (infsup (1.0, 5.0), infsup (1.0, 3.0)), infsup (1.0, 15.0))); %!test %! assert (isequal (infsup (1.0, 5.0) .* infsup (-inf, -1.0), infsup (-inf, -1.0))); %! assert (isequal (times (infsup (1.0, 5.0), infsup (-inf, -1.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (infsup (1.0, 5.0) .* infsup (-inf, 3.0), infsup (-inf, 15.0))); %! assert (isequal (times (infsup (1.0, 5.0), infsup (-inf, 3.0)), infsup (-inf, 15.0))); %!test %! assert (isequal (infsup (1.0, 5.0) .* infsup (-5.0, inf), infsup (-25.0, inf))); %! assert (isequal (times (infsup (1.0, 5.0), infsup (-5.0, inf)), infsup (-25.0, inf))); %!test %! assert (isequal (infsup (1.0, 5.0) .* infsup (1.0, inf), infsup (1.0, inf))); %! assert (isequal (times (infsup (1.0, 5.0), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (infsup (1.0, 5.0) .* infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (times (infsup (1.0, 5.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-1.0, 5.0) .* infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-1.0, 5.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-1.0, 5.0) .* infsup (-0.0, -0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-1.0, 5.0), infsup (-0.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-1.0, 5.0) .* infsup (-5.0, -1.0), infsup (-25.0, 5.0))); %! assert (isequal (times (infsup (-1.0, 5.0), infsup (-5.0, -1.0)), infsup (-25.0, 5.0))); %!#min max %!test %! assert (isequal (infsup (-1.0, 5.0) .* infsup (-5.0, 3.0), infsup (-25.0, 15.0))); %! assert (isequal (times (infsup (-1.0, 5.0), infsup (-5.0, 3.0)), infsup (-25.0, 15.0))); %!test %! assert (isequal (infsup (-10.0, 2.0) .* infsup (-5.0, 3.0), infsup (-30.0, 50.0))); %! assert (isequal (times (infsup (-10.0, 2.0), infsup (-5.0, 3.0)), infsup (-30.0, 50.0))); %!test %! assert (isequal (infsup (-1.0, 5.0) .* infsup (-1.0, 10.0), infsup (-10.0, 50.0))); %! assert (isequal (times (infsup (-1.0, 5.0), infsup (-1.0, 10.0)), infsup (-10.0, 50.0))); %!test %! assert (isequal (infsup (-2.0, 2.0) .* infsup (-5.0, 3.0), infsup (-10.0, 10.0))); %! assert (isequal (times (infsup (-2.0, 2.0), infsup (-5.0, 3.0)), infsup (-10.0, 10.0))); %!#end min max %!test %! assert (isequal (infsup (-1.0, 5.0) .* infsup (1.0, 3.0), infsup (-3.0, 15.0))); %! assert (isequal (times (infsup (-1.0, 5.0), infsup (1.0, 3.0)), infsup (-3.0, 15.0))); %!test %! assert (isequal (infsup (-1.0, 5.0) .* infsup (-inf, -1.0), infsup (-inf, inf))); %! assert (isequal (times (infsup (-1.0, 5.0), infsup (-inf, -1.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-1.0, 5.0) .* infsup (-inf, 3.0), infsup (-inf, inf))); %! assert (isequal (times (infsup (-1.0, 5.0), infsup (-inf, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-1.0, 5.0) .* infsup (-5.0, inf), infsup (-inf, inf))); %! assert (isequal (times (infsup (-1.0, 5.0), infsup (-5.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-1.0, 5.0) .* infsup (1.0, inf), infsup (-inf, inf))); %! assert (isequal (times (infsup (-1.0, 5.0), infsup (1.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-1.0, 5.0) .* infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (times (infsup (-1.0, 5.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-10.0, -5.0) .* infsup (0.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-10.0, -5.0), infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-10.0, -5.0) .* infsup (-0.0, -0.0), infsup (0.0, 0.0))); %! assert (isequal (times (infsup (-10.0, -5.0), infsup (-0.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-10.0, -5.0) .* infsup (-5.0, -1.0), infsup (5.0, 50.0))); %! assert (isequal (times (infsup (-10.0, -5.0), infsup (-5.0, -1.0)), infsup (5.0, 50.0))); %!test %! assert (isequal (infsup (-10.0, -5.0) .* infsup (-5.0, 3.0), infsup (-30.0, 50.0))); %! assert (isequal (times (infsup (-10.0, -5.0), infsup (-5.0, 3.0)), infsup (-30.0, 50.0))); %!test %! assert (isequal (infsup (-10.0, -5.0) .* infsup (1.0, 3.0), infsup (-30.0, -5.0))); %! assert (isequal (times (infsup (-10.0, -5.0), infsup (1.0, 3.0)), infsup (-30.0, -5.0))); %!test %! assert (isequal (infsup (-10.0, -5.0) .* infsup (-inf, -1.0), infsup (5.0, inf))); %! assert (isequal (times (infsup (-10.0, -5.0), infsup (-inf, -1.0)), infsup (5.0, inf))); %!test %! assert (isequal (infsup (-10.0, -5.0) .* infsup (-inf, 3.0), infsup (-30.0, inf))); %! assert (isequal (times (infsup (-10.0, -5.0), infsup (-inf, 3.0)), infsup (-30.0, inf))); %!test %! assert (isequal (infsup (-10.0, -5.0) .* infsup (-5.0, inf), infsup (-inf, 50.0))); %! assert (isequal (times (infsup (-10.0, -5.0), infsup (-5.0, inf)), infsup (-inf, 50.0))); %!test %! assert (isequal (infsup (-10.0, -5.0) .* infsup (1.0, inf), infsup (-inf, -5.0))); %! assert (isequal (times (infsup (-10.0, -5.0), infsup (1.0, inf)), infsup (-inf, -5.0))); %!test %! assert (isequal (infsup (-10.0, -5.0) .* infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (times (infsup (-10.0, -5.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (1.000000000000000056e-01, 1.999999999999996447e+00) .* infsup (-1.999999999999996447e+00, inf), infsup (-3.999999999999986233e+00, inf))); %! assert (isequal (times (infsup (1.000000000000000056e-01, 1.999999999999996447e+00), infsup (-1.999999999999996447e+00, inf)), infsup (-3.999999999999986233e+00, inf))); %!test %! assert (isequal (infsup (-1.000000000000000056e-01, 1.999999999999996447e+00) .* infsup (-1.999999999999996447e+00, -1.000000000000000056e-01), infsup (-3.999999999999986233e+00, 1.999999999999996780e-01))); %! assert (isequal (times (infsup (-1.000000000000000056e-01, 1.999999999999996447e+00), infsup (-1.999999999999996447e+00, -1.000000000000000056e-01)), infsup (-3.999999999999986233e+00, 1.999999999999996780e-01))); %!test %! assert (isequal (infsup (-1.000000000000000056e-01, 1.000000000000000056e-01) .* infsup (-1.999999999999996447e+00, 1.000000000000000056e-01), infsup (-1.999999999999996780e-01, 1.999999999999996780e-01))); %! assert (isequal (times (infsup (-1.000000000000000056e-01, 1.000000000000000056e-01), infsup (-1.999999999999996447e+00, 1.000000000000000056e-01)), infsup (-1.999999999999996780e-01, 1.999999999999996780e-01))); %!test %! assert (isequal (infsup (-1.999999999999996447e+00, -1.000000000000000056e-01) .* infsup (1.000000000000000056e-01, 1.999999999999996447e+00), infsup (-3.999999999999986233e+00, -1.000000000000000021e-02))); %! assert (isequal (times (infsup (-1.999999999999996447e+00, -1.000000000000000056e-01), infsup (1.000000000000000056e-01, 1.999999999999996447e+00)), infsup (-3.999999999999986233e+00, -1.000000000000000021e-02))); ## minimal_mul_dec_test %!test %! assert (isequal (infsupdec (1.0, 2.0, "com") .* infsupdec (5.0, 7.0, "com"), infsupdec (5.0, 14.0, "com"))); %! assert (isequal (decorationpart (infsupdec (1.0, 2.0, "com") .* infsupdec (5.0, 7.0, "com")){1}, decorationpart (infsupdec (5.0, 14.0, "com")){1})); %! assert (isequal (times (infsupdec (1.0, 2.0, "com"), infsupdec (5.0, 7.0, "com")), infsupdec (5.0, 14.0, "com"))); %! assert (isequal (decorationpart (times (infsupdec (1.0, 2.0, "com"), infsupdec (5.0, 7.0, "com"))){1}, decorationpart (infsupdec (5.0, 14.0, "com")){1})); %!test %! assert (isequal (infsupdec (1.0, 2.0, "com") .* infsupdec (5.0, 7.0, "def"), infsupdec (5.0, 14.0, "def"))); %! assert (isequal (decorationpart (infsupdec (1.0, 2.0, "com") .* infsupdec (5.0, 7.0, "def")){1}, decorationpart (infsupdec (5.0, 14.0, "def")){1})); %! assert (isequal (times (infsupdec (1.0, 2.0, "com"), infsupdec (5.0, 7.0, "def")), infsupdec (5.0, 14.0, "def"))); %! assert (isequal (decorationpart (times (infsupdec (1.0, 2.0, "com"), infsupdec (5.0, 7.0, "def"))){1}, decorationpart (infsupdec (5.0, 14.0, "def")){1})); %!test %! assert (isequal (infsupdec (1.0, 2.0, "com") .* infsupdec (5.0, 1.797693134862315708e+308, "com"), infsupdec (5.0, inf, "dac"))); %! assert (isequal (decorationpart (infsupdec (1.0, 2.0, "com") .* infsupdec (5.0, 1.797693134862315708e+308, "com")){1}, decorationpart (infsupdec (5.0, inf, "dac")){1})); %! assert (isequal (times (infsupdec (1.0, 2.0, "com"), infsupdec (5.0, 1.797693134862315708e+308, "com")), infsupdec (5.0, inf, "dac"))); %! assert (isequal (decorationpart (times (infsupdec (1.0, 2.0, "com"), infsupdec (5.0, 1.797693134862315708e+308, "com"))){1}, decorationpart (infsupdec (5.0, inf, "dac")){1})); %!test %! assert (isequal (infsupdec (-1.797693134862315708e+308, 2.0, "com") .* infsupdec (-1.0, 5.0, "com"), infsupdec (-inf, 1.797693134862315708e+308, "dac"))); %! assert (isequal (decorationpart (infsupdec (-1.797693134862315708e+308, 2.0, "com") .* infsupdec (-1.0, 5.0, "com")){1}, decorationpart (infsupdec (-inf, 1.797693134862315708e+308, "dac")){1})); %! assert (isequal (times (infsupdec (-1.797693134862315708e+308, 2.0, "com"), infsupdec (-1.0, 5.0, "com")), infsupdec (-inf, 1.797693134862315708e+308, "dac"))); %! assert (isequal (decorationpart (times (infsupdec (-1.797693134862315708e+308, 2.0, "com"), infsupdec (-1.0, 5.0, "com"))){1}, decorationpart (infsupdec (-inf, 1.797693134862315708e+308, "dac")){1})); %!test %! assert (isequal (infsupdec (1.0, 2.0, "trv") .* infsupdec (empty, "trv"), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (infsupdec (1.0, 2.0, "trv") .* infsupdec (empty, "trv")){1}, decorationpart (infsupdec (empty, "trv")){1})); %! assert (isequal (times (infsupdec (1.0, 2.0, "trv"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (times (infsupdec (1.0, 2.0, "trv"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); ## minimal_div_test %!test %! assert (isequal (infsup ./ infsup, infsup)); %! assert (isequal (rdivide (infsup, infsup), infsup)); %!test %! assert (isequal (infsup (-1.0, 1.0) ./ infsup, infsup)); %! assert (isequal (rdivide (infsup (-1.0, 1.0), infsup), infsup)); %!test %! assert (isequal (infsup ./ infsup (-1.0, 1.0), infsup)); %! assert (isequal (rdivide (infsup, infsup (-1.0, 1.0)), infsup)); %!test %! assert (isequal (infsup ./ infsup (0.1, 1.0), infsup)); %! assert (isequal (rdivide (infsup, infsup (0.1, 1.0)), infsup)); %!test %! assert (isequal (infsup ./ infsup (-1.0, -0.1), infsup)); %! assert (isequal (rdivide (infsup, infsup (-1.0, -0.1)), infsup)); %!test %! assert (isequal (infsup ./ infsup (-inf, inf), infsup)); %! assert (isequal (rdivide (infsup, infsup (-inf, inf)), infsup)); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup, infsup)); %! assert (isequal (rdivide (infsup (-inf, inf), infsup), infsup)); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup, infsup)); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup), infsup)); %!test %! assert (isequal (infsup ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup, infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (-0.0, -0.0) ./ infsup, infsup)); %! assert (isequal (rdivide (infsup (-0.0, -0.0), infsup), infsup)); %!test %! assert (isequal (infsup ./ infsup (-0.0, -0.0), infsup)); %! assert (isequal (rdivide (infsup, infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup (-5.0, -3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, inf), infsup (-5.0, -3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup (3.0, 5.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, inf), infsup (3.0, 5.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup (-inf, -3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, inf), infsup (-inf, -3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup (3.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, inf), infsup (3.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (-inf, inf), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup (-0.0, -0.0), infsup)); %! assert (isequal (rdivide (infsup (-inf, inf), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup (-3.0, 0.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, inf), infsup (-3.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup (-3.0, -0.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, inf), infsup (-3.0, -0.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup (-3.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, inf), infsup (-3.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup (0.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, inf), infsup (0.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup (-inf, 0.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, inf), infsup (-inf, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup (-0.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, inf), infsup (-0.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup (-inf, -0.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, inf), infsup (-inf, -0.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup (-inf, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, inf), infsup (-inf, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup (-3.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, inf), infsup (-3.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup (0.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, inf), infsup (0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup (-0.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, inf), infsup (-0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, inf) ./ infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, -15.0) ./ infsup (-5.0, -3.0), infsup (3.0, 10.0))); %! assert (isequal (rdivide (infsup (-30.0, -15.0), infsup (-5.0, -3.0)), infsup (3.0, 10.0))); %!test %! assert (isequal (infsup (-30.0, -15.0) ./ infsup (3.0, 5.0), infsup (-10.0, -3.0))); %! assert (isequal (rdivide (infsup (-30.0, -15.0), infsup (3.0, 5.0)), infsup (-10.0, -3.0))); %!test %! assert (isequal (infsup (-30.0, -15.0) ./ infsup (-inf, -3.0), infsup (0.0, 10.0))); %! assert (isequal (rdivide (infsup (-30.0, -15.0), infsup (-inf, -3.0)), infsup (0.0, 10.0))); %!test %! assert (isequal (infsup (-30.0, -15.0) ./ infsup (3.0, inf), infsup (-10.0, 0.0))); %! assert (isequal (rdivide (infsup (-30.0, -15.0), infsup (3.0, inf)), infsup (-10.0, 0.0))); %!test %! assert (isequal (infsup (-30.0, -15.0) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (-30.0, -15.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (-30.0, -15.0) ./ infsup (-3.0, 0.0), infsup (5.0, inf))); %! assert (isequal (rdivide (infsup (-30.0, -15.0), infsup (-3.0, 0.0)), infsup (5.0, inf))); %!test %! assert (isequal (infsup (-30.0, -15.0) ./ infsup (-0.0, -0.0), infsup)); %! assert (isequal (rdivide (infsup (-30.0, -15.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (infsup (-30.0, -15.0) ./ infsup (-3.0, -0.0), infsup (5.0, inf))); %! assert (isequal (rdivide (infsup (-30.0, -15.0), infsup (-3.0, -0.0)), infsup (5.0, inf))); %!test %! assert (isequal (infsup (-30.0, -15.0) ./ infsup (-3.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, -15.0), infsup (-3.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, -15.0) ./ infsup (0.0, 3.0), infsup (-inf, -5.0))); %! assert (isequal (rdivide (infsup (-30.0, -15.0), infsup (0.0, 3.0)), infsup (-inf, -5.0))); %!test %! assert (isequal (infsup (-30.0, -15.0) ./ infsup (-inf, 0.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-30.0, -15.0), infsup (-inf, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-30.0, -15.0) ./ infsup (-0.0, 3.0), infsup (-inf, -5.0))); %! assert (isequal (rdivide (infsup (-30.0, -15.0), infsup (-0.0, 3.0)), infsup (-inf, -5.0))); %!test %! assert (isequal (infsup (-30.0, -15.0) ./ infsup (-inf, -0.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-30.0, -15.0), infsup (-inf, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-30.0, -15.0) ./ infsup (-inf, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, -15.0), infsup (-inf, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, -15.0) ./ infsup (-3.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, -15.0), infsup (-3.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, -15.0) ./ infsup (0.0, inf), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-30.0, -15.0), infsup (0.0, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-30.0, -15.0) ./ infsup (-0.0, inf), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-30.0, -15.0), infsup (-0.0, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-30.0, -15.0) ./ infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, -15.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, 15.0) ./ infsup (-5.0, -3.0), infsup (-5.0, 10.0))); %! assert (isequal (rdivide (infsup (-30.0, 15.0), infsup (-5.0, -3.0)), infsup (-5.0, 10.0))); %!test %! assert (isequal (infsup (-30.0, 15.0) ./ infsup (3.0, 5.0), infsup (-10.0, 5.0))); %! assert (isequal (rdivide (infsup (-30.0, 15.0), infsup (3.0, 5.0)), infsup (-10.0, 5.0))); %!test %! assert (isequal (infsup (-30.0, 15.0) ./ infsup (-inf, -3.0), infsup (-5.0, 10.0))); %! assert (isequal (rdivide (infsup (-30.0, 15.0), infsup (-inf, -3.0)), infsup (-5.0, 10.0))); %!test %! assert (isequal (infsup (-30.0, 15.0) ./ infsup (3.0, inf), infsup (-10.0, 5.0))); %! assert (isequal (rdivide (infsup (-30.0, 15.0), infsup (3.0, inf)), infsup (-10.0, 5.0))); %!test %! assert (isequal (infsup (-30.0, 15.0) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (-30.0, 15.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (-30.0, 15.0) ./ infsup (-0.0, -0.0), infsup)); %! assert (isequal (rdivide (infsup (-30.0, 15.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (infsup (-30.0, 15.0) ./ infsup (-3.0, 0.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, 15.0), infsup (-3.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, 15.0) ./ infsup (-3.0, -0.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, 15.0), infsup (-3.0, -0.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, 15.0) ./ infsup (-3.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, 15.0), infsup (-3.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, 15.0) ./ infsup (0.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, 15.0), infsup (0.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, 15.0) ./ infsup (-inf, 0.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, 15.0), infsup (-inf, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, 15.0) ./ infsup (-0.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, 15.0), infsup (-0.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, 15.0) ./ infsup (-inf, -0.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, 15.0), infsup (-inf, -0.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, 15.0) ./ infsup (-inf, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, 15.0), infsup (-inf, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, 15.0) ./ infsup (-3.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, 15.0), infsup (-3.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, 15.0) ./ infsup (0.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, 15.0), infsup (0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, 15.0) ./ infsup (-0.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, 15.0), infsup (-0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, 15.0) ./ infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, 15.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (15.0, 30.0) ./ infsup (-5.0, -3.0), infsup (-10.0, -3.0))); %! assert (isequal (rdivide (infsup (15.0, 30.0), infsup (-5.0, -3.0)), infsup (-10.0, -3.0))); %!test %! assert (isequal (infsup (15.0, 30.0) ./ infsup (3.0, 5.0), infsup (3.0, 10.0))); %! assert (isequal (rdivide (infsup (15.0, 30.0), infsup (3.0, 5.0)), infsup (3.0, 10.0))); %!test %! assert (isequal (infsup (15.0, 30.0) ./ infsup (-inf, -3.0), infsup (-10.0, 0.0))); %! assert (isequal (rdivide (infsup (15.0, 30.0), infsup (-inf, -3.0)), infsup (-10.0, 0.0))); %!test %! assert (isequal (infsup (15.0, 30.0) ./ infsup (3.0, inf), infsup (0.0, 10.0))); %! assert (isequal (rdivide (infsup (15.0, 30.0), infsup (3.0, inf)), infsup (0.0, 10.0))); %!test %! assert (isequal (infsup (15.0, 30.0) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (15.0, 30.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (15.0, 30.0) ./ infsup (-3.0, 0.0), infsup (-inf, -5.0))); %! assert (isequal (rdivide (infsup (15.0, 30.0), infsup (-3.0, 0.0)), infsup (-inf, -5.0))); %!test %! assert (isequal (infsup (15.0, 30.0) ./ infsup (-0.0, -0.0), infsup)); %! assert (isequal (rdivide (infsup (15.0, 30.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (infsup (15.0, 30.0) ./ infsup (-3.0, -0.0), infsup (-inf, -5.0))); %! assert (isequal (rdivide (infsup (15.0, 30.0), infsup (-3.0, -0.0)), infsup (-inf, -5.0))); %!test %! assert (isequal (infsup (15.0, 30.0) ./ infsup (-3.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (15.0, 30.0), infsup (-3.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (15.0, 30.0) ./ infsup (0.0, 3.0), infsup (5.0, inf))); %! assert (isequal (rdivide (infsup (15.0, 30.0), infsup (0.0, 3.0)), infsup (5.0, inf))); %!test %! assert (isequal (infsup (15.0, 30.0) ./ infsup (-inf, 0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (15.0, 30.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (15.0, 30.0) ./ infsup (-0.0, 3.0), infsup (5.0, inf))); %! assert (isequal (rdivide (infsup (15.0, 30.0), infsup (-0.0, 3.0)), infsup (5.0, inf))); %!test %! assert (isequal (infsup (15.0, 30.0) ./ infsup (-inf, -0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (15.0, 30.0), infsup (-inf, -0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (15.0, 30.0) ./ infsup (-inf, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (15.0, 30.0), infsup (-inf, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (15.0, 30.0) ./ infsup (-3.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (15.0, 30.0), infsup (-3.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (15.0, 30.0) ./ infsup (0.0, inf), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (15.0, 30.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (15.0, 30.0) ./ infsup (-0.0, inf), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (15.0, 30.0), infsup (-0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (15.0, 30.0) ./ infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (15.0, 30.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (-5.0, -3.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (-5.0, -3.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (3.0, 5.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (3.0, 5.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (-inf, -3.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (-inf, -3.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (3.0, inf), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (3.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (-3.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (-3.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (-0.0, -0.0), infsup)); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (-3.0, -0.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (-3.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (-3.0, 3.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (-3.0, 3.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (0.0, 3.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (0.0, 3.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (-inf, 0.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (-inf, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (-0.0, 3.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (-0.0, 3.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (-inf, -0.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (-inf, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (-inf, 3.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (-inf, 3.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (-3.0, inf), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (-3.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (0.0, inf), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (0.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (-0.0, inf), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (-0.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 0.0) ./ infsup (-inf, inf), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 0.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) ./ infsup (-5.0, -3.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, -0.0), infsup (-5.0, -3.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) ./ infsup (3.0, 5.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, -0.0), infsup (3.0, 5.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) ./ infsup (-inf, -3.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, -0.0), infsup (-inf, -3.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) ./ infsup (3.0, inf), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, -0.0), infsup (3.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (-0.0, -0.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (-0.0, -0.0) ./ infsup (-3.0, 0.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, -0.0), infsup (-3.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) ./ infsup (-0.0, -0.0), infsup)); %! assert (isequal (rdivide (infsup (-0.0, -0.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (infsup (-0.0, -0.0) ./ infsup (-3.0, -0.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, -0.0), infsup (-3.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) ./ infsup (-3.0, 3.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, -0.0), infsup (-3.0, 3.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) ./ infsup (0.0, 3.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, -0.0), infsup (0.0, 3.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) ./ infsup (-inf, 0.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, -0.0), infsup (-inf, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) ./ infsup (-0.0, 3.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, -0.0), infsup (-0.0, 3.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) ./ infsup (-inf, -0.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, -0.0), infsup (-inf, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) ./ infsup (-inf, 3.0), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, -0.0), infsup (-inf, 3.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) ./ infsup (-3.0, inf), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, -0.0), infsup (-3.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) ./ infsup (0.0, inf), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, -0.0), infsup (0.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) ./ infsup (-0.0, inf), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, -0.0), infsup (-0.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, -0.0) ./ infsup (-inf, inf), infsup (0.0, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, -0.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (infsup (-inf, -15.0) ./ infsup (-5.0, -3.0), infsup (3.0, inf))); %! assert (isequal (rdivide (infsup (-inf, -15.0), infsup (-5.0, -3.0)), infsup (3.0, inf))); %!test %! assert (isequal (infsup (-inf, -15.0) ./ infsup (3.0, 5.0), infsup (-inf, -3.0))); %! assert (isequal (rdivide (infsup (-inf, -15.0), infsup (3.0, 5.0)), infsup (-inf, -3.0))); %!test %! assert (isequal (infsup (-inf, -15.0) ./ infsup (-inf, -3.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-inf, -15.0), infsup (-inf, -3.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-inf, -15.0) ./ infsup (3.0, inf), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-inf, -15.0), infsup (3.0, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-inf, -15.0) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (-inf, -15.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (-inf, -15.0) ./ infsup (-3.0, 0.0), infsup (5.0, inf))); %! assert (isequal (rdivide (infsup (-inf, -15.0), infsup (-3.0, 0.0)), infsup (5.0, inf))); %!test %! assert (isequal (infsup (-inf, -15.0) ./ infsup (-0.0, -0.0), infsup)); %! assert (isequal (rdivide (infsup (-inf, -15.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (infsup (-inf, -15.0) ./ infsup (-3.0, -0.0), infsup (5.0, inf))); %! assert (isequal (rdivide (infsup (-inf, -15.0), infsup (-3.0, -0.0)), infsup (5.0, inf))); %!test %! assert (isequal (infsup (-inf, -15.0) ./ infsup (-3.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, -15.0), infsup (-3.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, -15.0) ./ infsup (0.0, 3.0), infsup (-inf, -5.0))); %! assert (isequal (rdivide (infsup (-inf, -15.0), infsup (0.0, 3.0)), infsup (-inf, -5.0))); %!test %! assert (isequal (infsup (-inf, -15.0) ./ infsup (-inf, 0.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-inf, -15.0), infsup (-inf, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-inf, -15.0) ./ infsup (-0.0, 3.0), infsup (-inf, -5.0))); %! assert (isequal (rdivide (infsup (-inf, -15.0), infsup (-0.0, 3.0)), infsup (-inf, -5.0))); %!test %! assert (isequal (infsup (-inf, -15.0) ./ infsup (-inf, -0.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-inf, -15.0), infsup (-inf, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-inf, -15.0) ./ infsup (-inf, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, -15.0), infsup (-inf, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, -15.0) ./ infsup (-3.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, -15.0), infsup (-3.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, -15.0) ./ infsup (0.0, inf), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-inf, -15.0), infsup (0.0, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-inf, -15.0) ./ infsup (-0.0, inf), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-inf, -15.0), infsup (-0.0, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-inf, -15.0) ./ infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, -15.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 15.0) ./ infsup (-5.0, -3.0), infsup (-5.0, inf))); %! assert (isequal (rdivide (infsup (-inf, 15.0), infsup (-5.0, -3.0)), infsup (-5.0, inf))); %!test %! assert (isequal (infsup (-inf, 15.0) ./ infsup (3.0, 5.0), infsup (-inf, 5.0))); %! assert (isequal (rdivide (infsup (-inf, 15.0), infsup (3.0, 5.0)), infsup (-inf, 5.0))); %!test %! assert (isequal (infsup (-inf, 15.0) ./ infsup (-inf, -3.0), infsup (-5.0, inf))); %! assert (isequal (rdivide (infsup (-inf, 15.0), infsup (-inf, -3.0)), infsup (-5.0, inf))); %!test %! assert (isequal (infsup (-inf, 15.0) ./ infsup (3.0, inf), infsup (-inf, 5.0))); %! assert (isequal (rdivide (infsup (-inf, 15.0), infsup (3.0, inf)), infsup (-inf, 5.0))); %!test %! assert (isequal (infsup (-inf, 15.0) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (-inf, 15.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (-inf, 15.0) ./ infsup (-3.0, 0.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, 15.0), infsup (-3.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 15.0) ./ infsup (-0.0, -0.0), infsup)); %! assert (isequal (rdivide (infsup (-inf, 15.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (infsup (-inf, 15.0) ./ infsup (-3.0, -0.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, 15.0), infsup (-3.0, -0.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 15.0) ./ infsup (-3.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, 15.0), infsup (-3.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 15.0) ./ infsup (0.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, 15.0), infsup (0.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 15.0) ./ infsup (-inf, 0.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, 15.0), infsup (-inf, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 15.0) ./ infsup (-0.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, 15.0), infsup (-0.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 15.0) ./ infsup (-inf, -0.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, 15.0), infsup (-inf, -0.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 15.0) ./ infsup (-inf, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, 15.0), infsup (-inf, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 15.0) ./ infsup (-3.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, 15.0), infsup (-3.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 15.0) ./ infsup (0.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, 15.0), infsup (0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 15.0) ./ infsup (-0.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, 15.0), infsup (-0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 15.0) ./ infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, 15.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-15.0, inf) ./ infsup (-5.0, -3.0), infsup (-inf, 5.0))); %! assert (isequal (rdivide (infsup (-15.0, inf), infsup (-5.0, -3.0)), infsup (-inf, 5.0))); %!test %! assert (isequal (infsup (-15.0, inf) ./ infsup (3.0, 5.0), infsup (-5.0, inf))); %! assert (isequal (rdivide (infsup (-15.0, inf), infsup (3.0, 5.0)), infsup (-5.0, inf))); %!test %! assert (isequal (infsup (-15.0, inf) ./ infsup (-inf, -3.0), infsup (-inf, 5.0))); %! assert (isequal (rdivide (infsup (-15.0, inf), infsup (-inf, -3.0)), infsup (-inf, 5.0))); %!test %! assert (isequal (infsup (-15.0, inf) ./ infsup (3.0, inf), infsup (-5.0, inf))); %! assert (isequal (rdivide (infsup (-15.0, inf), infsup (3.0, inf)), infsup (-5.0, inf))); %!test %! assert (isequal (infsup (-15.0, inf) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (-15.0, inf), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (-15.0, inf) ./ infsup (-3.0, 0.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-15.0, inf), infsup (-3.0, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-15.0, inf) ./ infsup (-0.0, -0.0), infsup)); %! assert (isequal (rdivide (infsup (-15.0, inf), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (infsup (-15.0, inf) ./ infsup (-3.0, -0.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-15.0, inf), infsup (-3.0, -0.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-15.0, inf) ./ infsup (-3.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-15.0, inf), infsup (-3.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-15.0, inf) ./ infsup (0.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-15.0, inf), infsup (0.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-15.0, inf) ./ infsup (-inf, 0.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-15.0, inf), infsup (-inf, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-15.0, inf) ./ infsup (-0.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-15.0, inf), infsup (-0.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-15.0, inf) ./ infsup (-inf, -0.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-15.0, inf), infsup (-inf, -0.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-15.0, inf) ./ infsup (-inf, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-15.0, inf), infsup (-inf, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-15.0, inf) ./ infsup (-3.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-15.0, inf), infsup (-3.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-15.0, inf) ./ infsup (0.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-15.0, inf), infsup (0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-15.0, inf) ./ infsup (-0.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-15.0, inf), infsup (-0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-15.0, inf) ./ infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-15.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (15.0, inf) ./ infsup (-5.0, -3.0), infsup (-inf, -3.0))); %! assert (isequal (rdivide (infsup (15.0, inf), infsup (-5.0, -3.0)), infsup (-inf, -3.0))); %!test %! assert (isequal (infsup (15.0, inf) ./ infsup (3.0, 5.0), infsup (3.0, inf))); %! assert (isequal (rdivide (infsup (15.0, inf), infsup (3.0, 5.0)), infsup (3.0, inf))); %!test %! assert (isequal (infsup (15.0, inf) ./ infsup (-inf, -3.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (15.0, inf), infsup (-inf, -3.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (15.0, inf) ./ infsup (3.0, inf), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (15.0, inf), infsup (3.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (15.0, inf) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (15.0, inf), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (15.0, inf) ./ infsup (-3.0, 0.0), infsup (-inf, -5.0))); %! assert (isequal (rdivide (infsup (15.0, inf), infsup (-3.0, 0.0)), infsup (-inf, -5.0))); %!test %! assert (isequal (infsup (15.0, inf) ./ infsup (-0.0, -0.0), infsup)); %! assert (isequal (rdivide (infsup (15.0, inf), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (infsup (15.0, inf) ./ infsup (-3.0, -0.0), infsup (-inf, -5.0))); %! assert (isequal (rdivide (infsup (15.0, inf), infsup (-3.0, -0.0)), infsup (-inf, -5.0))); %!test %! assert (isequal (infsup (15.0, inf) ./ infsup (-3.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (15.0, inf), infsup (-3.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (15.0, inf) ./ infsup (0.0, 3.0), infsup (5.0, inf))); %! assert (isequal (rdivide (infsup (15.0, inf), infsup (0.0, 3.0)), infsup (5.0, inf))); %!test %! assert (isequal (infsup (15.0, inf) ./ infsup (-inf, 0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (15.0, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (15.0, inf) ./ infsup (-0.0, 3.0), infsup (5.0, inf))); %! assert (isequal (rdivide (infsup (15.0, inf), infsup (-0.0, 3.0)), infsup (5.0, inf))); %!test %! assert (isequal (infsup (15.0, inf) ./ infsup (-inf, -0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (15.0, inf), infsup (-inf, -0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (15.0, inf) ./ infsup (-inf, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (15.0, inf), infsup (-inf, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (15.0, inf) ./ infsup (-3.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (15.0, inf), infsup (-3.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (15.0, inf) ./ infsup (0.0, inf), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (15.0, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (15.0, inf) ./ infsup (-0.0, inf), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (15.0, inf), infsup (-0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (15.0, inf) ./ infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (15.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, 0.0) ./ infsup (-5.0, -3.0), infsup (0.0, 10.0))); %! assert (isequal (rdivide (infsup (-30.0, 0.0), infsup (-5.0, -3.0)), infsup (0.0, 10.0))); %!test %! assert (isequal (infsup (-30.0, 0.0) ./ infsup (3.0, 5.0), infsup (-10.0, 0.0))); %! assert (isequal (rdivide (infsup (-30.0, 0.0), infsup (3.0, 5.0)), infsup (-10.0, 0.0))); %!test %! assert (isequal (infsup (-30.0, 0.0) ./ infsup (-inf, -3.0), infsup (0.0, 10.0))); %! assert (isequal (rdivide (infsup (-30.0, 0.0), infsup (-inf, -3.0)), infsup (0.0, 10.0))); %!test %! assert (isequal (infsup (-30.0, 0.0) ./ infsup (3.0, inf), infsup (-10.0, 0.0))); %! assert (isequal (rdivide (infsup (-30.0, 0.0), infsup (3.0, inf)), infsup (-10.0, 0.0))); %!test %! assert (isequal (infsup (-30.0, 0.0) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (-30.0, 0.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (-30.0, 0.0) ./ infsup (-3.0, 0.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-30.0, 0.0), infsup (-3.0, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-30.0, 0.0) ./ infsup (-0.0, -0.0), infsup)); %! assert (isequal (rdivide (infsup (-30.0, 0.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (infsup (-30.0, 0.0) ./ infsup (-3.0, -0.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-30.0, 0.0), infsup (-3.0, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-30.0, 0.0) ./ infsup (-3.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, 0.0), infsup (-3.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, 0.0) ./ infsup (0.0, 3.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-30.0, 0.0), infsup (0.0, 3.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-30.0, 0.0) ./ infsup (-inf, 0.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-30.0, 0.0), infsup (-inf, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-30.0, 0.0) ./ infsup (-0.0, 3.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-30.0, 0.0), infsup (-0.0, 3.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-30.0, 0.0) ./ infsup (-inf, -0.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-30.0, 0.0), infsup (-inf, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-30.0, 0.0) ./ infsup (-inf, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, 0.0), infsup (-inf, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, 0.0) ./ infsup (-3.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, 0.0), infsup (-3.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, 0.0) ./ infsup (0.0, inf), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-30.0, 0.0), infsup (0.0, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-30.0, 0.0) ./ infsup (-0.0, inf), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-30.0, 0.0), infsup (-0.0, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-30.0, 0.0) ./ infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, 0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, -0.0) ./ infsup (-5.0, -3.0), infsup (0.0, 10.0))); %! assert (isequal (rdivide (infsup (-30.0, -0.0), infsup (-5.0, -3.0)), infsup (0.0, 10.0))); %!test %! assert (isequal (infsup (-30.0, -0.0) ./ infsup (3.0, 5.0), infsup (-10.0, 0.0))); %! assert (isequal (rdivide (infsup (-30.0, -0.0), infsup (3.0, 5.0)), infsup (-10.0, 0.0))); %!test %! assert (isequal (infsup (-30.0, -0.0) ./ infsup (-inf, -3.0), infsup (0.0, 10.0))); %! assert (isequal (rdivide (infsup (-30.0, -0.0), infsup (-inf, -3.0)), infsup (0.0, 10.0))); %!test %! assert (isequal (infsup (-30.0, -0.0) ./ infsup (3.0, inf), infsup (-10.0, 0.0))); %! assert (isequal (rdivide (infsup (-30.0, -0.0), infsup (3.0, inf)), infsup (-10.0, 0.0))); %!test %! assert (isequal (infsup (-30.0, -0.0) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (-30.0, -0.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (-30.0, -0.0) ./ infsup (-3.0, 0.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-30.0, -0.0), infsup (-3.0, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-30.0, -0.0) ./ infsup (-0.0, -0.0), infsup)); %! assert (isequal (rdivide (infsup (-30.0, -0.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (infsup (-30.0, -0.0) ./ infsup (-3.0, -0.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-30.0, -0.0), infsup (-3.0, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-30.0, -0.0) ./ infsup (-3.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, -0.0), infsup (-3.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, -0.0) ./ infsup (0.0, 3.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-30.0, -0.0), infsup (0.0, 3.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-30.0, -0.0) ./ infsup (-inf, 0.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-30.0, -0.0), infsup (-inf, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-30.0, -0.0) ./ infsup (-0.0, 3.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-30.0, -0.0), infsup (-0.0, 3.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-30.0, -0.0) ./ infsup (-inf, -0.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-30.0, -0.0), infsup (-inf, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-30.0, -0.0) ./ infsup (-inf, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, -0.0), infsup (-inf, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, -0.0) ./ infsup (-3.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, -0.0), infsup (-3.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-30.0, -0.0) ./ infsup (0.0, inf), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-30.0, -0.0), infsup (0.0, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-30.0, -0.0) ./ infsup (-0.0, inf), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-30.0, -0.0), infsup (-0.0, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-30.0, -0.0) ./ infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-30.0, -0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, 30.0) ./ infsup (-5.0, -3.0), infsup (-10.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 30.0), infsup (-5.0, -3.0)), infsup (-10.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 30.0) ./ infsup (3.0, 5.0), infsup (0.0, 10.0))); %! assert (isequal (rdivide (infsup (0.0, 30.0), infsup (3.0, 5.0)), infsup (0.0, 10.0))); %!test %! assert (isequal (infsup (0.0, 30.0) ./ infsup (-inf, -3.0), infsup (-10.0, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 30.0), infsup (-inf, -3.0)), infsup (-10.0, 0.0))); %!test %! assert (isequal (infsup (0.0, 30.0) ./ infsup (3.0, inf), infsup (0.0, 10.0))); %! assert (isequal (rdivide (infsup (0.0, 30.0), infsup (3.0, inf)), infsup (0.0, 10.0))); %!test %! assert (isequal (infsup (0.0, 30.0) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (0.0, 30.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (0.0, 30.0) ./ infsup (-3.0, 0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 30.0), infsup (-3.0, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (0.0, 30.0) ./ infsup (-0.0, -0.0), infsup)); %! assert (isequal (rdivide (infsup (0.0, 30.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (infsup (0.0, 30.0) ./ infsup (-3.0, -0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 30.0), infsup (-3.0, -0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (0.0, 30.0) ./ infsup (-3.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (0.0, 30.0), infsup (-3.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, 30.0) ./ infsup (0.0, 3.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (0.0, 30.0), infsup (0.0, 3.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (0.0, 30.0) ./ infsup (-inf, 0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 30.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (0.0, 30.0) ./ infsup (-0.0, 3.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (0.0, 30.0), infsup (-0.0, 3.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (0.0, 30.0) ./ infsup (-inf, -0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (0.0, 30.0), infsup (-inf, -0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (0.0, 30.0) ./ infsup (-inf, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (0.0, 30.0), infsup (-inf, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, 30.0) ./ infsup (-3.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (0.0, 30.0), infsup (-3.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, 30.0) ./ infsup (0.0, inf), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (0.0, 30.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (0.0, 30.0) ./ infsup (-0.0, inf), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (0.0, 30.0), infsup (-0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (0.0, 30.0) ./ infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (0.0, 30.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-0.0, 30.0) ./ infsup (-5.0, -3.0), infsup (-10.0, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, 30.0), infsup (-5.0, -3.0)), infsup (-10.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, 30.0) ./ infsup (3.0, 5.0), infsup (0.0, 10.0))); %! assert (isequal (rdivide (infsup (-0.0, 30.0), infsup (3.0, 5.0)), infsup (0.0, 10.0))); %!test %! assert (isequal (infsup (-0.0, 30.0) ./ infsup (-inf, -3.0), infsup (-10.0, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, 30.0), infsup (-inf, -3.0)), infsup (-10.0, 0.0))); %!test %! assert (isequal (infsup (-0.0, 30.0) ./ infsup (3.0, inf), infsup (0.0, 10.0))); %! assert (isequal (rdivide (infsup (-0.0, 30.0), infsup (3.0, inf)), infsup (0.0, 10.0))); %!test %! assert (isequal (infsup (-0.0, 30.0) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (-0.0, 30.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (-0.0, 30.0) ./ infsup (-3.0, 0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, 30.0), infsup (-3.0, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-0.0, 30.0) ./ infsup (-0.0, -0.0), infsup)); %! assert (isequal (rdivide (infsup (-0.0, 30.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (infsup (-0.0, 30.0) ./ infsup (-3.0, -0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, 30.0), infsup (-3.0, -0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-0.0, 30.0) ./ infsup (-3.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-0.0, 30.0), infsup (-3.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-0.0, 30.0) ./ infsup (0.0, 3.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-0.0, 30.0), infsup (0.0, 3.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-0.0, 30.0) ./ infsup (-inf, 0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, 30.0), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-0.0, 30.0) ./ infsup (-0.0, 3.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-0.0, 30.0), infsup (-0.0, 3.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-0.0, 30.0) ./ infsup (-inf, -0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, 30.0), infsup (-inf, -0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-0.0, 30.0) ./ infsup (-inf, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-0.0, 30.0), infsup (-inf, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-0.0, 30.0) ./ infsup (-3.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-0.0, 30.0), infsup (-3.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-0.0, 30.0) ./ infsup (0.0, inf), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-0.0, 30.0), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-0.0, 30.0) ./ infsup (-0.0, inf), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-0.0, 30.0), infsup (-0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-0.0, 30.0) ./ infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-0.0, 30.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 0.0) ./ infsup (-5.0, -3.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-inf, 0.0), infsup (-5.0, -3.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-inf, 0.0) ./ infsup (3.0, 5.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-inf, 0.0), infsup (3.0, 5.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-inf, 0.0) ./ infsup (-inf, -3.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-inf, 0.0), infsup (-inf, -3.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-inf, 0.0) ./ infsup (3.0, inf), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-inf, 0.0), infsup (3.0, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-inf, 0.0) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (-inf, 0.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (-inf, 0.0) ./ infsup (-3.0, 0.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-inf, 0.0), infsup (-3.0, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-inf, 0.0) ./ infsup (-0.0, -0.0), infsup)); %! assert (isequal (rdivide (infsup (-inf, 0.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (infsup (-inf, 0.0) ./ infsup (-3.0, -0.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-inf, 0.0), infsup (-3.0, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-inf, 0.0) ./ infsup (-3.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, 0.0), infsup (-3.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 0.0) ./ infsup (0.0, 3.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-inf, 0.0), infsup (0.0, 3.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-inf, 0.0) ./ infsup (-inf, 0.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-inf, 0.0), infsup (-inf, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-inf, 0.0) ./ infsup (-0.0, 3.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-inf, 0.0), infsup (-0.0, 3.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-inf, 0.0) ./ infsup (-inf, -0.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-inf, 0.0), infsup (-inf, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-inf, 0.0) ./ infsup (-inf, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, 0.0), infsup (-inf, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 0.0) ./ infsup (-3.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, 0.0), infsup (-3.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, 0.0) ./ infsup (0.0, inf), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-inf, 0.0), infsup (0.0, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-inf, 0.0) ./ infsup (-0.0, inf), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-inf, 0.0), infsup (-0.0, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-inf, 0.0) ./ infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, 0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, -0.0) ./ infsup (-5.0, -3.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-inf, -0.0), infsup (-5.0, -3.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-inf, -0.0) ./ infsup (3.0, 5.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-inf, -0.0), infsup (3.0, 5.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-inf, -0.0) ./ infsup (-inf, -3.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-inf, -0.0), infsup (-inf, -3.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-inf, -0.0) ./ infsup (3.0, inf), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-inf, -0.0), infsup (3.0, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-inf, -0.0) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (-inf, -0.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (-inf, -0.0) ./ infsup (-3.0, 0.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-inf, -0.0), infsup (-3.0, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-inf, -0.0) ./ infsup (-0.0, -0.0), infsup)); %! assert (isequal (rdivide (infsup (-inf, -0.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (infsup (-inf, -0.0) ./ infsup (-3.0, -0.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-inf, -0.0), infsup (-3.0, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-inf, -0.0) ./ infsup (-3.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, -0.0), infsup (-3.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, -0.0) ./ infsup (0.0, 3.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-inf, -0.0), infsup (0.0, 3.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-inf, -0.0) ./ infsup (-inf, 0.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-inf, -0.0), infsup (-inf, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-inf, -0.0) ./ infsup (-0.0, 3.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-inf, -0.0), infsup (-0.0, 3.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-inf, -0.0) ./ infsup (-inf, -0.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-inf, -0.0), infsup (-inf, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-inf, -0.0) ./ infsup (-inf, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, -0.0), infsup (-inf, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, -0.0) ./ infsup (-3.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, -0.0), infsup (-3.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-inf, -0.0) ./ infsup (0.0, inf), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-inf, -0.0), infsup (0.0, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-inf, -0.0) ./ infsup (-0.0, inf), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-inf, -0.0), infsup (-0.0, inf)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-inf, -0.0) ./ infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-inf, -0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, inf) ./ infsup (-5.0, -3.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (0.0, inf), infsup (-5.0, -3.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (0.0, inf) ./ infsup (3.0, 5.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (0.0, inf), infsup (3.0, 5.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (0.0, inf) ./ infsup (-inf, -3.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (0.0, inf), infsup (-inf, -3.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (0.0, inf) ./ infsup (3.0, inf), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (0.0, inf), infsup (3.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (0.0, inf) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (0.0, inf), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (0.0, inf) ./ infsup (-3.0, 0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (0.0, inf), infsup (-3.0, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (0.0, inf) ./ infsup (-0.0, -0.0), infsup)); %! assert (isequal (rdivide (infsup (0.0, inf), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (infsup (0.0, inf) ./ infsup (-3.0, -0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (0.0, inf), infsup (-3.0, -0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (0.0, inf) ./ infsup (-3.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (0.0, inf), infsup (-3.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, inf) ./ infsup (0.0, 3.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (0.0, inf), infsup (0.0, 3.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (0.0, inf) ./ infsup (-inf, 0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (0.0, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (0.0, inf) ./ infsup (-0.0, 3.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (0.0, inf), infsup (-0.0, 3.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (0.0, inf) ./ infsup (-inf, -0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (0.0, inf), infsup (-inf, -0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (0.0, inf) ./ infsup (-inf, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (0.0, inf), infsup (-inf, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, inf) ./ infsup (-3.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (0.0, inf), infsup (-3.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (0.0, inf) ./ infsup (0.0, inf), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (0.0, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (0.0, inf) ./ infsup (-0.0, inf), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (0.0, inf), infsup (-0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (0.0, inf) ./ infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (0.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-0.0, inf) ./ infsup (-5.0, -3.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, inf), infsup (-5.0, -3.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-0.0, inf) ./ infsup (3.0, 5.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-0.0, inf), infsup (3.0, 5.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-0.0, inf) ./ infsup (-inf, -3.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, inf), infsup (-inf, -3.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-0.0, inf) ./ infsup (3.0, inf), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-0.0, inf), infsup (3.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-0.0, inf) ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (infsup (-0.0, inf), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (infsup (-0.0, inf) ./ infsup (-3.0, 0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, inf), infsup (-3.0, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-0.0, inf) ./ infsup (-0.0, -0.0), infsup)); %! assert (isequal (rdivide (infsup (-0.0, inf), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (infsup (-0.0, inf) ./ infsup (-3.0, -0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, inf), infsup (-3.0, -0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-0.0, inf) ./ infsup (-3.0, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-0.0, inf), infsup (-3.0, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-0.0, inf) ./ infsup (0.0, 3.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-0.0, inf), infsup (0.0, 3.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-0.0, inf) ./ infsup (-inf, 0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, inf), infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-0.0, inf) ./ infsup (-0.0, 3.0), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-0.0, inf), infsup (-0.0, 3.0)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-0.0, inf) ./ infsup (-inf, -0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (infsup (-0.0, inf), infsup (-inf, -0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (infsup (-0.0, inf) ./ infsup (-inf, 3.0), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-0.0, inf), infsup (-inf, 3.0)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-0.0, inf) ./ infsup (-3.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-0.0, inf), infsup (-3.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-0.0, inf) ./ infsup (0.0, inf), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-0.0, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-0.0, inf) ./ infsup (-0.0, inf), infsup (0.0, inf))); %! assert (isequal (rdivide (infsup (-0.0, inf), infsup (-0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (infsup (-0.0, inf) ./ infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (infsup (-0.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (infsup (-2.0, -1.0) ./ infsup (-10.0, -3.0), infsup (9.999999999999999167e-02, 6.666666666666667407e-01))); %! assert (isequal (rdivide (infsup (-2.0, -1.0), infsup (-10.0, -3.0)), infsup (9.999999999999999167e-02, 6.666666666666667407e-01))); %!test %! assert (isequal (infsup (-2.0, -1.0) ./ infsup (0.0, 10.0), infsup (-inf, -9.999999999999999167e-02))); %! assert (isequal (rdivide (infsup (-2.0, -1.0), infsup (0.0, 10.0)), infsup (-inf, -9.999999999999999167e-02))); %!test %! assert (isequal (infsup (-2.0, -1.0) ./ infsup (-0.0, 10.0), infsup (-inf, -9.999999999999999167e-02))); %! assert (isequal (rdivide (infsup (-2.0, -1.0), infsup (-0.0, 10.0)), infsup (-inf, -9.999999999999999167e-02))); %!test %! assert (isequal (infsup (-1.0, 2.0) ./ infsup (10.0, inf), infsup (-1.000000000000000056e-01, 2.000000000000000111e-01))); %! assert (isequal (rdivide (infsup (-1.0, 2.0), infsup (10.0, inf)), infsup (-1.000000000000000056e-01, 2.000000000000000111e-01))); %!test %! assert (isequal (infsup (1.0, 3.0) ./ infsup (-inf, -10.0), infsup (-3.000000000000000444e-01, 0.0))); %! assert (isequal (rdivide (infsup (1.0, 3.0), infsup (-inf, -10.0)), infsup (-3.000000000000000444e-01, 0.0))); %!test %! assert (isequal (infsup (-inf, -1.0) ./ infsup (1.0, 3.0), infsup (-inf, -3.333333333333333148e-01))); %! assert (isequal (rdivide (infsup (-inf, -1.0), infsup (1.0, 3.0)), infsup (-inf, -3.333333333333333148e-01))); ## minimal_div_dec_test %!test %! assert (isequal (infsupdec (-2.0, -1.0, "com") ./ infsupdec (-10.0, -3.0, "com"), infsupdec (9.999999999999999167e-02, 6.666666666666667407e-01, "com"))); %! assert (isequal (decorationpart (infsupdec (-2.0, -1.0, "com") ./ infsupdec (-10.0, -3.0, "com")){1}, decorationpart (infsupdec (9.999999999999999167e-02, 6.666666666666667407e-01, "com")){1})); %! assert (isequal (rdivide (infsupdec (-2.0, -1.0, "com"), infsupdec (-10.0, -3.0, "com")), infsupdec (9.999999999999999167e-02, 6.666666666666667407e-01, "com"))); %! assert (isequal (decorationpart (rdivide (infsupdec (-2.0, -1.0, "com"), infsupdec (-10.0, -3.0, "com"))){1}, decorationpart (infsupdec (9.999999999999999167e-02, 6.666666666666667407e-01, "com")){1})); %!test %! assert (isequal (infsupdec (-200.0, -1.0, "com") ./ infsupdec (4.940656458412465442e-324, 10.0, "com"), infsupdec (-inf, -9.999999999999999167e-02, "dac"))); %! assert (isequal (decorationpart (infsupdec (-200.0, -1.0, "com") ./ infsupdec (4.940656458412465442e-324, 10.0, "com")){1}, decorationpart (infsupdec (-inf, -9.999999999999999167e-02, "dac")){1})); %! assert (isequal (rdivide (infsupdec (-200.0, -1.0, "com"), infsupdec (4.940656458412465442e-324, 10.0, "com")), infsupdec (-inf, -9.999999999999999167e-02, "dac"))); %! assert (isequal (decorationpart (rdivide (infsupdec (-200.0, -1.0, "com"), infsupdec (4.940656458412465442e-324, 10.0, "com"))){1}, decorationpart (infsupdec (-inf, -9.999999999999999167e-02, "dac")){1})); %!test %! assert (isequal (infsupdec (-2.0, -1.0, "com") ./ infsupdec (0.0, 10.0, "com"), infsupdec (-inf, -9.999999999999999167e-02, "trv"))); %! assert (isequal (decorationpart (infsupdec (-2.0, -1.0, "com") ./ infsupdec (0.0, 10.0, "com")){1}, decorationpart (infsupdec (-inf, -9.999999999999999167e-02, "trv")){1})); %! assert (isequal (rdivide (infsupdec (-2.0, -1.0, "com"), infsupdec (0.0, 10.0, "com")), infsupdec (-inf, -9.999999999999999167e-02, "trv"))); %! assert (isequal (decorationpart (rdivide (infsupdec (-2.0, -1.0, "com"), infsupdec (0.0, 10.0, "com"))){1}, decorationpart (infsupdec (-inf, -9.999999999999999167e-02, "trv")){1})); %!test %! assert (isequal (infsupdec (1.0, 3.0, "def") ./ infsupdec (-inf, -10.0, "dac"), infsupdec (-3.000000000000000444e-01, 0.0, "def"))); %! assert (isequal (decorationpart (infsupdec (1.0, 3.0, "def") ./ infsupdec (-inf, -10.0, "dac")){1}, decorationpart (infsupdec (-3.000000000000000444e-01, 0.0, "def")){1})); %! assert (isequal (rdivide (infsupdec (1.0, 3.0, "def"), infsupdec (-inf, -10.0, "dac")), infsupdec (-3.000000000000000444e-01, 0.0, "def"))); %! assert (isequal (decorationpart (rdivide (infsupdec (1.0, 3.0, "def"), infsupdec (-inf, -10.0, "dac"))){1}, decorationpart (infsupdec (-3.000000000000000444e-01, 0.0, "def")){1})); %!test %! assert (isequal (infsupdec (1.0, 2.0, "trv") ./ infsupdec (empty, "trv"), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (infsupdec (1.0, 2.0, "trv") ./ infsupdec (empty, "trv")){1}, decorationpart (infsupdec (empty, "trv")){1})); %! assert (isequal (rdivide (infsupdec (1.0, 2.0, "trv"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (rdivide (infsupdec (1.0, 2.0, "trv"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); ## minimal_recip_test %!test %! assert (isequal (1 ./ infsup (-50.0, -10.0), infsup (-1.000000000000000056e-01, -1.999999999999999695e-02))); %! assert (isequal (rdivide (1, infsup (-50.0, -10.0)), infsup (-1.000000000000000056e-01, -1.999999999999999695e-02))); %! assert (isequal (pown (infsup (-50.0, -10.0), -1), infsup (-1.000000000000000056e-01, -1.999999999999999695e-02))); %! assert (isequal (infsup (-50.0, -10.0) .^ -1, infsup (-1.000000000000000056e-01, -1.999999999999999695e-02))); %! assert (isequal (power (infsup (-50.0, -10.0), -1), infsup (-1.000000000000000056e-01, -1.999999999999999695e-02))); %! assert (isequal (infsup (-50.0, -10.0) ^ -1, infsup (-1.000000000000000056e-01, -1.999999999999999695e-02))); %! assert (isequal (mpower (infsup (-50.0, -10.0), -1), infsup (-1.000000000000000056e-01, -1.999999999999999695e-02))); %!test %! assert (isequal (1 ./ infsup (10.0, 50.0), infsup (1.999999999999999695e-02, 1.000000000000000056e-01))); %! assert (isequal (rdivide (1, infsup (10.0, 50.0)), infsup (1.999999999999999695e-02, 1.000000000000000056e-01))); %! assert (isequal (pown (infsup (10.0, 50.0), -1), infsup (1.999999999999999695e-02, 1.000000000000000056e-01))); %! assert (isequal (infsup (10.0, 50.0) .^ -1, infsup (1.999999999999999695e-02, 1.000000000000000056e-01))); %! assert (isequal (power (infsup (10.0, 50.0), -1), infsup (1.999999999999999695e-02, 1.000000000000000056e-01))); %! assert (isequal (infsup (10.0, 50.0) ^ -1, infsup (1.999999999999999695e-02, 1.000000000000000056e-01))); %! assert (isequal (mpower (infsup (10.0, 50.0), -1), infsup (1.999999999999999695e-02, 1.000000000000000056e-01))); %!test %! assert (isequal (1 ./ infsup (-inf, -10.0), infsup (-1.000000000000000056e-01, 0.0))); %! assert (isequal (rdivide (1, infsup (-inf, -10.0)), infsup (-1.000000000000000056e-01, 0.0))); %! assert (isequal (pown (infsup (-inf, -10.0), -1), infsup (-1.000000000000000056e-01, 0.0))); %! assert (isequal (infsup (-inf, -10.0) .^ -1, infsup (-1.000000000000000056e-01, 0.0))); %! assert (isequal (power (infsup (-inf, -10.0), -1), infsup (-1.000000000000000056e-01, 0.0))); %! assert (isequal (infsup (-inf, -10.0) ^ -1, infsup (-1.000000000000000056e-01, 0.0))); %! assert (isequal (mpower (infsup (-inf, -10.0), -1), infsup (-1.000000000000000056e-01, 0.0))); %!test %! assert (isequal (1 ./ infsup (10.0, inf), infsup (0.0, 1.000000000000000056e-01))); %! assert (isequal (rdivide (1, infsup (10.0, inf)), infsup (0.0, 1.000000000000000056e-01))); %! assert (isequal (pown (infsup (10.0, inf), -1), infsup (0.0, 1.000000000000000056e-01))); %! assert (isequal (infsup (10.0, inf) .^ -1, infsup (0.0, 1.000000000000000056e-01))); %! assert (isequal (power (infsup (10.0, inf), -1), infsup (0.0, 1.000000000000000056e-01))); %! assert (isequal (infsup (10.0, inf) ^ -1, infsup (0.0, 1.000000000000000056e-01))); %! assert (isequal (mpower (infsup (10.0, inf), -1), infsup (0.0, 1.000000000000000056e-01))); %!test %! assert (isequal (1 ./ infsup (0.0, 0.0), infsup)); %! assert (isequal (rdivide (1, infsup (0.0, 0.0)), infsup)); %! assert (isequal (pown (infsup (0.0, 0.0), -1), infsup)); %! assert (isequal (infsup (0.0, 0.0) .^ -1, infsup)); %! assert (isequal (power (infsup (0.0, 0.0), -1), infsup)); %! assert (isequal (infsup (0.0, 0.0) ^ -1, infsup)); %! assert (isequal (mpower (infsup (0.0, 0.0), -1), infsup)); %!test %! assert (isequal (1 ./ infsup (-0.0, -0.0), infsup)); %! assert (isequal (rdivide (1, infsup (-0.0, -0.0)), infsup)); %! assert (isequal (pown (infsup (-0.0, -0.0), -1), infsup)); %! assert (isequal (infsup (-0.0, -0.0) .^ -1, infsup)); %! assert (isequal (power (infsup (-0.0, -0.0), -1), infsup)); %! assert (isequal (infsup (-0.0, -0.0) ^ -1, infsup)); %! assert (isequal (mpower (infsup (-0.0, -0.0), -1), infsup)); %!test %! assert (isequal (1 ./ infsup (-10.0, 0.0), infsup (-inf, -9.999999999999999167e-02))); %! assert (isequal (rdivide (1, infsup (-10.0, 0.0)), infsup (-inf, -9.999999999999999167e-02))); %! assert (isequal (pown (infsup (-10.0, 0.0), -1), infsup (-inf, -9.999999999999999167e-02))); %! assert (isequal (infsup (-10.0, 0.0) .^ -1, infsup (-inf, -9.999999999999999167e-02))); %! assert (isequal (power (infsup (-10.0, 0.0), -1), infsup (-inf, -9.999999999999999167e-02))); %! assert (isequal (infsup (-10.0, 0.0) ^ -1, infsup (-inf, -9.999999999999999167e-02))); %! assert (isequal (mpower (infsup (-10.0, 0.0), -1), infsup (-inf, -9.999999999999999167e-02))); %!test %! assert (isequal (1 ./ infsup (-10.0, -0.0), infsup (-inf, -9.999999999999999167e-02))); %! assert (isequal (rdivide (1, infsup (-10.0, -0.0)), infsup (-inf, -9.999999999999999167e-02))); %! assert (isequal (pown (infsup (-10.0, -0.0), -1), infsup (-inf, -9.999999999999999167e-02))); %! assert (isequal (infsup (-10.0, -0.0) .^ -1, infsup (-inf, -9.999999999999999167e-02))); %! assert (isequal (power (infsup (-10.0, -0.0), -1), infsup (-inf, -9.999999999999999167e-02))); %! assert (isequal (infsup (-10.0, -0.0) ^ -1, infsup (-inf, -9.999999999999999167e-02))); %! assert (isequal (mpower (infsup (-10.0, -0.0), -1), infsup (-inf, -9.999999999999999167e-02))); %!test %! assert (isequal (1 ./ infsup (-10.0, 10.0), infsup (-inf, inf))); %! assert (isequal (rdivide (1, infsup (-10.0, 10.0)), infsup (-inf, inf))); %! assert (isequal (pown (infsup (-10.0, 10.0), -1), infsup (-inf, inf))); %! assert (isequal (infsup (-10.0, 10.0) .^ -1, infsup (-inf, inf))); %! assert (isequal (power (infsup (-10.0, 10.0), -1), infsup (-inf, inf))); %! assert (isequal (infsup (-10.0, 10.0) ^ -1, infsup (-inf, inf))); %! assert (isequal (mpower (infsup (-10.0, 10.0), -1), infsup (-inf, inf))); %!test %! assert (isequal (1 ./ infsup (0.0, 10.0), infsup (9.999999999999999167e-02, inf))); %! assert (isequal (rdivide (1, infsup (0.0, 10.0)), infsup (9.999999999999999167e-02, inf))); %! assert (isequal (pown (infsup (0.0, 10.0), -1), infsup (9.999999999999999167e-02, inf))); %! assert (isequal (infsup (0.0, 10.0) .^ -1, infsup (9.999999999999999167e-02, inf))); %! assert (isequal (power (infsup (0.0, 10.0), -1), infsup (9.999999999999999167e-02, inf))); %! assert (isequal (infsup (0.0, 10.0) ^ -1, infsup (9.999999999999999167e-02, inf))); %! assert (isequal (mpower (infsup (0.0, 10.0), -1), infsup (9.999999999999999167e-02, inf))); %!test %! assert (isequal (1 ./ infsup (-0.0, 10.0), infsup (9.999999999999999167e-02, inf))); %! assert (isequal (rdivide (1, infsup (-0.0, 10.0)), infsup (9.999999999999999167e-02, inf))); %! assert (isequal (pown (infsup (-0.0, 10.0), -1), infsup (9.999999999999999167e-02, inf))); %! assert (isequal (infsup (-0.0, 10.0) .^ -1, infsup (9.999999999999999167e-02, inf))); %! assert (isequal (power (infsup (-0.0, 10.0), -1), infsup (9.999999999999999167e-02, inf))); %! assert (isequal (infsup (-0.0, 10.0) ^ -1, infsup (9.999999999999999167e-02, inf))); %! assert (isequal (mpower (infsup (-0.0, 10.0), -1), infsup (9.999999999999999167e-02, inf))); %!test %! assert (isequal (1 ./ infsup (-inf, 0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (1, infsup (-inf, 0.0)), infsup (-inf, 0.0))); %! assert (isequal (pown (infsup (-inf, 0.0), -1), infsup (-inf, 0.0))); %! assert (isequal (infsup (-inf, 0.0) .^ -1, infsup (-inf, 0.0))); %! assert (isequal (power (infsup (-inf, 0.0), -1), infsup (-inf, 0.0))); %! assert (isequal (infsup (-inf, 0.0) ^ -1, infsup (-inf, 0.0))); %! assert (isequal (mpower (infsup (-inf, 0.0), -1), infsup (-inf, 0.0))); %!test %! assert (isequal (1 ./ infsup (-inf, -0.0), infsup (-inf, 0.0))); %! assert (isequal (rdivide (1, infsup (-inf, -0.0)), infsup (-inf, 0.0))); %! assert (isequal (pown (infsup (-inf, -0.0), -1), infsup (-inf, 0.0))); %! assert (isequal (infsup (-inf, -0.0) .^ -1, infsup (-inf, 0.0))); %! assert (isequal (power (infsup (-inf, -0.0), -1), infsup (-inf, 0.0))); %! assert (isequal (infsup (-inf, -0.0) ^ -1, infsup (-inf, 0.0))); %! assert (isequal (mpower (infsup (-inf, -0.0), -1), infsup (-inf, 0.0))); %!test %! assert (isequal (1 ./ infsup (-inf, 10.0), infsup (-inf, inf))); %! assert (isequal (rdivide (1, infsup (-inf, 10.0)), infsup (-inf, inf))); %! assert (isequal (pown (infsup (-inf, 10.0), -1), infsup (-inf, inf))); %! assert (isequal (infsup (-inf, 10.0) .^ -1, infsup (-inf, inf))); %! assert (isequal (power (infsup (-inf, 10.0), -1), infsup (-inf, inf))); %! assert (isequal (infsup (-inf, 10.0) ^ -1, infsup (-inf, inf))); %! assert (isequal (mpower (infsup (-inf, 10.0), -1), infsup (-inf, inf))); %!test %! assert (isequal (1 ./ infsup (-10.0, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (1, infsup (-10.0, inf)), infsup (-inf, inf))); %! assert (isequal (pown (infsup (-10.0, inf), -1), infsup (-inf, inf))); %! assert (isequal (infsup (-10.0, inf) .^ -1, infsup (-inf, inf))); %! assert (isequal (power (infsup (-10.0, inf), -1), infsup (-inf, inf))); %! assert (isequal (infsup (-10.0, inf) ^ -1, infsup (-inf, inf))); %! assert (isequal (mpower (infsup (-10.0, inf), -1), infsup (-inf, inf))); %!test %! assert (isequal (1 ./ infsup (0.0, inf), infsup (0.0, inf))); %! assert (isequal (rdivide (1, infsup (0.0, inf)), infsup (0.0, inf))); %! assert (isequal (pown (infsup (0.0, inf), -1), infsup (0.0, inf))); %! assert (isequal (infsup (0.0, inf) .^ -1, infsup (0.0, inf))); %! assert (isequal (power (infsup (0.0, inf), -1), infsup (0.0, inf))); %! assert (isequal (infsup (0.0, inf) ^ -1, infsup (0.0, inf))); %! assert (isequal (mpower (infsup (0.0, inf), -1), infsup (0.0, inf))); %!test %! assert (isequal (1 ./ infsup (-0.0, inf), infsup (0.0, inf))); %! assert (isequal (rdivide (1, infsup (-0.0, inf)), infsup (0.0, inf))); %! assert (isequal (pown (infsup (-0.0, inf), -1), infsup (0.0, inf))); %! assert (isequal (infsup (-0.0, inf) .^ -1, infsup (0.0, inf))); %! assert (isequal (power (infsup (-0.0, inf), -1), infsup (0.0, inf))); %! assert (isequal (infsup (-0.0, inf) ^ -1, infsup (0.0, inf))); %! assert (isequal (mpower (infsup (-0.0, inf), -1), infsup (0.0, inf))); %!test %! assert (isequal (1 ./ infsup (-inf, inf), infsup (-inf, inf))); %! assert (isequal (rdivide (1, infsup (-inf, inf)), infsup (-inf, inf))); %! assert (isequal (pown (infsup (-inf, inf), -1), infsup (-inf, inf))); %! assert (isequal (infsup (-inf, inf) .^ -1, infsup (-inf, inf))); %! assert (isequal (power (infsup (-inf, inf), -1), infsup (-inf, inf))); %! assert (isequal (infsup (-inf, inf) ^ -1, infsup (-inf, inf))); %! assert (isequal (mpower (infsup (-inf, inf), -1), infsup (-inf, inf))); ## minimal_recip_dec_test %!test %! assert (isequal (1 ./ infsupdec (10.0, 50.0, "com"), infsupdec (1.999999999999999695e-02, 1.000000000000000056e-01, "com"))); %! assert (isequal (decorationpart (1 ./ infsupdec (10.0, 50.0, "com")){1}, decorationpart (infsupdec (1.999999999999999695e-02, 1.000000000000000056e-01, "com")){1})); %! assert (isequal (rdivide (1, infsupdec (10.0, 50.0, "com")), infsupdec (1.999999999999999695e-02, 1.000000000000000056e-01, "com"))); %! assert (isequal (decorationpart (rdivide (1, infsupdec (10.0, 50.0, "com"))){1}, decorationpart (infsupdec (1.999999999999999695e-02, 1.000000000000000056e-01, "com")){1})); %! assert (isequal (pown (infsupdec (10.0, 50.0, "com"), -1), infsupdec (1.999999999999999695e-02, 1.000000000000000056e-01, "com"))); %! assert (isequal (decorationpart (pown (infsupdec (10.0, 50.0, "com"), -1)){1}, decorationpart (infsupdec (1.999999999999999695e-02, 1.000000000000000056e-01, "com")){1})); %! assert (isequal (infsupdec (10.0, 50.0, "com") .^ -1, infsupdec (1.999999999999999695e-02, 1.000000000000000056e-01, "com"))); %! assert (isequal (decorationpart (infsupdec (10.0, 50.0, "com") .^ -1){1}, decorationpart (infsupdec (1.999999999999999695e-02, 1.000000000000000056e-01, "com")){1})); %! assert (isequal (power (infsupdec (10.0, 50.0, "com"), -1), infsupdec (1.999999999999999695e-02, 1.000000000000000056e-01, "com"))); %! assert (isequal (decorationpart (power (infsupdec (10.0, 50.0, "com"), -1)){1}, decorationpart (infsupdec (1.999999999999999695e-02, 1.000000000000000056e-01, "com")){1})); %! assert (isequal (infsupdec (10.0, 50.0, "com") ^ -1, infsupdec (1.999999999999999695e-02, 1.000000000000000056e-01, "com"))); %! assert (isequal (decorationpart (infsupdec (10.0, 50.0, "com") ^ -1){1}, decorationpart (infsupdec (1.999999999999999695e-02, 1.000000000000000056e-01, "com")){1})); %! assert (isequal (mpower (infsupdec (10.0, 50.0, "com"), -1), infsupdec (1.999999999999999695e-02, 1.000000000000000056e-01, "com"))); %! assert (isequal (decorationpart (mpower (infsupdec (10.0, 50.0, "com"), -1)){1}, decorationpart (infsupdec (1.999999999999999695e-02, 1.000000000000000056e-01, "com")){1})); %!test %! assert (isequal (1 ./ infsupdec (-inf, -10.0, "dac"), infsupdec (-1.000000000000000056e-01, 0.0, "dac"))); %! assert (isequal (decorationpart (1 ./ infsupdec (-inf, -10.0, "dac")){1}, decorationpart (infsupdec (-1.000000000000000056e-01, 0.0, "dac")){1})); %! assert (isequal (rdivide (1, infsupdec (-inf, -10.0, "dac")), infsupdec (-1.000000000000000056e-01, 0.0, "dac"))); %! assert (isequal (decorationpart (rdivide (1, infsupdec (-inf, -10.0, "dac"))){1}, decorationpart (infsupdec (-1.000000000000000056e-01, 0.0, "dac")){1})); %! assert (isequal (pown (infsupdec (-inf, -10.0, "dac"), -1), infsupdec (-1.000000000000000056e-01, 0.0, "dac"))); %! assert (isequal (decorationpart (pown (infsupdec (-inf, -10.0, "dac"), -1)){1}, decorationpart (infsupdec (-1.000000000000000056e-01, 0.0, "dac")){1})); %! assert (isequal (infsupdec (-inf, -10.0, "dac") .^ -1, infsupdec (-1.000000000000000056e-01, 0.0, "dac"))); %! assert (isequal (decorationpart (infsupdec (-inf, -10.0, "dac") .^ -1){1}, decorationpart (infsupdec (-1.000000000000000056e-01, 0.0, "dac")){1})); %! assert (isequal (power (infsupdec (-inf, -10.0, "dac"), -1), infsupdec (-1.000000000000000056e-01, 0.0, "dac"))); %! assert (isequal (decorationpart (power (infsupdec (-inf, -10.0, "dac"), -1)){1}, decorationpart (infsupdec (-1.000000000000000056e-01, 0.0, "dac")){1})); %! assert (isequal (infsupdec (-inf, -10.0, "dac") ^ -1, infsupdec (-1.000000000000000056e-01, 0.0, "dac"))); %! assert (isequal (decorationpart (infsupdec (-inf, -10.0, "dac") ^ -1){1}, decorationpart (infsupdec (-1.000000000000000056e-01, 0.0, "dac")){1})); %! assert (isequal (mpower (infsupdec (-inf, -10.0, "dac"), -1), infsupdec (-1.000000000000000056e-01, 0.0, "dac"))); %! assert (isequal (decorationpart (mpower (infsupdec (-inf, -10.0, "dac"), -1)){1}, decorationpart (infsupdec (-1.000000000000000056e-01, 0.0, "dac")){1})); %!test %! assert (isequal (1 ./ infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "def"), infsupdec (-inf, -5.562684646268003458e-309, "def"))); %! assert (isequal (decorationpart (1 ./ infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "def")){1}, decorationpart (infsupdec (-inf, -5.562684646268003458e-309, "def")){1})); %! assert (isequal (rdivide (1, infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "def")), infsupdec (-inf, -5.562684646268003458e-309, "def"))); %! assert (isequal (decorationpart (rdivide (1, infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "def"))){1}, decorationpart (infsupdec (-inf, -5.562684646268003458e-309, "def")){1})); %! assert (isequal (pown (infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "def"), -1), infsupdec (-inf, -5.562684646268003458e-309, "def"))); %! assert (isequal (decorationpart (pown (infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "def"), -1)){1}, decorationpart (infsupdec (-inf, -5.562684646268003458e-309, "def")){1})); %! assert (isequal (infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "def") .^ -1, infsupdec (-inf, -5.562684646268003458e-309, "def"))); %! assert (isequal (decorationpart (infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "def") .^ -1){1}, decorationpart (infsupdec (-inf, -5.562684646268003458e-309, "def")){1})); %! assert (isequal (power (infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "def"), -1), infsupdec (-inf, -5.562684646268003458e-309, "def"))); %! assert (isequal (decorationpart (power (infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "def"), -1)){1}, decorationpart (infsupdec (-inf, -5.562684646268003458e-309, "def")){1})); %! assert (isequal (infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "def") ^ -1, infsupdec (-inf, -5.562684646268003458e-309, "def"))); %! assert (isequal (decorationpart (infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "def") ^ -1){1}, decorationpart (infsupdec (-inf, -5.562684646268003458e-309, "def")){1})); %! assert (isequal (mpower (infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "def"), -1), infsupdec (-inf, -5.562684646268003458e-309, "def"))); %! assert (isequal (decorationpart (mpower (infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "def"), -1)){1}, decorationpart (infsupdec (-inf, -5.562684646268003458e-309, "def")){1})); %!test %! assert (isequal (1 ./ infsupdec (0.0, 0.0, "com"), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (1 ./ infsupdec (0.0, 0.0, "com")){1}, decorationpart (infsupdec (empty, "trv")){1})); %! assert (isequal (rdivide (1, infsupdec (0.0, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (rdivide (1, infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %! assert (isequal (pown (infsupdec (0.0, 0.0, "com"), -1), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pown (infsupdec (0.0, 0.0, "com"), -1)){1}, decorationpart (infsupdec (empty, "trv")){1})); %! assert (isequal (infsupdec (0.0, 0.0, "com") .^ -1, infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (infsupdec (0.0, 0.0, "com") .^ -1){1}, decorationpart (infsupdec (empty, "trv")){1})); %! assert (isequal (power (infsupdec (0.0, 0.0, "com"), -1), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (power (infsupdec (0.0, 0.0, "com"), -1)){1}, decorationpart (infsupdec (empty, "trv")){1})); %! assert (isequal (infsupdec (0.0, 0.0, "com") ^ -1, infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (infsupdec (0.0, 0.0, "com") ^ -1){1}, decorationpart (infsupdec (empty, "trv")){1})); %! assert (isequal (mpower (infsupdec (0.0, 0.0, "com"), -1), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (mpower (infsupdec (0.0, 0.0, "com"), -1)){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (1 ./ infsupdec (-10.0, 0.0, "com"), infsupdec (-inf, -9.999999999999999167e-02, "trv"))); %! assert (isequal (decorationpart (1 ./ infsupdec (-10.0, 0.0, "com")){1}, decorationpart (infsupdec (-inf, -9.999999999999999167e-02, "trv")){1})); %! assert (isequal (rdivide (1, infsupdec (-10.0, 0.0, "com")), infsupdec (-inf, -9.999999999999999167e-02, "trv"))); %! assert (isequal (decorationpart (rdivide (1, infsupdec (-10.0, 0.0, "com"))){1}, decorationpart (infsupdec (-inf, -9.999999999999999167e-02, "trv")){1})); %! assert (isequal (pown (infsupdec (-10.0, 0.0, "com"), -1), infsupdec (-inf, -9.999999999999999167e-02, "trv"))); %! assert (isequal (decorationpart (pown (infsupdec (-10.0, 0.0, "com"), -1)){1}, decorationpart (infsupdec (-inf, -9.999999999999999167e-02, "trv")){1})); %! assert (isequal (infsupdec (-10.0, 0.0, "com") .^ -1, infsupdec (-inf, -9.999999999999999167e-02, "trv"))); %! assert (isequal (decorationpart (infsupdec (-10.0, 0.0, "com") .^ -1){1}, decorationpart (infsupdec (-inf, -9.999999999999999167e-02, "trv")){1})); %! assert (isequal (power (infsupdec (-10.0, 0.0, "com"), -1), infsupdec (-inf, -9.999999999999999167e-02, "trv"))); %! assert (isequal (decorationpart (power (infsupdec (-10.0, 0.0, "com"), -1)){1}, decorationpart (infsupdec (-inf, -9.999999999999999167e-02, "trv")){1})); %! assert (isequal (infsupdec (-10.0, 0.0, "com") ^ -1, infsupdec (-inf, -9.999999999999999167e-02, "trv"))); %! assert (isequal (decorationpart (infsupdec (-10.0, 0.0, "com") ^ -1){1}, decorationpart (infsupdec (-inf, -9.999999999999999167e-02, "trv")){1})); %! assert (isequal (mpower (infsupdec (-10.0, 0.0, "com"), -1), infsupdec (-inf, -9.999999999999999167e-02, "trv"))); %! assert (isequal (decorationpart (mpower (infsupdec (-10.0, 0.0, "com"), -1)){1}, decorationpart (infsupdec (-inf, -9.999999999999999167e-02, "trv")){1})); %!test %! assert (isequal (1 ./ infsupdec (-10.0, inf, "dac"), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (1 ./ infsupdec (-10.0, inf, "dac")){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (rdivide (1, infsupdec (-10.0, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (rdivide (1, infsupdec (-10.0, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (pown (infsupdec (-10.0, inf, "dac"), -1), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (pown (infsupdec (-10.0, inf, "dac"), -1)){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (infsupdec (-10.0, inf, "dac") .^ -1, infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (infsupdec (-10.0, inf, "dac") .^ -1){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (power (infsupdec (-10.0, inf, "dac"), -1), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (power (infsupdec (-10.0, inf, "dac"), -1)){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (infsupdec (-10.0, inf, "dac") ^ -1, infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (infsupdec (-10.0, inf, "dac") ^ -1){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (mpower (infsupdec (-10.0, inf, "dac"), -1), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (mpower (infsupdec (-10.0, inf, "dac"), -1)){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (1 ./ infsupdec (-0.0, inf, "dac"), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (1 ./ infsupdec (-0.0, inf, "dac")){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %! assert (isequal (rdivide (1, infsupdec (-0.0, inf, "dac")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (rdivide (1, infsupdec (-0.0, inf, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %! assert (isequal (pown (infsupdec (-0.0, inf, "dac"), -1), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pown (infsupdec (-0.0, inf, "dac"), -1)){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %! assert (isequal (infsupdec (-0.0, inf, "dac") .^ -1, infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (infsupdec (-0.0, inf, "dac") .^ -1){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %! assert (isequal (power (infsupdec (-0.0, inf, "dac"), -1), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (power (infsupdec (-0.0, inf, "dac"), -1)){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %! assert (isequal (infsupdec (-0.0, inf, "dac") ^ -1, infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (infsupdec (-0.0, inf, "dac") ^ -1){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %! assert (isequal (mpower (infsupdec (-0.0, inf, "dac"), -1), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (mpower (infsupdec (-0.0, inf, "dac"), -1)){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (1 ./ infsupdec (entire, "def"), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (1 ./ infsupdec (entire, "def")){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (rdivide (1, infsupdec (entire, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (rdivide (1, infsupdec (entire, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (pown (infsupdec (entire, "def"), -1), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (pown (infsupdec (entire, "def"), -1)){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (infsupdec (entire, "def") .^ -1, infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (infsupdec (entire, "def") .^ -1){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (power (infsupdec (entire, "def"), -1), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (power (infsupdec (entire, "def"), -1)){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (infsupdec (entire, "def") ^ -1, infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (infsupdec (entire, "def") ^ -1){1}, decorationpart (infsupdec (entire, "trv")){1})); %! assert (isequal (mpower (infsupdec (entire, "def"), -1), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (mpower (infsupdec (entire, "def"), -1)){1}, decorationpart (infsupdec (entire, "trv")){1})); ## minimal_sqr_test %!test %! assert (isequal (pown (infsup, 2), infsup)); %! assert (isequal (infsup .^ 2, infsup)); %! assert (isequal (power (infsup, 2), infsup)); %! assert (isequal (infsup ^ 2, infsup)); %! assert (isequal (mpower (infsup, 2), infsup)); %!test %! assert (isequal (pown (infsup (-inf, inf), 2), infsup (0.0, inf))); %! assert (isequal (infsup (-inf, inf) .^ 2, infsup (0.0, inf))); %! assert (isequal (power (infsup (-inf, inf), 2), infsup (0.0, inf))); %! assert (isequal (infsup (-inf, inf) ^ 2, infsup (0.0, inf))); %! assert (isequal (mpower (infsup (-inf, inf), 2), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-inf, -4.940656458412465442e-324), 2), infsup (0.0, inf))); %! assert (isequal (infsup (-inf, -4.940656458412465442e-324) .^ 2, infsup (0.0, inf))); %! assert (isequal (power (infsup (-inf, -4.940656458412465442e-324), 2), infsup (0.0, inf))); %! assert (isequal (infsup (-inf, -4.940656458412465442e-324) ^ 2, infsup (0.0, inf))); %! assert (isequal (mpower (infsup (-inf, -4.940656458412465442e-324), 2), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-1.0, 1.0), 2), infsup (0.0, 1.0))); %! assert (isequal (infsup (-1.0, 1.0) .^ 2, infsup (0.0, 1.0))); %! assert (isequal (power (infsup (-1.0, 1.0), 2), infsup (0.0, 1.0))); %! assert (isequal (infsup (-1.0, 1.0) ^ 2, infsup (0.0, 1.0))); %! assert (isequal (mpower (infsup (-1.0, 1.0), 2), infsup (0.0, 1.0))); %!test %! assert (isequal (pown (infsup (0.0, 1.0), 2), infsup (0.0, 1.0))); %! assert (isequal (infsup (0.0, 1.0) .^ 2, infsup (0.0, 1.0))); %! assert (isequal (power (infsup (0.0, 1.0), 2), infsup (0.0, 1.0))); %! assert (isequal (infsup (0.0, 1.0) ^ 2, infsup (0.0, 1.0))); %! assert (isequal (mpower (infsup (0.0, 1.0), 2), infsup (0.0, 1.0))); %!test %! assert (isequal (pown (infsup (-0.0, 1.0), 2), infsup (0.0, 1.0))); %! assert (isequal (infsup (-0.0, 1.0) .^ 2, infsup (0.0, 1.0))); %! assert (isequal (power (infsup (-0.0, 1.0), 2), infsup (0.0, 1.0))); %! assert (isequal (infsup (-0.0, 1.0) ^ 2, infsup (0.0, 1.0))); %! assert (isequal (mpower (infsup (-0.0, 1.0), 2), infsup (0.0, 1.0))); %!test %! assert (isequal (pown (infsup (-5.0, 3.0), 2), infsup (0.0, 25.0))); %! assert (isequal (infsup (-5.0, 3.0) .^ 2, infsup (0.0, 25.0))); %! assert (isequal (power (infsup (-5.0, 3.0), 2), infsup (0.0, 25.0))); %! assert (isequal (infsup (-5.0, 3.0) ^ 2, infsup (0.0, 25.0))); %! assert (isequal (mpower (infsup (-5.0, 3.0), 2), infsup (0.0, 25.0))); %!test %! assert (isequal (pown (infsup (-5.0, 0.0), 2), infsup (0.0, 25.0))); %! assert (isequal (infsup (-5.0, 0.0) .^ 2, infsup (0.0, 25.0))); %! assert (isequal (power (infsup (-5.0, 0.0), 2), infsup (0.0, 25.0))); %! assert (isequal (infsup (-5.0, 0.0) ^ 2, infsup (0.0, 25.0))); %! assert (isequal (mpower (infsup (-5.0, 0.0), 2), infsup (0.0, 25.0))); %!test %! assert (isequal (pown (infsup (-5.0, -0.0), 2), infsup (0.0, 25.0))); %! assert (isequal (infsup (-5.0, -0.0) .^ 2, infsup (0.0, 25.0))); %! assert (isequal (power (infsup (-5.0, -0.0), 2), infsup (0.0, 25.0))); %! assert (isequal (infsup (-5.0, -0.0) ^ 2, infsup (0.0, 25.0))); %! assert (isequal (mpower (infsup (-5.0, -0.0), 2), infsup (0.0, 25.0))); %!test %! assert (isequal (pown (infsup (1.000000000000000056e-01, 1.000000000000000056e-01), 2), infsup (1.000000000000000021e-02, 1.000000000000000194e-02))); %! assert (isequal (infsup (1.000000000000000056e-01, 1.000000000000000056e-01) .^ 2, infsup (1.000000000000000021e-02, 1.000000000000000194e-02))); %! assert (isequal (power (infsup (1.000000000000000056e-01, 1.000000000000000056e-01), 2), infsup (1.000000000000000021e-02, 1.000000000000000194e-02))); %! assert (isequal (infsup (1.000000000000000056e-01, 1.000000000000000056e-01) ^ 2, infsup (1.000000000000000021e-02, 1.000000000000000194e-02))); %! assert (isequal (mpower (infsup (1.000000000000000056e-01, 1.000000000000000056e-01), 2), infsup (1.000000000000000021e-02, 1.000000000000000194e-02))); %!test %! assert (isequal (pown (infsup (-1.999999999999996447e+00, 1.000000000000000056e-01), 2), infsup (0.0, 3.999999999999986233e+00))); %! assert (isequal (infsup (-1.999999999999996447e+00, 1.000000000000000056e-01) .^ 2, infsup (0.0, 3.999999999999986233e+00))); %! assert (isequal (power (infsup (-1.999999999999996447e+00, 1.000000000000000056e-01), 2), infsup (0.0, 3.999999999999986233e+00))); %! assert (isequal (infsup (-1.999999999999996447e+00, 1.000000000000000056e-01) ^ 2, infsup (0.0, 3.999999999999986233e+00))); %! assert (isequal (mpower (infsup (-1.999999999999996447e+00, 1.000000000000000056e-01), 2), infsup (0.0, 3.999999999999986233e+00))); %!test %! assert (isequal (pown (infsup (-1.999999999999996447e+00, -1.999999999999996447e+00), 2), infsup (3.999999999999985789e+00, 3.999999999999986233e+00))); %! assert (isequal (infsup (-1.999999999999996447e+00, -1.999999999999996447e+00) .^ 2, infsup (3.999999999999985789e+00, 3.999999999999986233e+00))); %! assert (isequal (power (infsup (-1.999999999999996447e+00, -1.999999999999996447e+00), 2), infsup (3.999999999999985789e+00, 3.999999999999986233e+00))); %! assert (isequal (infsup (-1.999999999999996447e+00, -1.999999999999996447e+00) ^ 2, infsup (3.999999999999985789e+00, 3.999999999999986233e+00))); %! assert (isequal (mpower (infsup (-1.999999999999996447e+00, -1.999999999999996447e+00), 2), infsup (3.999999999999985789e+00, 3.999999999999986233e+00))); ## minimal_sqr_dec_test %!test %! assert (isequal (pown (infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "com"), 2), infsupdec (0.0, inf, "dac"))); %! assert (isequal (decorationpart (pown (infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "com"), 2)){1}, decorationpart (infsupdec (0.0, inf, "dac")){1})); %! assert (isequal (infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "com") .^ 2, infsupdec (0.0, inf, "dac"))); %! assert (isequal (decorationpart (infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "com") .^ 2){1}, decorationpart (infsupdec (0.0, inf, "dac")){1})); %! assert (isequal (power (infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "com"), 2), infsupdec (0.0, inf, "dac"))); %! assert (isequal (decorationpart (power (infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "com"), 2)){1}, decorationpart (infsupdec (0.0, inf, "dac")){1})); %! assert (isequal (infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "com") ^ 2, infsupdec (0.0, inf, "dac"))); %! assert (isequal (decorationpart (infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "com") ^ 2){1}, decorationpart (infsupdec (0.0, inf, "dac")){1})); %! assert (isequal (mpower (infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "com"), 2), infsupdec (0.0, inf, "dac"))); %! assert (isequal (decorationpart (mpower (infsupdec (-1.797693134862315708e+308, -4.940656458412465442e-324, "com"), 2)){1}, decorationpart (infsupdec (0.0, inf, "dac")){1})); %!test %! assert (isequal (pown (infsupdec (-1.0, 1.0, "def"), 2), infsupdec (0.0, 1.0, "def"))); %! assert (isequal (decorationpart (pown (infsupdec (-1.0, 1.0, "def"), 2)){1}, decorationpart (infsupdec (0.0, 1.0, "def")){1})); %! assert (isequal (infsupdec (-1.0, 1.0, "def") .^ 2, infsupdec (0.0, 1.0, "def"))); %! assert (isequal (decorationpart (infsupdec (-1.0, 1.0, "def") .^ 2){1}, decorationpart (infsupdec (0.0, 1.0, "def")){1})); %! assert (isequal (power (infsupdec (-1.0, 1.0, "def"), 2), infsupdec (0.0, 1.0, "def"))); %! assert (isequal (decorationpart (power (infsupdec (-1.0, 1.0, "def"), 2)){1}, decorationpart (infsupdec (0.0, 1.0, "def")){1})); %! assert (isequal (infsupdec (-1.0, 1.0, "def") ^ 2, infsupdec (0.0, 1.0, "def"))); %! assert (isequal (decorationpart (infsupdec (-1.0, 1.0, "def") ^ 2){1}, decorationpart (infsupdec (0.0, 1.0, "def")){1})); %! assert (isequal (mpower (infsupdec (-1.0, 1.0, "def"), 2), infsupdec (0.0, 1.0, "def"))); %! assert (isequal (decorationpart (mpower (infsupdec (-1.0, 1.0, "def"), 2)){1}, decorationpart (infsupdec (0.0, 1.0, "def")){1})); %!test %! assert (isequal (pown (infsupdec (-5.0, 3.0, "com"), 2), infsupdec (0.0, 25.0, "com"))); %! assert (isequal (decorationpart (pown (infsupdec (-5.0, 3.0, "com"), 2)){1}, decorationpart (infsupdec (0.0, 25.0, "com")){1})); %! assert (isequal (infsupdec (-5.0, 3.0, "com") .^ 2, infsupdec (0.0, 25.0, "com"))); %! assert (isequal (decorationpart (infsupdec (-5.0, 3.0, "com") .^ 2){1}, decorationpart (infsupdec (0.0, 25.0, "com")){1})); %! assert (isequal (power (infsupdec (-5.0, 3.0, "com"), 2), infsupdec (0.0, 25.0, "com"))); %! assert (isequal (decorationpart (power (infsupdec (-5.0, 3.0, "com"), 2)){1}, decorationpart (infsupdec (0.0, 25.0, "com")){1})); %! assert (isequal (infsupdec (-5.0, 3.0, "com") ^ 2, infsupdec (0.0, 25.0, "com"))); %! assert (isequal (decorationpart (infsupdec (-5.0, 3.0, "com") ^ 2){1}, decorationpart (infsupdec (0.0, 25.0, "com")){1})); %! assert (isequal (mpower (infsupdec (-5.0, 3.0, "com"), 2), infsupdec (0.0, 25.0, "com"))); %! assert (isequal (decorationpart (mpower (infsupdec (-5.0, 3.0, "com"), 2)){1}, decorationpart (infsupdec (0.0, 25.0, "com")){1})); %!test %! assert (isequal (pown (infsupdec (1.000000000000000056e-01, 1.000000000000000056e-01, "com"), 2), infsupdec (1.000000000000000021e-02, 1.000000000000000194e-02, "com"))); %! assert (isequal (decorationpart (pown (infsupdec (1.000000000000000056e-01, 1.000000000000000056e-01, "com"), 2)){1}, decorationpart (infsupdec (1.000000000000000021e-02, 1.000000000000000194e-02, "com")){1})); %! assert (isequal (infsupdec (1.000000000000000056e-01, 1.000000000000000056e-01, "com") .^ 2, infsupdec (1.000000000000000021e-02, 1.000000000000000194e-02, "com"))); %! assert (isequal (decorationpart (infsupdec (1.000000000000000056e-01, 1.000000000000000056e-01, "com") .^ 2){1}, decorationpart (infsupdec (1.000000000000000021e-02, 1.000000000000000194e-02, "com")){1})); %! assert (isequal (power (infsupdec (1.000000000000000056e-01, 1.000000000000000056e-01, "com"), 2), infsupdec (1.000000000000000021e-02, 1.000000000000000194e-02, "com"))); %! assert (isequal (decorationpart (power (infsupdec (1.000000000000000056e-01, 1.000000000000000056e-01, "com"), 2)){1}, decorationpart (infsupdec (1.000000000000000021e-02, 1.000000000000000194e-02, "com")){1})); %! assert (isequal (infsupdec (1.000000000000000056e-01, 1.000000000000000056e-01, "com") ^ 2, infsupdec (1.000000000000000021e-02, 1.000000000000000194e-02, "com"))); %! assert (isequal (decorationpart (infsupdec (1.000000000000000056e-01, 1.000000000000000056e-01, "com") ^ 2){1}, decorationpart (infsupdec (1.000000000000000021e-02, 1.000000000000000194e-02, "com")){1})); %! assert (isequal (mpower (infsupdec (1.000000000000000056e-01, 1.000000000000000056e-01, "com"), 2), infsupdec (1.000000000000000021e-02, 1.000000000000000194e-02, "com"))); %! assert (isequal (decorationpart (mpower (infsupdec (1.000000000000000056e-01, 1.000000000000000056e-01, "com"), 2)){1}, decorationpart (infsupdec (1.000000000000000021e-02, 1.000000000000000194e-02, "com")){1})); ## minimal_sqrt_test %!test %! assert (isequal (realsqrt (infsup), infsup)); %!test %! assert (isequal (realsqrt (infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (realsqrt (infsup (-inf, -4.940656458412465442e-324)), infsup)); %!test %! assert (isequal (realsqrt (infsup (-1.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (realsqrt (infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (realsqrt (infsup (-0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (realsqrt (infsup (-5.0, 25.0)), infsup (0.0, 5.0))); %!test %! assert (isequal (realsqrt (infsup (0.0, 25.0)), infsup (0.0, 5.0))); %!test %! assert (isequal (realsqrt (infsup (-0.0, 25.0)), infsup (0.0, 5.0))); %!test %! assert (isequal (realsqrt (infsup (-5.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (realsqrt (infsup (1.000000000000000056e-01, 1.000000000000000056e-01)), infsup (3.162277660168379412e-01, 3.162277660168379967e-01))); %!test %! assert (isequal (realsqrt (infsup (-1.999999999999996447e+00, 1.000000000000000056e-01)), infsup (0.0, 3.162277660168379967e-01))); %!test %! assert (isequal (realsqrt (infsup (1.000000000000000056e-01, 1.999999999999996447e+00)), infsup (3.162277660168379412e-01, 1.414213562373093813e+00))); ## minimal_sqrt_dec_test %!test %! assert (isequal (realsqrt (infsupdec (1.0, 4.0, "com")), infsupdec (1.0, 2.0, "com"))); %! assert (isequal (decorationpart (realsqrt (infsupdec (1.0, 4.0, "com"))){1}, decorationpart (infsupdec (1.0, 2.0, "com")){1})); %!test %! assert (isequal (realsqrt (infsupdec (-5.0, 25.0, "com")), infsupdec (0.0, 5.0, "trv"))); %! assert (isequal (decorationpart (realsqrt (infsupdec (-5.0, 25.0, "com"))){1}, decorationpart (infsupdec (0.0, 5.0, "trv")){1})); %!test %! assert (isequal (realsqrt (infsupdec (0.0, 25.0, "def")), infsupdec (0.0, 5.0, "def"))); %! assert (isequal (decorationpart (realsqrt (infsupdec (0.0, 25.0, "def"))){1}, decorationpart (infsupdec (0.0, 5.0, "def")){1})); %!test %! assert (isequal (realsqrt (infsupdec (-5.0, inf, "dac")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (realsqrt (infsupdec (-5.0, inf, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); ## minimal_fma_test %!test %! assert (isequal (fma (infsup, infsup, infsup), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, 1.0), infsup, infsup), infsup)); %!test %! assert (isequal (fma (infsup, infsup (-1.0, 1.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup, infsup (-inf, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup, infsup), infsup)); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup, infsup), infsup)); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup, infsup), infsup)); %!test %! assert (isequal (fma (infsup, infsup (0.0, 0.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup, infsup (-0.0, -0.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (0.0, 0.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-0.0, -0.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-5.0, -1.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-5.0, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (1.0, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-inf, -1.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-inf, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-5.0, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (1.0, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-inf, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (0.0, 0.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-0.0, -0.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-5.0, -1.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-5.0, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (1.0, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-inf, -1.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-inf, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-5.0, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (1.0, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-inf, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (0.0, 0.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-0.0, -0.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-5.0, -1.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-5.0, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (1.0, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-inf, -1.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-inf, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-5.0, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (1.0, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-inf, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (0.0, 0.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-0.0, -0.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-5.0, -1.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-5.0, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (1.0, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-inf, -1.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-inf, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-5.0, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (1.0, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-inf, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (0.0, 0.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-0.0, -0.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-5.0, -1.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-5.0, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (1.0, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-inf, -1.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-inf, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-5.0, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (1.0, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-inf, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (0.0, 0.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-0.0, -0.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-5.0, -1.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-5.0, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (1.0, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-inf, -1.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-inf, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-5.0, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (1.0, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-inf, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (0.0, 0.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-0.0, -0.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-5.0, -1.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-5.0, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (1.0, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-inf, -1.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-inf, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-5.0, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (1.0, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-inf, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (0.0, 0.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-0.0, -0.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-5.0, -1.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-5.0, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (1.0, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-inf, -1.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-inf, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-5.0, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (1.0, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-inf, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (0.0, 0.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-0.0, -0.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-5.0, -1.0), infsup), infsup)); %!#min max %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-5.0, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-10.0, 2.0), infsup (-5.0, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-1.0, 10.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-2.0, 2.0), infsup (-5.0, 3.0), infsup), infsup)); %!#end min max %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (1.0, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-inf, -1.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-inf, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-5.0, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (1.0, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-inf, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (0.0, 0.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-0.0, -0.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-5.0, -1.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-5.0, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (1.0, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-inf, -1.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-inf, 3.0), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-5.0, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (1.0, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-inf, inf), infsup), infsup)); %!test %! assert (isequal (fma (infsup, infsup, infsup (-inf, 2.0)), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, 1.0), infsup, infsup (-inf, 2.0)), infsup)); %!test %! assert (isequal (fma (infsup, infsup (-1.0, 1.0), infsup (-inf, 2.0)), infsup)); %!test %! assert (isequal (fma (infsup, infsup (-inf, inf), infsup (-inf, 2.0)), infsup)); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup, infsup (-inf, 2.0)), infsup)); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup, infsup (-inf, 2.0)), infsup)); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup, infsup (-inf, 2.0)), infsup)); %!test %! assert (isequal (fma (infsup, infsup (0.0, 0.0), infsup (-inf, 2.0)), infsup)); %!test %! assert (isequal (fma (infsup, infsup (-0.0, -0.0), infsup (-inf, 2.0)), infsup)); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (0.0, 0.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-0.0, -0.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-5.0, -1.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-5.0, 3.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (1.0, 3.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-inf, -1.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-inf, 3.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-5.0, inf), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (1.0, inf), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-inf, inf), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (0.0, 0.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-0.0, -0.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-5.0, -1.0), infsup (-inf, 2.0)), infsup (-inf, 1.0))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-5.0, 3.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (1.0, 3.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-inf, -1.0), infsup (-inf, 2.0)), infsup (-inf, 1.0))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-inf, 3.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-5.0, inf), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (1.0, inf), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-inf, inf), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (0.0, 0.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-0.0, -0.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-5.0, -1.0), infsup (-inf, 2.0)), infsup (-inf, 7.0))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-5.0, 3.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (1.0, 3.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-inf, -1.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-inf, 3.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-5.0, inf), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (1.0, inf), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-inf, inf), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (0.0, 0.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-0.0, -0.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-5.0, -1.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-5.0, 3.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (1.0, 3.0), infsup (-inf, 2.0)), infsup (-inf, 11.0))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-inf, -1.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-inf, 3.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-5.0, inf), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (1.0, inf), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-inf, inf), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (0.0, 0.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-0.0, -0.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-5.0, -1.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-5.0, 3.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (1.0, 3.0), infsup (-inf, 2.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-inf, -1.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-inf, 3.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-5.0, inf), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (1.0, inf), infsup (-inf, 2.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-inf, inf), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (0.0, 0.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-0.0, -0.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-5.0, -1.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-5.0, 3.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (1.0, 3.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-inf, -1.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-inf, 3.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-5.0, inf), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (1.0, inf), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-inf, inf), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (0.0, 0.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-0.0, -0.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-5.0, -1.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-5.0, 3.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (1.0, 3.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-inf, -1.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-inf, 3.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-5.0, inf), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (1.0, inf), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-inf, inf), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (0.0, 0.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-0.0, -0.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-5.0, -1.0), infsup (-inf, 2.0)), infsup (-inf, 1.0))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-5.0, 3.0), infsup (-inf, 2.0)), infsup (-inf, 17.0))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (1.0, 3.0), infsup (-inf, 2.0)), infsup (-inf, 17.0))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-inf, -1.0), infsup (-inf, 2.0)), infsup (-inf, 1.0))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-inf, 3.0), infsup (-inf, 2.0)), infsup (-inf, 17.0))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-5.0, inf), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (1.0, inf), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-inf, inf), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (0.0, 0.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-0.0, -0.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-5.0, -1.0), infsup (-inf, 2.0)), infsup (-inf, 7.0))); %!#min max %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-5.0, 3.0), infsup (-inf, 2.0)), infsup (-inf, 17.0))); %!test %! assert (isequal (fma (infsup (-10.0, 2.0), infsup (-5.0, 3.0), infsup (-inf, 2.0)), infsup (-inf, 52.0))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-1.0, 10.0), infsup (-inf, 2.0)), infsup (-inf, 52.0))); %!test %! assert (isequal (fma (infsup (-2.0, 2.0), infsup (-5.0, 3.0), infsup (-inf, 2.0)), infsup (-inf, 12.0))); %!#end min max %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (1.0, 3.0), infsup (-inf, 2.0)), infsup (-inf, 17.0))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-inf, -1.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-inf, 3.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-5.0, inf), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (1.0, inf), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-inf, inf), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (0.0, 0.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-0.0, -0.0), infsup (-inf, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-5.0, -1.0), infsup (-inf, 2.0)), infsup (-inf, 52.0))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-5.0, 3.0), infsup (-inf, 2.0)), infsup (-inf, 52.0))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (1.0, 3.0), infsup (-inf, 2.0)), infsup (-inf, -3.0))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-inf, -1.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-inf, 3.0), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-5.0, inf), infsup (-inf, 2.0)), infsup (-inf, 52.0))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (1.0, inf), infsup (-inf, 2.0)), infsup (-inf, -3.0))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-inf, inf), infsup (-inf, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup, infsup, infsup (-2.0, 2.0)), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, 1.0), infsup, infsup (-2.0, 2.0)), infsup)); %!test %! assert (isequal (fma (infsup, infsup (-1.0, 1.0), infsup (-2.0, 2.0)), infsup)); %!test %! assert (isequal (fma (infsup, infsup (-inf, inf), infsup (-2.0, 2.0)), infsup)); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup, infsup (-2.0, 2.0)), infsup)); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup, infsup (-2.0, 2.0)), infsup)); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup, infsup (-2.0, 2.0)), infsup)); %!test %! assert (isequal (fma (infsup, infsup (0.0, 0.0), infsup (-2.0, 2.0)), infsup)); %!test %! assert (isequal (fma (infsup, infsup (-0.0, -0.0), infsup (-2.0, 2.0)), infsup)); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (0.0, 0.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-0.0, -0.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-5.0, -1.0), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-5.0, 3.0), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (1.0, 3.0), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-inf, -1.0), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-inf, 3.0), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-5.0, inf), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (1.0, inf), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-inf, inf), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (0.0, 0.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-0.0, -0.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-5.0, -1.0), infsup (-2.0, 2.0)), infsup (-inf, 1.0))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-5.0, 3.0), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (1.0, 3.0), infsup (-2.0, 2.0)), infsup (-1.0, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-inf, -1.0), infsup (-2.0, 2.0)), infsup (-inf, 1.0))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-inf, 3.0), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-5.0, inf), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (1.0, inf), infsup (-2.0, 2.0)), infsup (-1.0, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-inf, inf), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (0.0, 0.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-0.0, -0.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-5.0, -1.0), infsup (-2.0, 2.0)), infsup (-inf, 7.0))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-5.0, 3.0), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (1.0, 3.0), infsup (-2.0, 2.0)), infsup (-5.0, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-inf, -1.0), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-inf, 3.0), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-5.0, inf), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (1.0, inf), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-inf, inf), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (0.0, 0.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-0.0, -0.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-5.0, -1.0), infsup (-2.0, 2.0)), infsup (-17.0, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-5.0, 3.0), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (1.0, 3.0), infsup (-2.0, 2.0)), infsup (-inf, 11.0))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-inf, -1.0), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-inf, 3.0), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-5.0, inf), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (1.0, inf), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-inf, inf), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (0.0, 0.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-0.0, -0.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-5.0, -1.0), infsup (-2.0, 2.0)), infsup (1.0, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-5.0, 3.0), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (1.0, 3.0), infsup (-2.0, 2.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-inf, -1.0), infsup (-2.0, 2.0)), infsup (1.0, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-inf, 3.0), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-5.0, inf), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (1.0, inf), infsup (-2.0, 2.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-inf, inf), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (0.0, 0.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-0.0, -0.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-5.0, -1.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-5.0, 3.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (1.0, 3.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-inf, -1.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-inf, 3.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-5.0, inf), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (1.0, inf), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-inf, inf), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (0.0, 0.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-0.0, -0.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-5.0, -1.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-5.0, 3.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (1.0, 3.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-inf, -1.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-inf, 3.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-5.0, inf), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (1.0, inf), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-inf, inf), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (0.0, 0.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-0.0, -0.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-5.0, -1.0), infsup (-2.0, 2.0)), infsup (-27.0, 1.0))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-5.0, 3.0), infsup (-2.0, 2.0)), infsup (-27.0, 17.0))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (1.0, 3.0), infsup (-2.0, 2.0)), infsup (-1.0, 17.0))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-inf, -1.0), infsup (-2.0, 2.0)), infsup (-inf, 1.0))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-inf, 3.0), infsup (-2.0, 2.0)), infsup (-inf, 17.0))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-5.0, inf), infsup (-2.0, 2.0)), infsup (-27.0, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (1.0, inf), infsup (-2.0, 2.0)), infsup (-1.0, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-inf, inf), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (0.0, 0.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-0.0, -0.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-5.0, -1.0), infsup (-2.0, 2.0)), infsup (-27.0, 7.0))); %!#min max %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-5.0, 3.0), infsup (-2.0, 2.0)), infsup (-27.0, 17.0))); %!test %! assert (isequal (fma (infsup (-10.0, 2.0), infsup (-5.0, 3.0), infsup (-2.0, 2.0)), infsup (-32.0, 52.0))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-1.0, 10.0), infsup (-2.0, 2.0)), infsup (-12.0, 52.0))); %!test %! assert (isequal (fma (infsup (-2.0, 2.0), infsup (-5.0, 3.0), infsup (-2.0, 2.0)), infsup (-12.0, 12.0))); %!#end min max %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (1.0, 3.0), infsup (-2.0, 2.0)), infsup (-5.0, 17.0))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-inf, -1.0), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-inf, 3.0), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-5.0, inf), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (1.0, inf), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-inf, inf), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (0.0, 0.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-0.0, -0.0), infsup (-2.0, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-5.0, -1.0), infsup (-2.0, 2.0)), infsup (3.0, 52.0))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-5.0, 3.0), infsup (-2.0, 2.0)), infsup (-32.0, 52.0))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (1.0, 3.0), infsup (-2.0, 2.0)), infsup (-32.0, -3.0))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-inf, -1.0), infsup (-2.0, 2.0)), infsup (3.0, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-inf, 3.0), infsup (-2.0, 2.0)), infsup (-32.0, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-5.0, inf), infsup (-2.0, 2.0)), infsup (-inf, 52.0))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (1.0, inf), infsup (-2.0, 2.0)), infsup (-inf, -3.0))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-inf, inf), infsup (-2.0, 2.0)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup, infsup, infsup (-2.0, inf)), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, 1.0), infsup, infsup (-2.0, inf)), infsup)); %!test %! assert (isequal (fma (infsup, infsup (-1.0, 1.0), infsup (-2.0, inf)), infsup)); %!test %! assert (isequal (fma (infsup, infsup (-inf, inf), infsup (-2.0, inf)), infsup)); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup, infsup (-2.0, inf)), infsup)); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup, infsup (-2.0, inf)), infsup)); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup, infsup (-2.0, inf)), infsup)); %!test %! assert (isequal (fma (infsup, infsup (0.0, 0.0), infsup (-2.0, inf)), infsup)); %!test %! assert (isequal (fma (infsup, infsup (-0.0, -0.0), infsup (-2.0, inf)), infsup)); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (0.0, 0.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-0.0, -0.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-5.0, -1.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-5.0, 3.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (1.0, 3.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-inf, -1.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-inf, 3.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-5.0, inf), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (1.0, inf), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-inf, inf), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (0.0, 0.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-0.0, -0.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-5.0, -1.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-5.0, 3.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (1.0, 3.0), infsup (-2.0, inf)), infsup (-1.0, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-inf, -1.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-inf, 3.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-5.0, inf), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (1.0, inf), infsup (-2.0, inf)), infsup (-1.0, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-inf, inf), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (0.0, 0.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-0.0, -0.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-5.0, -1.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-5.0, 3.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (1.0, 3.0), infsup (-2.0, inf)), infsup (-5.0, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-inf, -1.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-inf, 3.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-5.0, inf), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (1.0, inf), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-inf, inf), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (0.0, 0.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-0.0, -0.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-5.0, -1.0), infsup (-2.0, inf)), infsup (-17.0, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-5.0, 3.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (1.0, 3.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-inf, -1.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-inf, 3.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-5.0, inf), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (1.0, inf), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-inf, inf), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (0.0, 0.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-0.0, -0.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-5.0, -1.0), infsup (-2.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-5.0, 3.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (1.0, 3.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-inf, -1.0), infsup (-2.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-inf, 3.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-5.0, inf), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (1.0, inf), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-inf, inf), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (0.0, 0.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-0.0, -0.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-5.0, -1.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-5.0, 3.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (1.0, 3.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-inf, -1.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-inf, 3.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-5.0, inf), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (1.0, inf), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-inf, inf), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (0.0, 0.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-0.0, -0.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-5.0, -1.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-5.0, 3.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (1.0, 3.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-inf, -1.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-inf, 3.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-5.0, inf), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (1.0, inf), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-inf, inf), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (0.0, 0.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-0.0, -0.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-5.0, -1.0), infsup (-2.0, inf)), infsup (-27.0, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-5.0, 3.0), infsup (-2.0, inf)), infsup (-27.0, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (1.0, 3.0), infsup (-2.0, inf)), infsup (-1.0, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-inf, -1.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-inf, 3.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-5.0, inf), infsup (-2.0, inf)), infsup (-27.0, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (1.0, inf), infsup (-2.0, inf)), infsup (-1.0, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-inf, inf), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-0.0, -0.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (0.0, 0.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-5.0, -1.0), infsup (-2.0, inf)), infsup (-27.0, inf))); %!#min max %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-5.0, 3.0), infsup (-2.0, inf)), infsup (-27.0, inf))); %!test %! assert (isequal (fma (infsup (-10.0, 2.0), infsup (-5.0, 3.0), infsup (-2.0, inf)), infsup (-32.0, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-1.0, 10.0), infsup (-2.0, inf)), infsup (-12.0, inf))); %!test %! assert (isequal (fma (infsup (-2.0, 2.0), infsup (-5.0, 3.0), infsup (-2.0, inf)), infsup (-12.0, inf))); %!#end min max %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (1.0, 3.0), infsup (-2.0, inf)), infsup (-5.0, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-inf, -1.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-inf, 3.0), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-5.0, inf), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (1.0, inf), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-inf, inf), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (0.0, 0.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-0.0, -0.0), infsup (-2.0, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-5.0, -1.0), infsup (-2.0, inf)), infsup (3.0, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-5.0, 3.0), infsup (-2.0, inf)), infsup (-32.0, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (1.0, 3.0), infsup (-2.0, inf)), infsup (-32.0, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-inf, -1.0), infsup (-2.0, inf)), infsup (3.0, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-inf, 3.0), infsup (-2.0, inf)), infsup (-32.0, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-5.0, inf), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (1.0, inf), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-inf, inf), infsup (-2.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup, infsup, infsup (-inf, inf)), infsup)); %!test %! assert (isequal (fma (infsup (-1.0, 1.0), infsup, infsup (-inf, inf)), infsup)); %!test %! assert (isequal (fma (infsup, infsup (-1.0, 1.0), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (fma (infsup, infsup (-inf, inf), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup, infsup (-inf, inf)), infsup)); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup, infsup (-inf, inf)), infsup)); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup, infsup (-inf, inf)), infsup)); %!test %! assert (isequal (fma (infsup, infsup (0.0, 0.0), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (fma (infsup, infsup (-0.0, -0.0), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (0.0, 0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-0.0, -0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-5.0, -1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-5.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (1.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-inf, -1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-inf, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-5.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, inf), infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (0.0, 0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-0.0, -0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-5.0, -1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-5.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (1.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-inf, -1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-inf, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-5.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, inf), infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (0.0, 0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-0.0, -0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-5.0, -1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-5.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (1.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-inf, -1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-inf, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-5.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, inf), infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (0.0, 0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-0.0, -0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-5.0, -1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-5.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (1.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-inf, -1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-inf, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-5.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, 3.0), infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (0.0, 0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-0.0, -0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-5.0, -1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-5.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (1.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-inf, -1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-inf, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-5.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-inf, -3.0), infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (0.0, 0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-0.0, -0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-5.0, -1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-5.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (1.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-inf, -1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-inf, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-5.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (0.0, 0.0), infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (0.0, 0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-0.0, -0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-5.0, -1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-5.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (1.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-inf, -1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-inf, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-5.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-0.0, -0.0), infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (0.0, 0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-0.0, -0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-5.0, -1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-5.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (1.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-inf, -1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-inf, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-5.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (1.0, 5.0), infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (0.0, 0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-0.0, -0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-5.0, -1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!#min max %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-5.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-10.0, 2.0), infsup (-5.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-1.0, 10.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-2.0, 2.0), infsup (-5.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!#end min max %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (1.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-inf, -1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-inf, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-5.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-1.0, 5.0), infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (0.0, 0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-0.0, -0.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-5.0, -1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-5.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (1.0, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-inf, -1.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-inf, 3.0), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-5.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (-10.0, -5.0), infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fma (infsup (0.1, 0.5), infsup (-5.0, 3.0), infsup (-0.1, 0.1)), infsup (-2.600000000000000089e+00, 1.600000000000000089e+00))); %!test %! assert (isequal (fma (infsup (-0.5, 0.2), infsup (-5.0, 3.0), infsup (-0.1, 0.1)), infsup (-1.600000000000000089e+00, 2.600000000000000089e+00))); %!test %! assert (isequal (fma (infsup (-0.5, -0.1), infsup (2.0, 3.0), infsup (-0.1, 0.1)), infsup (-1.600000000000000089e+00, -1.000000000000000056e-01))); %!test %! assert (isequal (fma (infsup (-0.5, -0.1), infsup (-inf, 3.0), infsup (-0.1, 0.1)), infsup (-1.600000000000000089e+00, inf))); ## minimal_fma_dec_test %!test %! assert (isequal (fma (infsupdec (-0.5, -0.1, "com"), infsupdec (-inf, 3.0, "dac"), infsupdec (-0.1, 0.1, "com")), infsupdec (-1.600000000000000089e+00, inf, "dac"))); %! assert (isequal (decorationpart (fma (infsupdec (-0.5, -0.1, "com"), infsupdec (-inf, 3.0, "dac"), infsupdec (-0.1, 0.1, "com"))){1}, decorationpart (infsupdec (-1.600000000000000089e+00, inf, "dac")){1})); %!test %! assert (isequal (fma (infsupdec (1.0, 2.0, "com"), infsupdec (1.0, 1.797693134862315708e+308, "com"), infsupdec (0.0, 1.0, "com")), infsupdec (1.0, inf, "dac"))); %! assert (isequal (decorationpart (fma (infsupdec (1.0, 2.0, "com"), infsupdec (1.0, 1.797693134862315708e+308, "com"), infsupdec (0.0, 1.0, "com"))){1}, decorationpart (infsupdec (1.0, inf, "dac")){1})); %!test %! assert (isequal (fma (infsupdec (1.0, 2.0, "com"), infsupdec (1.0, 2.0, "com"), infsupdec (2.0, 5.0, "com")), infsupdec (3.0, 9.0, "com"))); %! assert (isequal (decorationpart (fma (infsupdec (1.0, 2.0, "com"), infsupdec (1.0, 2.0, "com"), infsupdec (2.0, 5.0, "com"))){1}, decorationpart (infsupdec (3.0, 9.0, "com")){1})); ## minimal_pown_test %!test %! assert (isequal (pown (infsup, 0), infsup)); %!test %! assert (isequal (pown (infsup (-inf, inf), 0), infsup (1.0, 1.0))); %!test %! assert (isequal (pown (infsup (0.0, 0.0), 0), infsup (1.0, 1.0))); %!test %! assert (isequal (pown (infsup (-0.0, -0.0), 0), infsup (1.0, 1.0))); %!test %! assert (isequal (pown (infsup (13.1, 13.1), 0), infsup (1.0, 1.0))); %!test %! assert (isequal (pown (infsup (-7451.145, -7451.145), 0), infsup (1.0, 1.0))); %!test %! assert (isequal (pown (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), 0), infsup (1.0, 1.0))); %!test %! assert (isequal (pown (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308), 0), infsup (1.0, 1.0))); %!test %! assert (isequal (pown (infsup (0.0, inf), 0), infsup (1.0, 1.0))); %!test %! assert (isequal (pown (infsup (-0.0, inf), 0), infsup (1.0, 1.0))); %!test %! assert (isequal (pown (infsup (-inf, 0.0), 0), infsup (1.0, 1.0))); %!test %! assert (isequal (pown (infsup (-inf, -0.0), 0), infsup (1.0, 1.0))); %!test %! assert (isequal (pown (infsup (-324.3, 2.5), 0), infsup (1.0, 1.0))); %!test %! assert (isequal (pown (infsup, 2), infsup)); %!test %! assert (isequal (pown (infsup (-inf, inf), 2), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (0.0, 0.0), 2), infsup (0.0, 0.0))); %!test %! assert (isequal (pown (infsup (-0.0, -0.0), 2), infsup (0.0, 0.0))); %!test %! assert (isequal (pown (infsup (13.1, 13.1), 2), infsup (1.716099999999999852e+02, 1.716100000000000136e+02))); %!test %! assert (isequal (pown (infsup (-7451.145, -7451.145), 2), infsup (5.551956181102500111e+07, 5.551956181102500856e+07))); %!test %! assert (isequal (pown (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), 2), infsup (1.797693134862315708e+308, inf))); %!test %! assert (isequal (pown (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308), 2), infsup (1.797693134862315708e+308, inf))); %!test %! assert (isequal (pown (infsup (0.0, inf), 2), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-0.0, inf), 2), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-inf, 0.0), 2), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-inf, -0.0), 2), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-324.3, 2.5), 2), infsup (0.0, 1.051704900000000198e+05))); %!test %! assert (isequal (pown (infsup (0.01, 2.33), 2), infsup (9.999999999999999124e-05, 5.428900000000000503e+00))); %!test %! assert (isequal (pown (infsup (-1.9, -0.33), 2), infsup (1.088999999999999968e-01, 3.609999999999999876e+00))); %!test %! assert (isequal (pown (infsup, 8), infsup)); %!test %! assert (isequal (pown (infsup (-inf, inf), 8), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (0.0, 0.0), 8), infsup (0.0, 0.0))); %!test %! assert (isequal (pown (infsup (-0.0, -0.0), 8), infsup (0.0, 0.0))); %!test %! assert (isequal (pown (infsup (13.1, 13.1), 8), infsup (8.673020346900621653e+08, 8.673020346900622845e+08))); %!test %! assert (isequal (pown (infsup (-7451.145, -7451.145), 8), infsup (9.501323805961964567e+30, 9.501323805961965692e+30))); %!test %! assert (isequal (pown (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), 8), infsup (1.797693134862315708e+308, inf))); %!test %! assert (isequal (pown (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308), 8), infsup (1.797693134862315708e+308, inf))); %!test %! assert (isequal (pown (infsup (0.0, inf), 8), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-0.0, inf), 8), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-inf, 0.0), 8), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-inf, -0.0), 8), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-324.3, 2.5), 8), infsup (0.0, 1.223420037986718843e+20))); %!test %! assert (isequal (pown (infsup (0.01, 2.33), 8), infsup (1.000000000000000102e-16, 8.686550888106663706e+02))); %!test %! assert (isequal (pown (infsup (-1.9, -0.33), 8), infsup (1.406408618241000491e-04, 1.698356304099999647e+02))); %!test %! assert (isequal (pown (infsup, 1), infsup)); %!test %! assert (isequal (pown (infsup (-inf, inf), 1), infsup (-inf, inf))); %!test %! assert (isequal (pown (infsup (0.0, 0.0), 1), infsup (0.0, 0.0))); %!test %! assert (isequal (pown (infsup (-0.0, -0.0), 1), infsup (0.0, 0.0))); %!test %! assert (isequal (pown (infsup (13.1, 13.1), 1), infsup (13.1, 13.1))); %!test %! assert (isequal (pown (infsup (-7451.145, -7451.145), 1), infsup (-7451.145, -7451.145))); %!test %! assert (isequal (pown (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), 1), infsup (1.797693134862315708e+308, 1.797693134862315708e+308))); %!test %! assert (isequal (pown (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308), 1), infsup (-1.797693134862315708e+308, -1.797693134862315708e+308))); %!test %! assert (isequal (pown (infsup (0.0, inf), 1), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-0.0, inf), 1), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-inf, 0.0), 1), infsup (-inf, 0.0))); %!test %! assert (isequal (pown (infsup (-inf, -0.0), 1), infsup (-inf, 0.0))); %!test %! assert (isequal (pown (infsup (-324.3, 2.5), 1), infsup (-324.3, 2.5))); %!test %! assert (isequal (pown (infsup (0.01, 2.33), 1), infsup (0.01, 2.33))); %!test %! assert (isequal (pown (infsup (-1.9, -0.33), 1), infsup (-1.9, -0.33))); %!test %! assert (isequal (pown (infsup, 3), infsup)); %!test %! assert (isequal (pown (infsup (-inf, inf), 3), infsup (-inf, inf))); %!test %! assert (isequal (pown (infsup (0.0, 0.0), 3), infsup (0.0, 0.0))); %!test %! assert (isequal (pown (infsup (-0.0, -0.0), 3), infsup (0.0, 0.0))); %!test %! assert (isequal (pown (infsup (13.1, 13.1), 3), infsup (2.248090999999999440e+03, 2.248090999999999894e+03))); %!test %! assert (isequal (pown (infsup (-7451.145, -7451.145), 3), infsup (-4.136843053904099731e+11, -4.136843053904099121e+11))); %!test %! assert (isequal (pown (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), 3), infsup (1.797693134862315708e+308, inf))); %!test %! assert (isequal (pown (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308), 3), infsup (-inf, -1.797693134862315708e+308))); %!test %! assert (isequal (pown (infsup (0.0, inf), 3), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-0.0, inf), 3), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-inf, 0.0), 3), infsup (-inf, 0.0))); %!test %! assert (isequal (pown (infsup (-inf, -0.0), 3), infsup (-inf, 0.0))); %!test %! assert (isequal (pown (infsup (-324.3, 2.5), 3), infsup (-3.410678990700000525e+07, 1.562500000000000000e+01))); %!test %! assert (isequal (pown (infsup (0.01, 2.33), 3), infsup (9.999999999999999547e-07, 1.264933700000000272e+01))); %!test %! assert (isequal (pown (infsup (-1.9, -0.33), 3), infsup (-6.858999999999999098e+00, -3.593700000000000366e-02))); %!test %! assert (isequal (pown (infsup, 7), infsup)); %!test %! assert (isequal (pown (infsup (-inf, inf), 7), infsup (-inf, inf))); %!test %! assert (isequal (pown (infsup (0.0, 0.0), 7), infsup (0.0, 0.0))); %!test %! assert (isequal (pown (infsup (-0.0, -0.0), 7), infsup (0.0, 0.0))); %!test %! assert (isequal (pown (infsup (13.1, 13.1), 7), infsup (6.620626219008108228e+07, 6.620626219008108974e+07))); %!test %! assert (isequal (pown (infsup (-7451.145, -7451.145), 7), infsup (-1.275149497957960280e+27, -1.275149497957960005e+27))); %!test %! assert (isequal (pown (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), 7), infsup (1.797693134862315708e+308, inf))); %!test %! assert (isequal (pown (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308), 7), infsup (-inf, -1.797693134862315708e+308))); %!test %! assert (isequal (pown (infsup (0.0, inf), 7), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-0.0, inf), 7), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-inf, 0.0), 7), infsup (-inf, 0.0))); %!test %! assert (isequal (pown (infsup (-inf, -0.0), 7), infsup (-inf, 0.0))); %!test %! assert (isequal (pown (infsup (-324.3, 2.5), 7), infsup (-3.772494720896449920e+17, 6.103515625000000000e+02))); %!test %! assert (isequal (pown (infsup (0.01, 2.33), 7), infsup (9.999999999999999988e-15, 3.728133428371958757e+02))); %!test %! assert (isequal (pown (infsup (-1.9, -0.33), 7), infsup (-8.938717389999997920e+01, -4.261844297700001028e-04))); %!test %! assert (isequal (pown (infsup, -2), infsup)); %!test %! assert (isequal (pown (infsup (-inf, inf), -2), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (0.0, 0.0), -2), infsup)); %!test %! assert (isequal (pown (infsup (-0.0, -0.0), -2), infsup)); %!test %! assert (isequal (pown (infsup (13.1, 13.1), -2), infsup (5.827166249053085390e-03, 5.827166249053086257e-03))); %!test %! assert (isequal (pown (infsup (-7451.145, -7451.145), -2), infsup (1.801166953377180740e-08, 1.801166953377181071e-08))); %!test %! assert (isequal (pown (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), -2), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %!test %! assert (isequal (pown (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308), -2), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %!test %! assert (isequal (pown (infsup (0.0, inf), -2), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-0.0, inf), -2), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-inf, 0.0), -2), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-inf, -0.0), -2), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-324.3, 2.5), -2), infsup (9.508370646556841917e-06, inf))); %!test %! assert (isequal (pown (infsup (0.01, 2.33), -2), infsup (1.841993774061043421e-01, 1.000000000000000000e+04))); %!test %! assert (isequal (pown (infsup (-1.9, -0.33), -2), infsup (2.770083102493074989e-01, 9.182736455463727410e+00))); %!test %! assert (isequal (pown (infsup, -8), infsup)); %!test %! assert (isequal (pown (infsup (-inf, inf), -8), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (0.0, 0.0), -8), infsup)); %!test %! assert (isequal (pown (infsup (-0.0, -0.0), -8), infsup)); %!test %! assert (isequal (pown (infsup (13.1, 13.1), -8), infsup (1.153000869365374417e-09, 1.153000869365374624e-09))); %!test %! assert (isequal (pown (infsup (-7451.145, -7451.145), -8), infsup (1.052484917283328578e-31, 1.052484917283328797e-31))); %!test %! assert (isequal (pown (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), -8), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %!test %! assert (isequal (pown (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308), -8), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %!test %! assert (isequal (pown (infsup (0.0, inf), -8), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-0.0, inf), -8), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-inf, 0.0), -8), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-inf, -0.0), -8), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-324.3, 2.5), -8), infsup (8.173807596331487643e-21, inf))); %!test %! assert (isequal (pown (infsup (0.01, 2.33), -8), infsup (1.151204906160357110e-03, 1.000000000000000000e+16))); %!test %! assert (isequal (pown (infsup (-1.9, -0.33), -8), infsup (5.888045974722156024e-03, 7.110309102419345436e+03))); %!test %! assert (isequal (pown (infsup, -1), infsup)); %!test %! assert (isequal (pown (infsup (-inf, inf), -1), infsup (-inf, inf))); %!test %! assert (isequal (pown (infsup (0.0, 0.0), -1), infsup)); %!test %! assert (isequal (pown (infsup (-0.0, -0.0), -1), infsup)); %!test %! assert (isequal (pown (infsup (13.1, 13.1), -1), infsup (7.633587786259540819e-02, 7.633587786259542207e-02))); %!test %! assert (isequal (pown (infsup (-7451.145, -7451.145), -1), infsup (-1.342075613882161712e-04, -1.342075613882161441e-04))); %!test %! assert (isequal (pown (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), -1), infsup (5.562684646268003458e-309, 5.562684646268008398e-309))); %!test %! assert (isequal (pown (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308), -1), infsup (-5.562684646268008398e-309, -5.562684646268003458e-309))); %!test %! assert (isequal (pown (infsup (0.0, inf), -1), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-0.0, inf), -1), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-inf, 0.0), -1), infsup (-inf, 0.0))); %!test %! assert (isequal (pown (infsup (-inf, -0.0), -1), infsup (-inf, 0.0))); %!test %! assert (isequal (pown (infsup (-324.3, 2.5), -1), infsup (-inf, inf))); %!test %! assert (isequal (pown (infsup (0.01, 2.33), -1), infsup (4.291845493562231328e-01, 1.000000000000000000e+02))); %!test %! assert (isequal (pown (infsup (-1.9, -0.33), -1), infsup (-3.030303030303030276e+00, -5.263157894736841813e-01))); %!test %! assert (isequal (pown (infsup, -3), infsup)); %!test %! assert (isequal (pown (infsup (-inf, inf), -3), infsup (-inf, inf))); %!test %! assert (isequal (pown (infsup (0.0, 0.0), -3), infsup)); %!test %! assert (isequal (pown (infsup (-0.0, -0.0), -3), infsup)); %!test %! assert (isequal (pown (infsup (13.1, 13.1), -3), infsup (4.448218510727546177e-04, 4.448218510727546720e-04))); %!test %! assert (isequal (pown (infsup (-7451.145, -7451.145), -3), infsup (-2.417302244657943502e-12, -2.417302244657943098e-12))); %!test %! assert (isequal (pown (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), -3), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %!test %! assert (isequal (pown (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308), -3), infsup (-4.940656458412465442e-324, -0.000000000000000000e+00))); %!test %! assert (isequal (pown (infsup (0.0, inf), -3), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-0.0, inf), -3), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-inf, 0.0), -3), infsup (-inf, 0.0))); %!test %! assert (isequal (pown (infsup (-inf, -0.0), -3), infsup (-inf, 0.0))); %!test %! assert (isequal (pown (infsup (-324.3, 2.5), -3), infsup (-inf, inf))); %!test %! assert (isequal (pown (infsup (0.01, 2.33), -3), infsup (7.905552678373577169e-02, 1.000000000000000000e+06))); %!test %! assert (isequal (pown (infsup (-1.9, -0.33), -3), infsup (-2.782647410746584171e+01, -1.457938474996355316e-01))); %!test %! assert (isequal (pown (infsup, -7), infsup)); %!test %! assert (isequal (pown (infsup (-inf, inf), -7), infsup (-inf, inf))); %!test %! assert (isequal (pown (infsup (0.0, 0.0), -7), infsup)); %!test %! assert (isequal (pown (infsup (-0.0, -0.0), -7), infsup)); %!test %! assert (isequal (pown (infsup (13.1, 13.1), -7), infsup (1.510431138868640339e-08, 1.510431138868640670e-08))); %!test %! assert (isequal (pown (infsup (-7451.145, -7451.145), -7), infsup (-7.842217728991088300e-28, -7.842217728991087403e-28))); %!test %! assert (isequal (pown (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), -7), infsup (0.000000000000000000e+00, 4.940656458412465442e-324))); %!test %! assert (isequal (pown (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308), -7), infsup (-4.940656458412465442e-324, -0.000000000000000000e+00))); %!test %! assert (isequal (pown (infsup (0.0, inf), -7), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-0.0, inf), -7), infsup (0.0, inf))); %!test %! assert (isequal (pown (infsup (-inf, 0.0), -7), infsup (-inf, 0.0))); %!test %! assert (isequal (pown (infsup (-inf, -0.0), -7), infsup (-inf, 0.0))); %!test %! assert (isequal (pown (infsup (-324.3, 2.5), -7), infsup (-inf, inf))); %!test %! assert (isequal (pown (infsup (0.01, 2.33), -7), infsup (2.682307431353632161e-03, 1.000000000000000000e+14))); %!test %! assert (isequal (pown (infsup (-1.9, -0.33), -7), infsup (-2.346402003798384158e+03, -1.118728735197209619e-02))); ## minimal_pown_dec_test %!test %! assert (isequal (pown (infsupdec (-5.0, 10.0, "com"), 0), infsupdec (1.0, 1.0, "com"))); %! assert (isequal (decorationpart (pown (infsupdec (-5.0, 10.0, "com"), 0)){1}, decorationpart (infsupdec (1.0, 1.0, "com")){1})); %!test %! assert (isequal (pown (infsupdec (-inf, 15.0, "dac"), 0), infsupdec (1.0, 1.0, "dac"))); %! assert (isequal (decorationpart (pown (infsupdec (-inf, 15.0, "dac"), 0)){1}, decorationpart (infsupdec (1.0, 1.0, "dac")){1})); %!test %! assert (isequal (pown (infsupdec (-3.0, 5.0, "def"), 2), infsupdec (0.0, 25.0, "def"))); %! assert (isequal (decorationpart (pown (infsupdec (-3.0, 5.0, "def"), 2)){1}, decorationpart (infsupdec (0.0, 25.0, "def")){1})); %!test %! assert (isequal (pown (infsupdec (-1.797693134862315708e+308, 2.0, "com"), 2), infsupdec (0.0, inf, "dac"))); %! assert (isequal (decorationpart (pown (infsupdec (-1.797693134862315708e+308, 2.0, "com"), 2)){1}, decorationpart (infsupdec (0.0, inf, "dac")){1})); %!test %! assert (isequal (pown (infsupdec (-3.0, 5.0, "dac"), 3), infsupdec (-27.0, 125.0, "dac"))); %! assert (isequal (decorationpart (pown (infsupdec (-3.0, 5.0, "dac"), 3)){1}, decorationpart (infsupdec (-27.0, 125.0, "dac")){1})); %!test %! assert (isequal (pown (infsupdec (-1.797693134862315708e+308, 2.0, "com"), 3), infsupdec (-inf, 8.0, "dac"))); %! assert (isequal (decorationpart (pown (infsupdec (-1.797693134862315708e+308, 2.0, "com"), 3)){1}, decorationpart (infsupdec (-inf, 8.0, "dac")){1})); %!test %! assert (isequal (pown (infsupdec (3.0, 5.0, "com"), -2), infsupdec (3.999999999999999389e-02, 1.111111111111111188e-01, "com"))); %! assert (isequal (decorationpart (pown (infsupdec (3.0, 5.0, "com"), -2)){1}, decorationpart (infsupdec (3.999999999999999389e-02, 1.111111111111111188e-01, "com")){1})); %!test %! assert (isequal (pown (infsupdec (-5.0, -3.0, "def"), -2), infsupdec (3.999999999999999389e-02, 1.111111111111111188e-01, "def"))); %! assert (isequal (decorationpart (pown (infsupdec (-5.0, -3.0, "def"), -2)){1}, decorationpart (infsupdec (3.999999999999999389e-02, 1.111111111111111188e-01, "def")){1})); %!test %! assert (isequal (pown (infsupdec (-5.0, 3.0, "com"), -2), infsupdec (3.999999999999999389e-02, inf, "trv"))); %! assert (isequal (decorationpart (pown (infsupdec (-5.0, 3.0, "com"), -2)){1}, decorationpart (infsupdec (3.999999999999999389e-02, inf, "trv")){1})); %!test %! assert (isequal (pown (infsupdec (3.0, 5.0, "dac"), -3), infsupdec (7.999999999999998432e-03, 3.703703703703704192e-02, "dac"))); %! assert (isequal (decorationpart (pown (infsupdec (3.0, 5.0, "dac"), -3)){1}, decorationpart (infsupdec (7.999999999999998432e-03, 3.703703703703704192e-02, "dac")){1})); %!test %! assert (isequal (pown (infsupdec (-3.0, 5.0, "com"), -3), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (pown (infsupdec (-3.0, 5.0, "com"), -3)){1}, decorationpart (infsupdec (entire, "trv")){1})); ## minimal_pow_test %!test %! assert (isequal (pow (infsup, infsup), infsup)); %!test %! assert (isequal (pow (infsup, infsup (-inf, inf)), infsup)); %!test %! assert (isequal (pow (infsup, infsup (-inf, -1.0)), infsup)); %!test %! assert (isequal (pow (infsup, infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup, infsup (-inf, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup, infsup (0.0, inf)), infsup)); %!test %! assert (isequal (pow (infsup, infsup (-0.0, inf)), infsup)); %!test %! assert (isequal (pow (infsup, infsup (1.0, inf)), infsup)); %!test %! assert (isequal (pow (infsup, infsup (-3.0, 5.0)), infsup)); %!test %! assert (isequal (pow (infsup, infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup, infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup, infsup (-5.0, -5.0)), infsup)); %!test %! assert (isequal (pow (infsup, infsup (5.0, 5.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup), infsup)); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-0.0, -0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (0.0, 1.0)), infsup (1.000000000000000056e-01, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-0.0, 1.0)), infsup (1.000000000000000056e-01, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (0.0, 2.5)), infsup (3.162277660168379394e-03, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-0.0, 2.5)), infsup (3.162277660168379394e-03, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (0.0, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-0.0, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (0.1, 0.1)), infsup (7.943282347242814900e-01, 9.330329915368075211e-01))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (0.1, 1.0)), infsup (1.000000000000000056e-01, 9.330329915368075211e-01))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (0.1, 2.5)), infsup (3.162277660168379394e-03, 9.330329915368075211e-01))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (0.1, inf)), infsup (0.0, 9.330329915368075211e-01))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (1.0, 1.0)), infsup (1.000000000000000056e-01, 5.000000000000000000e-01))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (1.0, 2.5)), infsup (3.162277660168379394e-03, 5.000000000000000000e-01))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (1.0, inf)), infsup (0.0, 5.000000000000000000e-01))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (2.5, 2.5)), infsup (3.162277660168379394e-03, 1.767766952966368932e-01))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (2.5, inf)), infsup (0.0, 1.767766952966368932e-01))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-0.1, 0.1)), infsup (7.943282347242814900e-01, 1.258925411794167282e+00))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-0.1, 1.0)), infsup (1.000000000000000056e-01, 1.258925411794167282e+00))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-0.1, 2.5)), infsup (3.162277660168379394e-03, 1.258925411794167282e+00))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-0.1, inf)), infsup (0.0, 1.258925411794167282e+00))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-1.0, 0.1)), infsup (7.943282347242814900e-01, 1.000000000000000000e+01))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-1.0, 1.0)), infsup (1.000000000000000056e-01, 1.000000000000000000e+01))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-1.0, 2.5)), infsup (3.162277660168379394e-03, 1.000000000000000000e+01))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-1.0, inf)), infsup (0.0, 1.000000000000000000e+01))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-2.5, 0.1)), infsup (7.943282347242814900e-01, 3.162277660168379043e+02))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-2.5, 1.0)), infsup (1.000000000000000056e-01, 3.162277660168379043e+02))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-2.5, 2.5)), infsup (3.162277660168379394e-03, 3.162277660168379043e+02))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-2.5, inf)), infsup (0.0, 3.162277660168379043e+02))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-inf, 0.1)), infsup (7.943282347242814900e-01, inf))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-inf, 1.0)), infsup (1.000000000000000056e-01, inf))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-inf, 2.5)), infsup (3.162277660168379394e-03, inf))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-1.0, 0.0)), infsup (1.0, 1.000000000000000000e+01))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-1.0, -0.0)), infsup (1.0, 1.000000000000000000e+01))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-2.5, 0.0)), infsup (1.0, 3.162277660168379043e+02))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-2.5, -0.0)), infsup (1.0, 3.162277660168379043e+02))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-inf, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-inf, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-0.1, -0.1)), infsup (1.071773462536293131e+00, 1.258925411794167282e+00))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-1.0, -0.1)), infsup (1.071773462536293131e+00, 1.000000000000000000e+01))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-2.5, -0.1)), infsup (1.071773462536293131e+00, 3.162277660168379043e+02))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-inf, -0.1)), infsup (1.071773462536293131e+00, inf))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-1.0, -1.0)), infsup (2.000000000000000000e+00, 1.000000000000000000e+01))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-2.5, -1.0)), infsup (2.000000000000000000e+00, 3.162277660168379043e+02))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-inf, -1.0)), infsup (2.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-2.5, -2.5)), infsup (5.656854249492379694e+00, 3.162277660168379043e+02))); %!test %! assert (isequal (pow (infsup (0.1, 0.5), infsup (-inf, -2.5)), infsup (5.656854249492379694e+00, inf))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup), infsup)); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-0.0, -0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (0.0, 1.0)), infsup (1.000000000000000056e-01, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-0.0, 1.0)), infsup (1.000000000000000056e-01, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (0.0, 2.5)), infsup (3.162277660168379394e-03, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-0.0, 2.5)), infsup (3.162277660168379394e-03, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (0.0, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-0.0, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (0.1, 0.1)), infsup (7.943282347242814900e-01, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (0.1, 1.0)), infsup (1.000000000000000056e-01, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (0.1, 2.5)), infsup (3.162277660168379394e-03, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (0.1, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (1.0, 1.0)), infsup (1.000000000000000056e-01, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (1.0, 2.5)), infsup (3.162277660168379394e-03, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (1.0, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (2.5, 2.5)), infsup (3.162277660168379394e-03, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (2.5, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-0.1, 0.1)), infsup (7.943282347242814900e-01, 1.258925411794167282e+00))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-0.1, 1.0)), infsup (1.000000000000000056e-01, 1.258925411794167282e+00))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-0.1, 2.5)), infsup (3.162277660168379394e-03, 1.258925411794167282e+00))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-0.1, inf)), infsup (0.0, 1.258925411794167282e+00))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-1.0, 0.1)), infsup (7.943282347242814900e-01, 1.000000000000000000e+01))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-1.0, 1.0)), infsup (1.000000000000000056e-01, 1.000000000000000000e+01))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-1.0, 2.5)), infsup (3.162277660168379394e-03, 1.000000000000000000e+01))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-1.0, inf)), infsup (0.0, 1.000000000000000000e+01))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-2.5, 0.1)), infsup (7.943282347242814900e-01, 3.162277660168379043e+02))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-2.5, 1.0)), infsup (1.000000000000000056e-01, 3.162277660168379043e+02))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-2.5, 2.5)), infsup (3.162277660168379394e-03, 3.162277660168379043e+02))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-2.5, inf)), infsup (0.0, 3.162277660168379043e+02))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-inf, 0.1)), infsup (7.943282347242814900e-01, inf))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-inf, 1.0)), infsup (1.000000000000000056e-01, inf))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-inf, 2.5)), infsup (3.162277660168379394e-03, inf))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-0.1, 0.0)), infsup (1.0, 1.258925411794167282e+00))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-0.1, -0.0)), infsup (1.0, 1.258925411794167282e+00))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-1.0, 0.0)), infsup (1.0, 1.000000000000000000e+01))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-1.0, -0.0)), infsup (1.0, 1.000000000000000000e+01))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-2.5, 0.0)), infsup (1.0, 3.162277660168379043e+02))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-2.5, -0.0)), infsup (1.0, 3.162277660168379043e+02))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-inf, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-inf, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-0.1, -0.1)), infsup (1.0, 1.258925411794167282e+00))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-1.0, -0.1)), infsup (1.0, 1.000000000000000000e+01))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-2.5, -0.1)), infsup (1.0, 3.162277660168379043e+02))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-inf, -0.1)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-1.0, -1.0)), infsup (1.0, 1.000000000000000000e+01))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-2.5, -1.0)), infsup (1.0, 3.162277660168379043e+02))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-inf, -1.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-2.5, -2.5)), infsup (1.0, 3.162277660168379043e+02))); %!test %! assert (isequal (pow (infsup (0.1, 1.0), infsup (-inf, -2.5)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup), infsup)); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-0.0, -0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (0.0, 1.0)), infsup (0.5, 1.5))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-0.0, 1.0)), infsup (0.5, 1.5))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (0.0, 2.5)), infsup (1.767766952966368654e-01, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-0.0, 2.5)), infsup (1.767766952966368654e-01, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (0.1, 0.1)), infsup (9.330329915368074101e-01, 1.041379743992410623e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (0.1, 1.0)), infsup (0.5, 1.5))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (0.1, 2.5)), infsup (1.767766952966368654e-01, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (0.1, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (1.0, 1.0)), infsup (0.5, 1.5))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (1.0, 2.5)), infsup (1.767766952966368654e-01, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (2.5, 2.5)), infsup (1.767766952966368654e-01, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (2.5, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-0.1, 0.1)), infsup (9.330329915368074101e-01, 1.071773462536293353e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-0.1, 1.0)), infsup (5.000000000000000000e-01, 1.500000000000000000e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-0.1, 2.5)), infsup (1.767766952966368654e-01, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-0.1, inf)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-1.0, 0.1)), infsup (6.666666666666666297e-01, 2.000000000000000000e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-1.0, 1.0)), infsup (5.000000000000000000e-01, 2.000000000000000000e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-1.0, 2.5)), infsup (1.767766952966368654e-01, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-1.0, inf)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-2.5, 0.1)), infsup (3.628873693012115154e-01, 5.656854249492380582e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-2.5, 1.0)), infsup (3.628873693012115154e-01, 5.656854249492380582e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-2.5, 2.5)), infsup (1.767766952966368654e-01, 5.656854249492380582e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-2.5, inf)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-inf, 0.1)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-inf, 1.0)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-inf, 2.5)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-inf, inf)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-1.0, 0.0)), infsup (6.666666666666666297e-01, 2.000000000000000000e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-1.0, -0.0)), infsup (6.666666666666666297e-01, 2.000000000000000000e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-2.5, 0.0)), infsup (3.628873693012115154e-01, 5.656854249492380582e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-2.5, -0.0)), infsup (3.628873693012115154e-01, 5.656854249492380582e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-inf, 0.0)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-inf, -0.0)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-0.1, -0.1)), infsup (9.602645007922180342e-01, 1.071773462536293353e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-1.0, -0.1)), infsup (6.666666666666666297e-01, 2.000000000000000000e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-2.5, -0.1)), infsup (3.628873693012115154e-01, 5.656854249492380582e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-inf, -0.1)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-1.0, -1.0)), infsup (6.666666666666666297e-01, 2.000000000000000000e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-2.5, -1.0)), infsup (3.628873693012115154e-01, 5.656854249492380582e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-inf, -1.0)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-2.5, -2.5)), infsup (3.628873693012115154e-01, 5.656854249492380582e+00))); %!test %! assert (isequal (pow (infsup (0.5, 1.5), infsup (-inf, -2.5)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup), infsup)); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-0.0, -0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (0.0, 1.0)), infsup (0.5, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-0.0, 1.0)), infsup (0.5, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (0.0, 2.5)), infsup (1.767766952966368654e-01, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-0.0, 2.5)), infsup (1.767766952966368654e-01, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (0.1, 0.1)), infsup (9.330329915368074101e-01, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (0.1, 1.0)), infsup (0.5, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (0.1, 2.5)), infsup (1.767766952966368654e-01, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (0.1, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (1.0, 1.0)), infsup (0.5, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (1.0, 2.5)), infsup (1.767766952966368654e-01, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (2.5, 2.5)), infsup (1.767766952966368654e-01, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (2.5, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-0.1, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-0.1, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-0.1, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-0.1, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-1.0, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-1.0, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-1.0, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-2.5, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-2.5, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-2.5, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-2.5, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-inf, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-inf, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-inf, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-1.0, 0.0)), infsup (0.0, 2.000000000000000000e+00))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-1.0, -0.0)), infsup (0.0, 2.000000000000000000e+00))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-2.5, 0.0)), infsup (0.0, 5.656854249492380582e+00))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-2.5, -0.0)), infsup (0.0, 5.656854249492380582e+00))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-inf, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-inf, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-0.1, -0.1)), infsup (0.0, 1.071773462536293353e+00))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-1.0, -0.1)), infsup (0.0, 2.000000000000000000e+00))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-2.5, -0.1)), infsup (0.0, 5.656854249492380582e+00))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-inf, -0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-1.0, -1.0)), infsup (0.0, 2.000000000000000000e+00))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-2.5, -1.0)), infsup (0.0, 5.656854249492380582e+00))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-inf, -1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-inf, -2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.5, inf), infsup (-2.5, -2.5)), infsup (0.0, 5.656854249492380582e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup), infsup)); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-0.0, -0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (0.0, 1.0)), infsup (1.0, 1.500000000000000000e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-0.0, 1.0)), infsup (1.0, 1.500000000000000000e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (0.0, 2.5)), infsup (1.0, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-0.0, 2.5)), infsup (1.0, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (0.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-0.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (0.1, 0.1)), infsup (1.0, 1.041379743992410623e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (0.1, 1.0)), infsup (1.0, 1.500000000000000000e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (0.1, 2.5)), infsup (1.0, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (0.1, inf)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (1.0, 1.0)), infsup (1.0, 1.500000000000000000e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (1.0, 2.5)), infsup (1.0, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (2.5, 2.5)), infsup (1.0, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (2.5, inf)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-0.1, 0.1)), infsup (9.602645007922180342e-01, 1.041379743992410623e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-0.1, 1.0)), infsup (9.602645007922180342e-01, 1.500000000000000000e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-0.1, 2.5)), infsup (9.602645007922180342e-01, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-0.1, inf)), infsup (9.602645007922180342e-01, inf))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-1.0, 0.1)), infsup (6.666666666666666297e-01, 1.041379743992410623e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-1.0, 1.0)), infsup (6.666666666666666297e-01, 1.500000000000000000e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-1.0, 2.5)), infsup (6.666666666666666297e-01, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-1.0, inf)), infsup (6.666666666666666297e-01, inf))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-2.5, 0.1)), infsup (3.628873693012115154e-01, 1.041379743992410623e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-2.5, 1.0)), infsup (3.628873693012115154e-01, 1.500000000000000000e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-2.5, 2.5)), infsup (3.628873693012115154e-01, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-2.5, inf)), infsup (3.628873693012115154e-01, inf))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-inf, 0.1)), infsup (0.000000000000000000e+00, 1.041379743992410623e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-inf, 1.0)), infsup (0.000000000000000000e+00, 1.500000000000000000e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-inf, 2.5)), infsup (0.000000000000000000e+00, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-inf, inf)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-1.0, 0.0)), infsup (6.666666666666666297e-01, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-1.0, -0.0)), infsup (6.666666666666666297e-01, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-2.5, 0.0)), infsup (3.628873693012115154e-01, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-2.5, -0.0)), infsup (3.628873693012115154e-01, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-inf, 0.0)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-inf, -0.0)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-0.1, -0.1)), infsup (9.602645007922180342e-01, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-1.0, -0.1)), infsup (6.666666666666666297e-01, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-2.5, -0.1)), infsup (3.628873693012115154e-01, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-inf, -0.1)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-1.0, -1.0)), infsup (6.666666666666666297e-01, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-2.5, -1.0)), infsup (3.628873693012115154e-01, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-inf, -1.0)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-2.5, -2.5)), infsup (3.628873693012115154e-01, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, 1.5), infsup (-inf, -2.5)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup), infsup)); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-0.0, -0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (0.0, 1.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-0.0, 1.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (0.0, 2.5)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-0.0, 2.5)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (0.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-0.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (0.1, 0.1)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (0.1, 1.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (0.1, 2.5)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (0.1, inf)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (1.0, 1.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (1.0, 2.5)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (1.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (2.5, 2.5)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (2.5, inf)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-0.1, 0.1)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-0.1, 1.0)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-0.1, 2.5)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-0.1, inf)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-1.0, 0.1)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-1.0, 1.0)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-1.0, 2.5)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-1.0, inf)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-2.5, 0.1)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-2.5, 1.0)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-2.5, 2.5)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-2.5, inf)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-inf, 0.1)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-inf, 1.0)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-inf, 2.5)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-inf, inf)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-1.0, 0.0)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-1.0, -0.0)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-2.5, 0.0)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-2.5, -0.0)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-inf, 0.0)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-inf, -0.0)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-0.1, -0.1)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-1.0, -0.1)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-2.5, -0.1)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-inf, -0.1)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-1.0, -1.0)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-2.5, -1.0)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-inf, -1.0)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-2.5, -2.5)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.0, inf), infsup (-inf, -2.5)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup), infsup)); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-0.0, -0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (0.0, 1.0)), infsup (1.0, 1.500000000000000000e+00))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-0.0, 1.0)), infsup (1.0, 1.500000000000000000e+00))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (0.0, 2.5)), infsup (1.0, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-0.0, 2.5)), infsup (1.0, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (0.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-0.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (0.1, 0.1)), infsup (1.009576582776886999e+00, 1.041379743992410623e+00))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (0.1, 1.0)), infsup (1.009576582776886999e+00, 1.500000000000000000e+00))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (0.1, 2.5)), infsup (1.009576582776886999e+00, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (0.1, inf)), infsup (1.009576582776886999e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (1.0, 1.0)), infsup (1.100000000000000089e+00, 1.500000000000000000e+00))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (1.0, 2.5)), infsup (1.100000000000000089e+00, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (1.0, inf)), infsup (1.100000000000000089e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (2.5, 2.5)), infsup (1.269058706285883575e+00, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (2.5, inf)), infsup (1.269058706285883575e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-0.1, 0.1)), infsup (9.602645007922180342e-01, 1.041379743992410623e+00))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-0.1, 1.0)), infsup (9.602645007922180342e-01, 1.500000000000000000e+00))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-0.1, 2.5)), infsup (9.602645007922180342e-01, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-0.1, inf)), infsup (9.602645007922180342e-01, inf))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-1.0, 0.1)), infsup (6.666666666666666297e-01, 1.041379743992410623e+00))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-1.0, 1.0)), infsup (6.666666666666666297e-01, 1.500000000000000000e+00))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-1.0, 2.5)), infsup (6.666666666666666297e-01, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-1.0, inf)), infsup (6.666666666666666297e-01, inf))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-2.5, 0.1)), infsup (3.628873693012115154e-01, 1.041379743992410623e+00))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-2.5, 1.0)), infsup (3.628873693012115154e-01, 1.500000000000000000e+00))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-2.5, 2.5)), infsup (3.628873693012115154e-01, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-2.5, inf)), infsup (3.628873693012115154e-01, inf))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-inf, 0.1)), infsup (0.000000000000000000e+00, 1.041379743992410623e+00))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-inf, 1.0)), infsup (0.000000000000000000e+00, 1.500000000000000000e+00))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-inf, 2.5)), infsup (0.000000000000000000e+00, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-inf, inf)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-1.0, 0.0)), infsup (6.666666666666666297e-01, 1.0))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-1.0, -0.0)), infsup (6.666666666666666297e-01, 1.0))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-2.5, 0.0)), infsup (3.628873693012115154e-01, 1.0))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-2.5, -0.0)), infsup (3.628873693012115154e-01, 1.0))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-inf, 0.0)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-inf, -0.0)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-0.1, -0.1)), infsup (9.602645007922180342e-01, 9.905142582145218810e-01))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-1.0, -0.1)), infsup (6.666666666666666297e-01, 9.905142582145218810e-01))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-2.5, -0.1)), infsup (3.628873693012115154e-01, 9.905142582145218810e-01))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-inf, -0.1)), infsup (0.000000000000000000e+00, 9.905142582145218810e-01))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-1.0, -1.0)), infsup (6.666666666666666297e-01, 9.090909090909090606e-01))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-2.5, -1.0)), infsup (3.628873693012115154e-01, 9.090909090909090606e-01))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-inf, -1.0)), infsup (0.000000000000000000e+00, 9.090909090909090606e-01))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-2.5, -2.5)), infsup (3.628873693012115154e-01, 7.879856109467704428e-01))); %!test %! assert (isequal (pow (infsup (1.1, 1.5), infsup (-inf, -2.5)), infsup (0.000000000000000000e+00, 7.879856109467704428e-01))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup), infsup)); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-0.0, -0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (0.0, 1.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-0.0, 1.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (0.0, 2.5)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-0.0, 2.5)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (0.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-0.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (0.1, 0.1)), infsup (1.009576582776886999e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (0.1, 1.0)), infsup (1.009576582776886999e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (0.1, 2.5)), infsup (1.009576582776886999e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (0.1, inf)), infsup (1.009576582776886999e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (1.0, 1.0)), infsup (1.100000000000000089e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (1.0, 2.5)), infsup (1.100000000000000089e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (1.0, inf)), infsup (1.100000000000000089e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (2.5, 2.5)), infsup (1.269058706285883575e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (2.5, inf)), infsup (1.269058706285883575e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-0.1, 0.1)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-0.1, 1.0)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-0.1, 2.5)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-0.1, inf)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-1.0, 0.1)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-1.0, 1.0)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-1.0, 2.5)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-1.0, inf)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-2.5, 0.1)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-2.5, 1.0)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-2.5, 2.5)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-2.5, inf)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-inf, 0.1)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-inf, 1.0)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-inf, 2.5)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-inf, inf)), infsup (0.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-1.0, 0.0)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-1.0, -0.0)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-2.5, 0.0)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-2.5, -0.0)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-inf, 0.0)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-inf, -0.0)), infsup (0.000000000000000000e+00, 1.0))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-0.1, -0.1)), infsup (0.000000000000000000e+00, 9.905142582145218810e-01))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-1.0, -0.1)), infsup (0.000000000000000000e+00, 9.905142582145218810e-01))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-2.5, -0.1)), infsup (0.000000000000000000e+00, 9.905142582145218810e-01))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-inf, -0.1)), infsup (0.000000000000000000e+00, 9.905142582145218810e-01))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-1.0, -1.0)), infsup (0.000000000000000000e+00, 9.090909090909090606e-01))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-2.5, -1.0)), infsup (0.000000000000000000e+00, 9.090909090909090606e-01))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-inf, -1.0)), infsup (0.000000000000000000e+00, 9.090909090909090606e-01))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-2.5, -2.5)), infsup (0.000000000000000000e+00, 7.879856109467704428e-01))); %!test %! assert (isequal (pow (infsup (1.1, inf), infsup (-inf, -2.5)), infsup (0.000000000000000000e+00, 7.879856109467704428e-01))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup), infsup)); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-0.0, -0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (0.0, 2.5)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-0.0, 2.5)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (0.0, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-0.0, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (0.1, 0.1)), infsup (0.0, 9.330329915368075211e-01))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (0.1, 1.0)), infsup (0.0, 9.330329915368075211e-01))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (0.1, 2.5)), infsup (0.0, 9.330329915368075211e-01))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (0.1, inf)), infsup (0.0, 9.330329915368075211e-01))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (1.0, 1.0)), infsup (0.0, 0.5))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (1.0, 2.5)), infsup (0.0, 0.5))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (1.0, inf)), infsup (0.0, 0.5))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (2.5, 2.5)), infsup (0.0, 1.767766952966368932e-01))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (2.5, inf)), infsup (0.0, 1.767766952966368932e-01))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-0.1, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-0.1, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-0.1, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-0.1, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-1.0, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-1.0, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-1.0, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-2.5, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-2.5, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-2.5, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-2.5, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-inf, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-inf, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-inf, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-1.0, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-1.0, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-2.5, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-2.5, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-inf, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-inf, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-0.1, -0.1)), infsup (1.071773462536293131e+00, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-1.0, -0.1)), infsup (1.071773462536293131e+00, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-2.5, -0.1)), infsup (1.071773462536293131e+00, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-inf, -0.1)), infsup (1.071773462536293131e+00, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-1.0, -1.0)), infsup (2.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-2.5, -1.0)), infsup (2.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-inf, -1.0)), infsup (2.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-2.5, -2.5)), infsup (5.656854249492379694e+00, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.5), infsup (-inf, -2.5)), infsup (5.656854249492379694e+00, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup), infsup)); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-0.0, -0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (0.0, 2.5)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-0.0, 2.5)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (0.0, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-0.0, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (0.1, 0.1)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (0.1, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (0.1, 2.5)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (0.1, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (1.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (1.0, 2.5)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (1.0, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (2.5, 2.5)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (2.5, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-0.1, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-0.1, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-0.1, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-0.1, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-1.0, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-1.0, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-1.0, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-2.5, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-2.5, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-2.5, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-2.5, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-inf, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-inf, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-inf, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-0.1, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-0.1, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-1.0, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-1.0, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-2.5, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-2.5, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-inf, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-inf, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-0.1, -0.1)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-1.0, -0.1)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-2.5, -0.1)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-inf, -0.1)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-1.0, -1.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-2.5, -1.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-inf, -1.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-2.5, -2.5)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.0), infsup (-inf, -2.5)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup), infsup)); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-0.0, -0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (0.0, 1.0)), infsup (0.0, 1.5))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-0.0, 1.0)), infsup (0.0, 1.5))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (0.0, 2.5)), infsup (0.0, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-0.0, 2.5)), infsup (0.0, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (0.1, 0.1)), infsup (0.0, 1.041379743992410623e+00))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (0.1, 1.0)), infsup (0.0, 1.5))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (0.1, 2.5)), infsup (0.0, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (0.1, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (1.0, 1.0)), infsup (0.0, 1.5))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (1.0, 2.5)), infsup (0.0, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (2.5, 2.5)), infsup (0.0, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (2.5, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-0.1, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-0.1, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-0.1, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-0.1, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-1.0, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-1.0, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-1.0, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-2.5, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-2.5, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-2.5, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-2.5, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-inf, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-inf, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-inf, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-1.0, 0.0)), infsup (6.666666666666666297e-01, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-1.0, -0.0)), infsup (6.666666666666666297e-01, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-2.5, 0.0)), infsup (3.628873693012115154e-01, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-2.5, -0.0)), infsup (3.628873693012115154e-01, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-inf, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-inf, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-0.1, -0.1)), infsup (9.602645007922180342e-01, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-1.0, -0.1)), infsup (6.666666666666666297e-01, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-2.5, -0.1)), infsup (3.628873693012115154e-01, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-inf, -0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-1.0, -1.0)), infsup (6.666666666666666297e-01, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-2.5, -1.0)), infsup (3.628873693012115154e-01, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-inf, -1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-2.5, -2.5)), infsup (3.628873693012115154e-01, inf))); %!test %! assert (isequal (pow (infsup (0.0, 1.5), infsup (-inf, -2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup), infsup)); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-0.0, -0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (0.0, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-0.0, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (0.0, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-0.0, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (0.1, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (0.1, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (0.1, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (0.1, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (1.0, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (1.0, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (2.5, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (2.5, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-0.1, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-0.1, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-0.1, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-0.1, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-1.0, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-1.0, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-1.0, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-2.5, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-2.5, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-2.5, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-2.5, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-inf, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-inf, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-inf, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-1.0, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-1.0, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-2.5, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-2.5, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-inf, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-inf, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-0.1, -0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-1.0, -0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-2.5, -0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-inf, -0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-1.0, -1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-2.5, -1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-inf, -1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-inf, -2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, inf), infsup (-2.5, -2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-0.0, -0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (0.0, 2.5)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-0.0, 2.5)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (0.0, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-0.0, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (0.1, 0.1)), infsup (0.0, 9.330329915368075211e-01))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (0.1, 1.0)), infsup (0.0, 9.330329915368075211e-01))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (0.1, 2.5)), infsup (0.0, 9.330329915368075211e-01))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (0.1, inf)), infsup (0.0, 9.330329915368075211e-01))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (1.0, 1.0)), infsup (0.0, 0.5))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (1.0, 2.5)), infsup (0.0, 0.5))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (1.0, inf)), infsup (0.0, 0.5))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (2.5, 2.5)), infsup (0.0, 1.767766952966368932e-01))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (2.5, inf)), infsup (0.0, 1.767766952966368932e-01))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-0.1, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-0.1, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-0.1, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-0.1, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-1.0, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-1.0, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-1.0, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-2.5, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-2.5, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-2.5, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-2.5, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-inf, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-inf, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-inf, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-1.0, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-1.0, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-2.5, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-2.5, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-inf, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-inf, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-0.1, -0.1)), infsup (1.071773462536293131e+00, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-1.0, -0.1)), infsup (1.071773462536293131e+00, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-2.5, -0.1)), infsup (1.071773462536293131e+00, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-inf, -0.1)), infsup (1.071773462536293131e+00, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-1.0, -1.0)), infsup (2.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-2.5, -1.0)), infsup (2.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-inf, -1.0)), infsup (2.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-2.5, -2.5)), infsup (5.656854249492379694e+00, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 0.5), infsup (-inf, -2.5)), infsup (5.656854249492379694e+00, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-0.0, -0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (0.0, 2.5)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-0.0, 2.5)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (0.0, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-0.0, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (0.1, 0.1)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (0.1, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (0.1, 2.5)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (0.1, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (1.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (1.0, 2.5)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (1.0, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (2.5, 2.5)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (2.5, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-0.1, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-0.1, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-0.1, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-0.1, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-1.0, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-1.0, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-1.0, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-2.5, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-2.5, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-2.5, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-2.5, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-inf, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-inf, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-inf, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-0.1, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-0.1, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-1.0, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-1.0, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-2.5, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-2.5, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-inf, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-inf, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-0.1, -0.1)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-1.0, -0.1)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-2.5, -0.1)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-inf, -0.1)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-1.0, -1.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-2.5, -1.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-inf, -1.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-2.5, -2.5)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.0), infsup (-inf, -2.5)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-0.0, -0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (0.0, 1.0)), infsup (0.0, 1.5))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-0.0, 1.0)), infsup (0.0, 1.5))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (0.0, 2.5)), infsup (0.0, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-0.0, 2.5)), infsup (0.0, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (0.1, 0.1)), infsup (0.0, 1.041379743992410623e+00))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (0.1, 1.0)), infsup (0.0, 1.5))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (0.1, 2.5)), infsup (0.0, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (0.1, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (1.0, 1.0)), infsup (0.0, 1.5))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (1.0, 2.5)), infsup (0.0, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (2.5, 2.5)), infsup (0.0, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (2.5, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-0.1, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-0.1, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-0.1, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-0.1, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-1.0, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-1.0, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-1.0, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-2.5, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-2.5, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-2.5, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-2.5, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-inf, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-inf, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-inf, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-1.0, 0.0)), infsup (6.666666666666666297e-01, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-1.0, -0.0)), infsup (6.666666666666666297e-01, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-2.5, 0.0)), infsup (3.628873693012115154e-01, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-2.5, -0.0)), infsup (3.628873693012115154e-01, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-inf, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-inf, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-0.1, -0.1)), infsup (9.602645007922180342e-01, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-1.0, -0.1)), infsup (6.666666666666666297e-01, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-2.5, -0.1)), infsup (3.628873693012115154e-01, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-inf, -0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-1.0, -1.0)), infsup (6.666666666666666297e-01, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-2.5, -1.0)), infsup (3.628873693012115154e-01, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-inf, -1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-2.5, -2.5)), infsup (3.628873693012115154e-01, inf))); %!test %! assert (isequal (pow (infsup (-0.0, 1.5), infsup (-inf, -2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-0.0, -0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (0.0, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-0.0, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (0.0, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-0.0, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (0.1, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (0.1, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (0.1, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (0.1, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (1.0, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (1.0, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (2.5, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (2.5, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-0.1, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-0.1, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-0.1, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-0.1, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-1.0, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-1.0, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-1.0, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-2.5, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-2.5, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-2.5, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-2.5, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-inf, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-inf, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-inf, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-1.0, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-1.0, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-2.5, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-2.5, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-inf, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-inf, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-0.1, -0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-1.0, -0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-2.5, -0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-inf, -0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-1.0, -1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-2.5, -1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-inf, -1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-inf, -2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.0, inf), infsup (-2.5, -2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup), infsup)); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-0.0, -0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (0.0, 2.5)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-0.0, 2.5)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (0.0, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-0.0, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (0.1, 0.1)), infsup (0.0, 9.330329915368075211e-01))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (0.1, 1.0)), infsup (0.0, 9.330329915368075211e-01))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (0.1, 2.5)), infsup (0.0, 9.330329915368075211e-01))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (0.1, inf)), infsup (0.0, 9.330329915368075211e-01))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (1.0, 1.0)), infsup (0.0, 0.5))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (1.0, 2.5)), infsup (0.0, 0.5))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (1.0, inf)), infsup (0.0, 0.5))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (2.5, 2.5)), infsup (0.0, 1.767766952966368932e-01))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (2.5, inf)), infsup (0.0, 1.767766952966368932e-01))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-0.1, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-0.1, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-0.1, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-0.1, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-1.0, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-1.0, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-1.0, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-2.5, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-2.5, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-2.5, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-2.5, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-inf, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-inf, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-inf, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-1.0, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-1.0, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-2.5, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-2.5, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-inf, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-inf, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-0.1, -0.1)), infsup (1.071773462536293131e+00, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-1.0, -0.1)), infsup (1.071773462536293131e+00, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-2.5, -0.1)), infsup (1.071773462536293131e+00, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-inf, -0.1)), infsup (1.071773462536293131e+00, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-1.0, -1.0)), infsup (2.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-2.5, -1.0)), infsup (2.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-inf, -1.0)), infsup (2.000000000000000000e+00, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-2.5, -2.5)), infsup (5.656854249492379694e+00, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 0.5), infsup (-inf, -2.5)), infsup (5.656854249492379694e+00, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup), infsup)); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-0.0, -0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-0.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (0.0, 2.5)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-0.0, 2.5)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (0.0, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-0.0, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (0.1, 0.1)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (0.1, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (0.1, 2.5)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (0.1, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (1.0, 1.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (1.0, 2.5)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (1.0, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (2.5, 2.5)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (2.5, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-0.1, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-0.1, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-0.1, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-0.1, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-1.0, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-1.0, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-1.0, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-2.5, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-2.5, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-2.5, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-2.5, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-inf, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-inf, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-inf, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-0.1, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-0.1, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-1.0, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-1.0, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-2.5, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-2.5, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-inf, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-inf, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-0.1, -0.1)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-1.0, -0.1)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-2.5, -0.1)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-inf, -0.1)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-1.0, -1.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-2.5, -1.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-inf, -1.0)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-2.5, -2.5)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.0), infsup (-inf, -2.5)), infsup (1.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup), infsup)); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-0.0, -0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (0.0, 1.0)), infsup (0.0, 1.5))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-0.0, 1.0)), infsup (0.0, 1.5))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (0.0, 2.5)), infsup (0.0, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-0.0, 2.5)), infsup (0.0, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (0.1, 0.1)), infsup (0.0, 1.041379743992410623e+00))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (0.1, 1.0)), infsup (0.0, 1.5))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (0.1, 2.5)), infsup (0.0, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (0.1, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (1.0, 1.0)), infsup (0.0, 1.5))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (1.0, 2.5)), infsup (0.0, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (2.5, 2.5)), infsup (0.0, 2.755675960631075672e+00))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (2.5, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-0.1, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-0.1, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-0.1, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-0.1, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-1.0, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-1.0, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-1.0, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-2.5, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-2.5, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-2.5, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-2.5, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-inf, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-inf, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-inf, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-1.0, 0.0)), infsup (6.666666666666666297e-01, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-1.0, -0.0)), infsup (6.666666666666666297e-01, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-2.5, 0.0)), infsup (3.628873693012115154e-01, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-2.5, -0.0)), infsup (3.628873693012115154e-01, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-inf, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-inf, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-0.1, -0.1)), infsup (9.602645007922180342e-01, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-1.0, -0.1)), infsup (6.666666666666666297e-01, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-2.5, -0.1)), infsup (3.628873693012115154e-01, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-inf, -0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-1.0, -1.0)), infsup (6.666666666666666297e-01, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-2.5, -1.0)), infsup (3.628873693012115154e-01, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-inf, -1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-2.5, -2.5)), infsup (3.628873693012115154e-01, inf))); %!test %! assert (isequal (pow (infsup (-0.1, 1.5), infsup (-inf, -2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup), infsup)); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-0.0, -0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (0.0, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-0.0, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (0.0, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-0.0, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (0.1, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (0.1, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (0.1, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (0.1, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (1.0, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (1.0, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (2.5, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (2.5, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-0.1, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-0.1, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-0.1, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-0.1, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-1.0, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-1.0, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-1.0, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-2.5, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-2.5, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-2.5, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-2.5, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-inf, 0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-inf, 1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-inf, 2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-1.0, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-1.0, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-2.5, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-2.5, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-inf, 0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-inf, -0.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-0.1, -0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-1.0, -0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-2.5, -0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-inf, -0.1)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-1.0, -1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-2.5, -1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-inf, -1.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-inf, -2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (-0.1, inf), infsup (-2.5, -2.5)), infsup (0.0, inf))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup), infsup)); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (0.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-0.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (0.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-0.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (0.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-0.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (0.1, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (0.1, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (0.1, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (0.1, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (1.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (1.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (1.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (2.5, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (2.5, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-0.1, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-0.1, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-0.1, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-0.1, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-1.0, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-1.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-1.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-1.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-2.5, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-2.5, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-2.5, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-2.5, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-inf, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-inf, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-inf, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-1.0, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-1.0, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-2.5, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-2.5, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-inf, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-0.1, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-1.0, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-2.5, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-inf, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-1.0, -1.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-2.5, -1.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-inf, -1.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-inf, -2.5)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, 0.0), infsup (-2.5, -2.5)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (0.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-0.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (0.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-0.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (0.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-0.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (0.1, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (0.1, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (0.1, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (0.1, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (1.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (1.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (1.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (2.5, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (2.5, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-0.1, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-0.1, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-0.1, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-0.1, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-1.0, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-1.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-1.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-1.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-2.5, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-2.5, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-2.5, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-2.5, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-inf, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-inf, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-inf, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-1.0, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-1.0, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-2.5, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-2.5, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-inf, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-0.1, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-1.0, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-2.5, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-inf, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-1.0, -1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-2.5, -1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-inf, -1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-inf, -2.5)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, -0.0), infsup (-2.5, -2.5)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (0.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-0.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (0.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-0.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (0.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-0.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (0.1, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (0.1, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (0.1, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (0.1, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (1.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (1.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (1.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (2.5, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (2.5, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-0.1, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-0.1, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-0.1, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-0.1, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-1.0, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-1.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-1.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-1.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-2.5, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-2.5, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-2.5, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-2.5, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-inf, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-inf, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-inf, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-1.0, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-1.0, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-2.5, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-2.5, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-inf, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-0.1, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-1.0, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-2.5, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-inf, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-1.0, -1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-2.5, -1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-inf, -1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-inf, -2.5)), infsup)); %!test %! assert (isequal (pow (infsup (-0.0, 0.0), infsup (-2.5, -2.5)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup), infsup)); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (0.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-0.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (0.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-0.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (0.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-0.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (0.1, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (0.1, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (0.1, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (0.1, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (1.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (1.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (1.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (2.5, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (2.5, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-0.1, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-0.1, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-0.1, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-0.1, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-1.0, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-1.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-1.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-1.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-2.5, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-2.5, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-2.5, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-2.5, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-inf, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-inf, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-inf, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-1.0, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-1.0, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-2.5, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-2.5, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-inf, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-0.1, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-1.0, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-2.5, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-inf, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-1.0, -1.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-2.5, -1.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-inf, -1.0)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-inf, -2.5)), infsup)); %!test %! assert (isequal (pow (infsup (0.0, -0.0), infsup (-2.5, -2.5)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (0.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-0.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (0.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-0.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (0.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-0.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (0.1, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (0.1, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (0.1, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (0.1, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (1.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (1.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (1.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (2.5, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (2.5, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-0.1, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-0.1, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-0.1, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-0.1, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-1.0, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-1.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-1.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-1.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-2.5, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-2.5, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-2.5, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-2.5, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-inf, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-inf, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-inf, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-1.0, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-1.0, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-2.5, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-2.5, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-inf, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-0.1, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-1.0, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-2.5, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-inf, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-1.0, -1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-2.5, -1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-inf, -1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-inf, -2.5)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, 0.0), infsup (-2.5, -2.5)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (0.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-0.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (0.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-0.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (0.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-0.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (0.1, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (0.1, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (0.1, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (0.1, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (1.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (1.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (1.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (2.5, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (2.5, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-0.1, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-0.1, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-0.1, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-0.1, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-1.0, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-1.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-1.0, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-1.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-2.5, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-2.5, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-2.5, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-2.5, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-inf, 0.1)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-inf, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-inf, 2.5)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-1.0, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-1.0, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-2.5, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-2.5, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-inf, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-0.1, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-1.0, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-2.5, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-inf, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-1.0, -1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-2.5, -1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-inf, -1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-inf, -2.5)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.0), infsup (-2.5, -2.5)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (0.0, 1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-0.0, 1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (0.0, 2.5)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-0.0, 2.5)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (0.0, inf)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-0.0, inf)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (0.1, 0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (0.1, 1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (0.1, 2.5)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (0.1, inf)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (1.0, 1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (1.0, 2.5)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (1.0, inf)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (2.5, 2.5)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (2.5, inf)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-0.1, 0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-0.1, 1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-0.1, 2.5)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-0.1, inf)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-1.0, 0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-1.0, 1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-1.0, 2.5)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-1.0, inf)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-2.5, 0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-2.5, 1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-2.5, 2.5)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-2.5, inf)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-inf, 0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-inf, 1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-inf, 2.5)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-1.0, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-1.0, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-2.5, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-2.5, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-inf, -0.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-0.1, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-1.0, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-2.5, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-inf, -0.1)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-1.0, -1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-2.5, -1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-inf, -1.0)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-inf, -2.5)), infsup)); %!test %! assert (isequal (pow (infsup (-1.0, -0.1), infsup (-2.5, -2.5)), infsup)); ## minimal_pow_dec_test %!test %! assert (isequal (pow (infsupdec (0.1, 0.5, "com"), infsupdec (0.0, 1.0, "com")), infsupdec (1.000000000000000056e-01, 1.0, "com"))); %! assert (isequal (decorationpart (pow (infsupdec (0.1, 0.5, "com"), infsupdec (0.0, 1.0, "com"))){1}, decorationpart (infsupdec (1.000000000000000056e-01, 1.0, "com")){1})); %!test %! assert (isequal (pow (infsupdec (0.1, 0.5, "com"), infsupdec (0.1, 0.1, "def")), infsupdec (7.943282347242814900e-01, 9.330329915368075211e-01, "def"))); %! assert (isequal (decorationpart (pow (infsupdec (0.1, 0.5, "com"), infsupdec (0.1, 0.1, "def"))){1}, decorationpart (infsupdec (7.943282347242814900e-01, 9.330329915368075211e-01, "def")){1})); %!test %! assert (isequal (pow (infsupdec (0.1, 0.5, "trv"), infsupdec (-2.5, 2.5, "dac")), infsupdec (3.162277660168379394e-03, 3.162277660168379043e+02, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (0.1, 0.5, "trv"), infsupdec (-2.5, 2.5, "dac"))){1}, decorationpart (infsupdec (3.162277660168379394e-03, 3.162277660168379043e+02, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (0.1, 0.5, "com"), infsupdec (-2.5, inf, "dac")), infsupdec (0.0, 3.162277660168379043e+02, "dac"))); %! assert (isequal (decorationpart (pow (infsupdec (0.1, 0.5, "com"), infsupdec (-2.5, inf, "dac"))){1}, decorationpart (infsupdec (0.0, 3.162277660168379043e+02, "dac")){1})); %!test %! assert (isequal (pow (infsupdec (0.1, 0.5, "trv"), infsupdec (-inf, 0.1, "dac")), infsupdec (7.943282347242814900e-01, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (0.1, 0.5, "trv"), infsupdec (-inf, 0.1, "dac"))){1}, decorationpart (infsupdec (7.943282347242814900e-01, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (0.1, 1.0, "com"), infsupdec (0.0, 2.5, "com")), infsupdec (3.162277660168379394e-03, 1.0, "com"))); %! assert (isequal (decorationpart (pow (infsupdec (0.1, 1.0, "com"), infsupdec (0.0, 2.5, "com"))){1}, decorationpart (infsupdec (3.162277660168379394e-03, 1.0, "com")){1})); %!test %! assert (isequal (pow (infsupdec (0.1, 1.0, "def"), infsupdec (1.0, 1.0, "dac")), infsupdec (1.000000000000000056e-01, 1.0, "def"))); %! assert (isequal (decorationpart (pow (infsupdec (0.1, 1.0, "def"), infsupdec (1.0, 1.0, "dac"))){1}, decorationpart (infsupdec (1.000000000000000056e-01, 1.0, "def")){1})); %!test %! assert (isequal (pow (infsupdec (0.1, 1.0, "trv"), infsupdec (-2.5, 1.0, "def")), infsupdec (1.000000000000000056e-01, 3.162277660168379043e+02, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (0.1, 1.0, "trv"), infsupdec (-2.5, 1.0, "def"))){1}, decorationpart (infsupdec (1.000000000000000056e-01, 3.162277660168379043e+02, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (0.5, 1.5, "dac"), infsupdec (0.1, 0.1, "com")), infsupdec (9.330329915368074101e-01, 1.041379743992410623e+00, "dac"))); %! assert (isequal (decorationpart (pow (infsupdec (0.5, 1.5, "dac"), infsupdec (0.1, 0.1, "com"))){1}, decorationpart (infsupdec (9.330329915368074101e-01, 1.041379743992410623e+00, "dac")){1})); %!test %! assert (isequal (pow (infsupdec (0.5, 1.5, "def"), infsupdec (-2.5, 0.1, "trv")), infsupdec (3.628873693012115154e-01, 5.656854249492380582e+00, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (0.5, 1.5, "def"), infsupdec (-2.5, 0.1, "trv"))){1}, decorationpart (infsupdec (3.628873693012115154e-01, 5.656854249492380582e+00, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (0.5, 1.5, "com"), infsupdec (-2.5, -2.5, "com")), infsupdec (3.628873693012115154e-01, 5.656854249492380582e+00, "com"))); %! assert (isequal (decorationpart (pow (infsupdec (0.5, 1.5, "com"), infsupdec (-2.5, -2.5, "com"))){1}, decorationpart (infsupdec (3.628873693012115154e-01, 5.656854249492380582e+00, "com")){1})); %!test %! assert (isequal (pow (infsupdec (0.5, inf, "dac"), infsupdec (0.1, 0.1, "com")), infsupdec (9.330329915368074101e-01, inf, "dac"))); %! assert (isequal (decorationpart (pow (infsupdec (0.5, inf, "dac"), infsupdec (0.1, 0.1, "com"))){1}, decorationpart (infsupdec (9.330329915368074101e-01, inf, "dac")){1})); %!test %! assert (isequal (pow (infsupdec (0.5, inf, "def"), infsupdec (-2.5, -0.0, "com")), infsupdec (0.0, 5.656854249492380582e+00, "def"))); %! assert (isequal (decorationpart (pow (infsupdec (0.5, inf, "def"), infsupdec (-2.5, -0.0, "com"))){1}, decorationpart (infsupdec (0.0, 5.656854249492380582e+00, "def")){1})); %!test %! assert (isequal (pow (infsupdec (1.0, 1.5, "com"), infsupdec (-0.1, 0.1, "def")), infsupdec (9.602645007922180342e-01, 1.041379743992410623e+00, "def"))); %! assert (isequal (decorationpart (pow (infsupdec (1.0, 1.5, "com"), infsupdec (-0.1, 0.1, "def"))){1}, decorationpart (infsupdec (9.602645007922180342e-01, 1.041379743992410623e+00, "def")){1})); %!test %! assert (isequal (pow (infsupdec (1.0, 1.5, "trv"), infsupdec (-0.1, -0.1, "com")), infsupdec (9.602645007922180342e-01, 1.0, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (1.0, 1.5, "trv"), infsupdec (-0.1, -0.1, "com"))){1}, decorationpart (infsupdec (9.602645007922180342e-01, 1.0, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (1.0, inf, "dac"), infsupdec (1.0, 1.0, "dac")), infsupdec (1.0, inf, "dac"))); %! assert (isequal (decorationpart (pow (infsupdec (1.0, inf, "dac"), infsupdec (1.0, 1.0, "dac"))){1}, decorationpart (infsupdec (1.0, inf, "dac")){1})); %!test %! assert (isequal (pow (infsupdec (1.0, inf, "def"), infsupdec (-1.0, -0.0, "dac")), infsupdec (0.000000000000000000e+00, 1.0, "def"))); %! assert (isequal (decorationpart (pow (infsupdec (1.0, inf, "def"), infsupdec (-1.0, -0.0, "dac"))){1}, decorationpart (infsupdec (0.000000000000000000e+00, 1.0, "def")){1})); %!test %! assert (isequal (pow (infsupdec (1.1, 1.5, "def"), infsupdec (1.0, 2.5, "com")), infsupdec (1.100000000000000089e+00, 2.755675960631075672e+00, "def"))); %! assert (isequal (decorationpart (pow (infsupdec (1.1, 1.5, "def"), infsupdec (1.0, 2.5, "com"))){1}, decorationpart (infsupdec (1.100000000000000089e+00, 2.755675960631075672e+00, "def")){1})); %!test %! assert (isequal (pow (infsupdec (1.1, 1.5, "com"), infsupdec (-0.1, -0.1, "com")), infsupdec (9.602645007922180342e-01, 9.905142582145218810e-01, "com"))); %! assert (isequal (decorationpart (pow (infsupdec (1.1, 1.5, "com"), infsupdec (-0.1, -0.1, "com"))){1}, decorationpart (infsupdec (9.602645007922180342e-01, 9.905142582145218810e-01, "com")){1})); %!test %! assert (isequal (pow (infsupdec (1.1, inf, "dac"), infsupdec (0.1, inf, "dac")), infsupdec (1.009576582776886999e+00, inf, "dac"))); %! assert (isequal (decorationpart (pow (infsupdec (1.1, inf, "dac"), infsupdec (0.1, inf, "dac"))){1}, decorationpart (infsupdec (1.009576582776886999e+00, inf, "dac")){1})); %!test %! assert (isequal (pow (infsupdec (1.1, inf, "def"), infsupdec (-2.5, inf, "dac")), infsupdec (0.000000000000000000e+00, inf, "def"))); %! assert (isequal (decorationpart (pow (infsupdec (1.1, inf, "def"), infsupdec (-2.5, inf, "dac"))){1}, decorationpart (infsupdec (0.000000000000000000e+00, inf, "def")){1})); %!test %! assert (isequal (pow (infsupdec (1.1, inf, "trv"), infsupdec (-inf, -1.0, "def")), infsupdec (0.000000000000000000e+00, 9.090909090909090606e-01, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (1.1, inf, "trv"), infsupdec (-inf, -1.0, "def"))){1}, decorationpart (infsupdec (0.000000000000000000e+00, 9.090909090909090606e-01, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (0.0, 0.5, "com"), infsupdec (0.1, 0.1, "com")), infsupdec (0.0, 9.330329915368075211e-01, "com"))); %! assert (isequal (decorationpart (pow (infsupdec (0.0, 0.5, "com"), infsupdec (0.1, 0.1, "com"))){1}, decorationpart (infsupdec (0.0, 9.330329915368075211e-01, "com")){1})); %!test %! assert (isequal (pow (infsupdec (0.0, 0.5, "com"), infsupdec (2.5, inf, "dac")), infsupdec (0.0, 1.767766952966368932e-01, "dac"))); %! assert (isequal (decorationpart (pow (infsupdec (0.0, 0.5, "com"), infsupdec (2.5, inf, "dac"))){1}, decorationpart (infsupdec (0.0, 1.767766952966368932e-01, "dac")){1})); %!test %! assert (isequal (pow (infsupdec (0.0, 0.5, "com"), infsupdec (-inf, -2.5, "dac")), infsupdec (5.656854249492379694e+00, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (0.0, 0.5, "com"), infsupdec (-inf, -2.5, "dac"))){1}, decorationpart (infsupdec (5.656854249492379694e+00, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (0.0, 1.0, "com"), infsupdec (0.0, 0.0, "com")), infsupdec (1.0, 1.0, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (0.0, 1.0, "com"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (1.0, 1.0, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (0.0, 1.0, "def"), infsupdec (0.0, 2.5, "dac")), infsupdec (0.0, 1.0, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (0.0, 1.0, "def"), infsupdec (0.0, 2.5, "dac"))){1}, decorationpart (infsupdec (0.0, 1.0, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (0.0, 1.0, "dac"), infsupdec (1.0, 2.5, "com")), infsupdec (0.0, 1.0, "dac"))); %! assert (isequal (decorationpart (pow (infsupdec (0.0, 1.0, "dac"), infsupdec (1.0, 2.5, "com"))){1}, decorationpart (infsupdec (0.0, 1.0, "dac")){1})); %!test %! assert (isequal (pow (infsupdec (0.0, 1.0, "com"), infsupdec (-2.5, 0.1, "dac")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (0.0, 1.0, "com"), infsupdec (-2.5, 0.1, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (0.0, 1.0, "def"), infsupdec (entire, "def")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (0.0, 1.0, "def"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (0.0, 1.0, "dac"), infsupdec (-0.1, 0.0, "com")), infsupdec (1.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (0.0, 1.0, "dac"), infsupdec (-0.1, 0.0, "com"))){1}, decorationpart (infsupdec (1.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (0.0, 1.0, "com"), infsupdec (-inf, 0.0, "dac")), infsupdec (1.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (0.0, 1.0, "com"), infsupdec (-inf, 0.0, "dac"))){1}, decorationpart (infsupdec (1.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (0.0, 1.0, "def"), infsupdec (-inf, -2.5, "dac")), infsupdec (1.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (0.0, 1.0, "def"), infsupdec (-inf, -2.5, "dac"))){1}, decorationpart (infsupdec (1.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (0.0, 1.5, "com"), infsupdec (0.0, 2.5, "com")), infsupdec (0.0, 2.755675960631075672e+00, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (0.0, 1.5, "com"), infsupdec (0.0, 2.5, "com"))){1}, decorationpart (infsupdec (0.0, 2.755675960631075672e+00, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (0.0, 1.5, "def"), infsupdec (2.5, 2.5, "dac")), infsupdec (0.0, 2.755675960631075672e+00, "def"))); %! assert (isequal (decorationpart (pow (infsupdec (0.0, 1.5, "def"), infsupdec (2.5, 2.5, "dac"))){1}, decorationpart (infsupdec (0.0, 2.755675960631075672e+00, "def")){1})); %!test %! assert (isequal (pow (infsupdec (0.0, 1.5, "dac"), infsupdec (-1.0, 0.0, "com")), infsupdec (6.666666666666666297e-01, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (0.0, 1.5, "dac"), infsupdec (-1.0, 0.0, "com"))){1}, decorationpart (infsupdec (6.666666666666666297e-01, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (0.0, 1.5, "com"), infsupdec (-2.5, -2.5, "def")), infsupdec (3.628873693012115154e-01, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (0.0, 1.5, "com"), infsupdec (-2.5, -2.5, "def"))){1}, decorationpart (infsupdec (3.628873693012115154e-01, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (0.0, inf, "dac"), infsupdec (0.1, 0.1, "com")), infsupdec (0.0, inf, "dac"))); %! assert (isequal (decorationpart (pow (infsupdec (0.0, inf, "dac"), infsupdec (0.1, 0.1, "com"))){1}, decorationpart (infsupdec (0.0, inf, "dac")){1})); %!test %! assert (isequal (pow (infsupdec (0.0, inf, "def"), infsupdec (-1.0, 1.0, "dac")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (0.0, inf, "def"), infsupdec (-1.0, 1.0, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (0.0, inf, "trv"), infsupdec (-inf, -1.0, "def")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (0.0, inf, "trv"), infsupdec (-inf, -1.0, "def"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (0.0, inf, "dac"), infsupdec (-2.5, -2.5, "dac")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (0.0, inf, "dac"), infsupdec (-2.5, -2.5, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.0, 0.5, "com"), infsupdec (0.0, inf, "dac")), infsupdec (0.0, 1.0, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.0, 0.5, "com"), infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (0.0, 1.0, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.0, 0.5, "def"), infsupdec (0.1, inf, "def")), infsupdec (0.0, 9.330329915368075211e-01, "def"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.0, 0.5, "def"), infsupdec (0.1, inf, "def"))){1}, decorationpart (infsupdec (0.0, 9.330329915368075211e-01, "def")){1})); %!test %! assert (isequal (pow (infsupdec (-0.0, 0.5, "dac"), infsupdec (2.5, 2.5, "com")), infsupdec (0.0, 1.767766952966368932e-01, "dac"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.0, 0.5, "dac"), infsupdec (2.5, 2.5, "com"))){1}, decorationpart (infsupdec (0.0, 1.767766952966368932e-01, "dac")){1})); %!test %! assert (isequal (pow (infsupdec (-0.0, 0.5, "trv"), infsupdec (-2.5, -0.0, "dac")), infsupdec (1.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.0, 0.5, "trv"), infsupdec (-2.5, -0.0, "dac"))){1}, decorationpart (infsupdec (1.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.0, 0.5, "com"), infsupdec (-inf, -0.1, "def")), infsupdec (1.071773462536293131e+00, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.0, 0.5, "com"), infsupdec (-inf, -0.1, "def"))){1}, decorationpart (infsupdec (1.071773462536293131e+00, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.0, 0.5, "def"), infsupdec (-inf, -2.5, "dac")), infsupdec (5.656854249492379694e+00, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.0, 0.5, "def"), infsupdec (-inf, -2.5, "dac"))){1}, decorationpart (infsupdec (5.656854249492379694e+00, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.0, 1.0, "com"), infsupdec (2.5, 2.5, "dac")), infsupdec (0.0, 1.0, "dac"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.0, 1.0, "com"), infsupdec (2.5, 2.5, "dac"))){1}, decorationpart (infsupdec (0.0, 1.0, "dac")){1})); %!test %! assert (isequal (pow (infsupdec (-0.0, 1.0, "dac"), infsupdec (-1.0, inf, "def")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.0, 1.0, "dac"), infsupdec (-1.0, inf, "def"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.0, 1.0, "com"), infsupdec (entire, "def")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.0, 1.0, "com"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.0, 1.0, "def"), infsupdec (-2.5, -2.5, "com")), infsupdec (1.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.0, 1.0, "def"), infsupdec (-2.5, -2.5, "com"))){1}, decorationpart (infsupdec (1.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.0, 1.0, "dac"), infsupdec (-inf, -2.5, "def")), infsupdec (1.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.0, 1.0, "dac"), infsupdec (-inf, -2.5, "def"))){1}, decorationpart (infsupdec (1.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.0, 1.5, "com"), infsupdec (0.1, 2.5, "dac")), infsupdec (0.0, 2.755675960631075672e+00, "dac"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.0, 1.5, "com"), infsupdec (0.1, 2.5, "dac"))){1}, decorationpart (infsupdec (0.0, 2.755675960631075672e+00, "dac")){1})); %!test %! assert (isequal (pow (infsupdec (-0.0, 1.5, "def"), infsupdec (-1.0, 0.0, "trv")), infsupdec (6.666666666666666297e-01, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.0, 1.5, "def"), infsupdec (-1.0, 0.0, "trv"))){1}, decorationpart (infsupdec (6.666666666666666297e-01, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.0, 1.5, "dac"), infsupdec (-2.5, -0.1, "def")), infsupdec (3.628873693012115154e-01, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.0, 1.5, "dac"), infsupdec (-2.5, -0.1, "def"))){1}, decorationpart (infsupdec (3.628873693012115154e-01, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.0, 1.5, "com"), infsupdec (-2.5, -2.5, "com")), infsupdec (3.628873693012115154e-01, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.0, 1.5, "com"), infsupdec (-2.5, -2.5, "com"))){1}, decorationpart (infsupdec (3.628873693012115154e-01, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.0, 1.5, "def"), infsupdec (-inf, -2.5, "dac")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.0, 1.5, "def"), infsupdec (-inf, -2.5, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.0, inf, "dac"), infsupdec (-0.1, inf, "dac")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.0, inf, "dac"), infsupdec (-0.1, inf, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.0, inf, "def"), infsupdec (-2.5, -0.0, "com")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.0, inf, "def"), infsupdec (-2.5, -0.0, "com"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.0, inf, "trv"), infsupdec (-inf, 0.0, "def")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.0, inf, "trv"), infsupdec (-inf, 0.0, "def"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.0, inf, "dac"), infsupdec (-inf, -0.0, "trv")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.0, inf, "dac"), infsupdec (-inf, -0.0, "trv"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.0, inf, "def"), infsupdec (-inf, -1.0, "def")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.0, inf, "def"), infsupdec (-inf, -1.0, "def"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.1, 0.5, "def"), infsupdec (0.1, inf, "dac")), infsupdec (0.0, 9.330329915368075211e-01, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.1, 0.5, "def"), infsupdec (0.1, inf, "dac"))){1}, decorationpart (infsupdec (0.0, 9.330329915368075211e-01, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.1, 0.5, "com"), infsupdec (-0.1, -0.1, "com")), infsupdec (1.071773462536293131e+00, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.1, 0.5, "com"), infsupdec (-0.1, -0.1, "com"))){1}, decorationpart (infsupdec (1.071773462536293131e+00, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.1, 0.5, "dac"), infsupdec (-inf, -2.5, "def")), infsupdec (5.656854249492379694e+00, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.1, 0.5, "dac"), infsupdec (-inf, -2.5, "def"))){1}, decorationpart (infsupdec (5.656854249492379694e+00, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.1, 1.0, "com"), infsupdec (0.0, 0.0, "com")), infsupdec (1.0, 1.0, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.1, 1.0, "com"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (1.0, 1.0, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.1, 1.0, "dac"), infsupdec (-inf, 2.5, "dac")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.1, 1.0, "dac"), infsupdec (-inf, 2.5, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.1, 1.0, "def"), infsupdec (-inf, -1.0, "def")), infsupdec (1.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.1, 1.0, "def"), infsupdec (-inf, -1.0, "def"))){1}, decorationpart (infsupdec (1.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.1, 1.0, "com"), infsupdec (-2.5, -2.5, "com")), infsupdec (1.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.1, 1.0, "com"), infsupdec (-2.5, -2.5, "com"))){1}, decorationpart (infsupdec (1.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.1, 1.0, "trv"), infsupdec (-inf, -2.5, "trv")), infsupdec (1.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.1, 1.0, "trv"), infsupdec (-inf, -2.5, "trv"))){1}, decorationpart (infsupdec (1.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.1, 1.5, "trv"), infsupdec (0.0, 2.5, "com")), infsupdec (0.0, 2.755675960631075672e+00, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.1, 1.5, "trv"), infsupdec (0.0, 2.5, "com"))){1}, decorationpart (infsupdec (0.0, 2.755675960631075672e+00, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.1, 1.5, "com"), infsupdec (2.5, 2.5, "dac")), infsupdec (0.0, 2.755675960631075672e+00, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.1, 1.5, "com"), infsupdec (2.5, 2.5, "dac"))){1}, decorationpart (infsupdec (0.0, 2.755675960631075672e+00, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.1, 1.5, "dac"), infsupdec (-1.0, 0.0, "trv")), infsupdec (6.666666666666666297e-01, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.1, 1.5, "dac"), infsupdec (-1.0, 0.0, "trv"))){1}, decorationpart (infsupdec (6.666666666666666297e-01, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.1, 1.5, "com"), infsupdec (-0.1, -0.1, "com")), infsupdec (9.602645007922180342e-01, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.1, 1.5, "com"), infsupdec (-0.1, -0.1, "com"))){1}, decorationpart (infsupdec (9.602645007922180342e-01, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.1, 1.5, "def"), infsupdec (-2.5, -2.5, "def")), infsupdec (3.628873693012115154e-01, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.1, 1.5, "def"), infsupdec (-2.5, -2.5, "def"))){1}, decorationpart (infsupdec (3.628873693012115154e-01, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.1, inf, "dac"), infsupdec (-0.1, 2.5, "com")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.1, inf, "dac"), infsupdec (-0.1, 2.5, "com"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.1, inf, "def"), infsupdec (-2.5, 0.0, "def")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.1, inf, "def"), infsupdec (-2.5, 0.0, "def"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-0.1, inf, "dac"), infsupdec (-2.5, -2.5, "trv")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-0.1, inf, "dac"), infsupdec (-2.5, -2.5, "trv"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (0.0, 0.0, "com"), infsupdec (1.0, inf, "dac")), infsupdec (0.0, 0.0, "dac"))); %! assert (isequal (decorationpart (pow (infsupdec (0.0, 0.0, "com"), infsupdec (1.0, inf, "dac"))){1}, decorationpart (infsupdec (0.0, 0.0, "dac")){1})); %!test %! assert (isequal (pow (infsupdec (0.0, 0.0, "com"), infsupdec (-2.5, 0.1, "com")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (0.0, 0.0, "com"), infsupdec (-2.5, 0.1, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (0.0, 0.0, "dac"), infsupdec (-1.0, 0.0, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (0.0, 0.0, "dac"), infsupdec (-1.0, 0.0, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-1.0, -0.1, "com"), infsupdec (-0.1, 1.0, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-1.0, -0.1, "com"), infsupdec (-0.1, 1.0, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-1.0, -0.1, "dac"), infsupdec (-0.1, 2.5, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-1.0, -0.1, "dac"), infsupdec (-0.1, 2.5, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (pow (infsupdec (-1.0, -0.1, "def"), infsupdec (-0.1, inf, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (pow (infsupdec (-1.0, -0.1, "def"), infsupdec (-0.1, inf, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); ## minimal_exp_test %!test %! assert (isequal (exp (infsup), infsup)); %!test %! assert (isequal (exp (infsup (-inf, 0.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (exp (infsup (-inf, -0.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (exp (infsup (0.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (exp (infsup (-0.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (exp (infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (exp (infsup (-inf, 7.097827128933840868e+02)), infsup (0.0, inf))); %!test %! assert (isequal (exp (infsup (7.097827128933840868e+02, 7.097827128933840868e+02)), infsup (1.797693134862315708e+308, inf))); %!test %! assert (isequal (exp (infsup (0.0, 7.097827128933822678e+02)), infsup (1.0, 1.797693134859207786e+308))); %!test %! assert (isequal (exp (infsup (-0.0, 7.097827128933822678e+02)), infsup (1.0, 1.797693134859207786e+308))); %!test %! assert (isequal (exp (infsup (-7.083964185322641924e+02, 7.097827128933822678e+02)), infsup (2.225073858507009192e-308, 1.797693134859207786e+308))); %!test %! assert (isequal (exp (infsup (-3.541982092661320962e+02, 7.097827128933822678e+02)), infsup (1.491668146239976927e-154, 1.797693134859207786e+308))); %!test %! assert (isequal (exp (infsup (-3.541982092661320962e+02, 0.0)), infsup (1.491668146239976927e-154, 1.0))); %!test %! assert (isequal (exp (infsup (-3.541982092661320962e+02, -0.0)), infsup (1.491668146239976927e-154, 1.0))); %!test %! assert (isequal (exp (infsup (-3.541982092661320962e+02, 1.0)), infsup (1.491668146239976927e-154, 2.718281828459045535e+00))); %!test %! assert (isequal (exp (infsup (1.0, 5.0)), infsup (2.718281828459045091e+00, 1.484131591025766284e+02))); %!test %! assert (isequal (exp (infsup (-3.321928094887362626e+00, 1.807354922057604174e+00)), infsup (3.608319282078719520e-02, 6.094306179356355990e+00))); %!test %! assert (isequal (exp (infsup (7.655347463629769145e-01, 9.883328352961747498e+01)), infsup (2.150143848892317244e+00, 8.370466551497384459e+42))); %!test %! assert (isequal (exp (infsup (1.175028826901562873e+01, 2.599046225837774315e+01)), infsup (1.267901033964801463e+05, 1.938716653660042725e+11))); ## minimal_exp_dec_test %!test %! assert (isequal (exp (infsupdec (7.097827128933840868e+02, 7.097827128933840868e+02, "com")), infsupdec (1.797693134862315708e+308, inf, "dac"))); %! assert (isequal (decorationpart (exp (infsupdec (7.097827128933840868e+02, 7.097827128933840868e+02, "com"))){1}, decorationpart (infsupdec (1.797693134862315708e+308, inf, "dac")){1})); %!test %! assert (isequal (exp (infsupdec (0.0, 7.097827128933822678e+02, "def")), infsupdec (1.0, 1.797693134859207786e+308, "def"))); %! assert (isequal (decorationpart (exp (infsupdec (0.0, 7.097827128933822678e+02, "def"))){1}, decorationpart (infsupdec (1.0, 1.797693134859207786e+308, "def")){1})); ## minimal_exp2_test %!test %! assert (isequal (pow2 (infsup), infsup)); %!test %! assert (isequal (pow2 (infsup (-inf, 0.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow2 (infsup (-inf, -0.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow2 (infsup (0.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (pow2 (infsup (-0.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (pow2 (infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow2 (infsup (-inf, 1024.0)), infsup (0.0, inf))); %!test %! assert (isequal (pow2 (infsup (1024.0, 1024.0)), infsup (1.797693134862315708e+308, inf))); %!test %! assert (isequal (pow2 (infsup (0.0, 1023.0)), infsup (1.0, 8.988465674311579539e+307))); %!test %! assert (isequal (pow2 (infsup (-0.0, 1023.0)), infsup (1.0, 8.988465674311579539e+307))); %!test %! assert (isequal (pow2 (infsup (-1022.0, 1023.0)), infsup (2.225073858507201383e-308, 8.988465674311579539e+307))); %!test %! assert (isequal (pow2 (infsup (-1022.0, 0.0)), infsup (2.225073858507201383e-308, 1.0))); %!test %! assert (isequal (pow2 (infsup (-1022.0, -0.0)), infsup (2.225073858507201383e-308, 1.0))); %!test %! assert (isequal (pow2 (infsup (-1022.0, 1.0)), infsup (2.225073858507201383e-308, 2.0))); %!test %! assert (isequal (pow2 (infsup (1.0, 5.0)), infsup (2.0, 32.0))); %!test %! assert (isequal (pow2 (infsup (-3.321928094887362626e+00, 1.807354922057604174e+00)), infsup (9.999999999999997780e-02, 3.500000000000000444e+00))); %!test %! assert (isequal (pow2 (infsup (7.655347463629769145e-01, 9.883328352961747498e+01)), infsup (1.699999999999999734e+00, 5.646546544444466696e+29))); %!test %! assert (isequal (pow2 (infsup (1.175028826901562873e+01, 2.599046225837774315e+01)), infsup (3.445000003400298283e+03, 6.666666666666669399e+07))); ## minimal_exp2_dec_test %!test %! assert (isequal (pow2 (infsupdec (1024.0, 1024.0, "com")), infsupdec (1.797693134862315708e+308, inf, "dac"))); %! assert (isequal (decorationpart (pow2 (infsupdec (1024.0, 1024.0, "com"))){1}, decorationpart (infsupdec (1.797693134862315708e+308, inf, "dac")){1})); %!test %! assert (isequal (pow2 (infsupdec (7.655347463629769145e-01, 9.883328352961747498e+01, "def")), infsupdec (1.699999999999999734e+00, 5.646546544444466696e+29, "def"))); %! assert (isequal (decorationpart (pow2 (infsupdec (7.655347463629769145e-01, 9.883328352961747498e+01, "def"))){1}, decorationpart (infsupdec (1.699999999999999734e+00, 5.646546544444466696e+29, "def")){1})); ## minimal_exp10_test %!test %! assert (isequal (pow10 (infsup), infsup)); %!test %! assert (isequal (pow10 (infsup (-inf, 0.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow10 (infsup (-inf, -0.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (pow10 (infsup (0.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (pow10 (infsup (-0.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (pow10 (infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (pow10 (infsup (-inf, 3.082547155599167468e+02)), infsup (0.0, inf))); %!test %! assert (isequal (pow10 (infsup (3.082547155599167468e+02, 3.082547155599167468e+02)), infsup (1.797693134862315708e+308, inf))); %!test %! assert (isequal (pow10 (infsup (0.0, 3.082547155599166899e+02)), infsup (1.0, 1.797693134862092573e+308))); %!test %! assert (isequal (pow10 (infsup (-0.0, 3.082547155599166899e+02)), infsup (1.0, 1.797693134862092573e+308))); %!test %! assert (isequal (pow10 (infsup (-3.076526555685887843e+02, 3.082547155599166899e+02)), infsup (2.225073858507187055e-308, 1.797693134862092573e+308))); %!test %! assert (isequal (pow10 (infsup (-1.450000000000000000e+02, 3.082547155599166899e+02)), infsup (9.999999999999999149e-146, 1.797693134862092573e+308))); %!test %! assert (isequal (pow10 (infsup (-1.450000000000000000e+02, 0.0)), infsup (9.999999999999999149e-146, 1.0))); %!test %! assert (isequal (pow10 (infsup (-1.450000000000000000e+02, -0.0)), infsup (9.999999999999999149e-146, 1.0))); %!test %! assert (isequal (pow10 (infsup (-1.450000000000000000e+02, 1.0)), infsup (9.999999999999999149e-146, 10.0))); %!test %! assert (isequal (pow10 (infsup (1.0, 5.0)), infsup (10.0, 100000.0))); %!test %! assert (isequal (pow10 (infsup (-3.321928094887362626e+00, 1.807354922057604174e+00)), infsup (4.765098748902241383e-04, 6.417338117537050834e+01))); %!test %! assert (isequal (pow10 (infsup (7.655347463629769145e-01, 9.883328352961747498e+01)), infsup (5.828204023267978151e+00, 6.812139448068793717e+98))); %!test %! assert (isequal (pow10 (infsup (1.175028826901562873e+01, 2.599046225837774315e+01)), infsup (5.627147109892520752e+11, 9.782779355126447395e+25))); ## minimal_exp10_dec_test %!test %! assert (isequal (pow10 (infsupdec (3.082547155599167468e+02, 3.082547155599167468e+02, "com")), infsupdec (1.797693134862315708e+308, inf, "dac"))); %! assert (isequal (decorationpart (pow10 (infsupdec (3.082547155599167468e+02, 3.082547155599167468e+02, "com"))){1}, decorationpart (infsupdec (1.797693134862315708e+308, inf, "dac")){1})); %!test %! assert (isequal (pow10 (infsupdec (7.655347463629769145e-01, 9.883328352961747498e+01, "def")), infsupdec (5.828204023267978151e+00, 6.812139448068793717e+98, "def"))); %! assert (isequal (decorationpart (pow10 (infsupdec (7.655347463629769145e-01, 9.883328352961747498e+01, "def"))){1}, decorationpart (infsupdec (5.828204023267978151e+00, 6.812139448068793717e+98, "def")){1})); ## minimal_log_test %!test %! assert (isequal (log (infsup), infsup)); %!test %! assert (isequal (log (infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (log (infsup (-inf, -0.0)), infsup)); %!test %! assert (isequal (log (infsup (0.0, 1.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (log (infsup (-0.0, 1.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (log (infsup (1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (log (infsup (0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (log (infsup (-0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (log (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (log (infsup (0.0, 1.797693134862315708e+308)), infsup (-inf, 7.097827128933840868e+02))); %!test %! assert (isequal (log (infsup (-0.0, 1.797693134862315708e+308)), infsup (-inf, 7.097827128933840868e+02))); %!test %! assert (isequal (log (infsup (1.0, 1.797693134862315708e+308)), infsup (0.0, 7.097827128933840868e+02))); %!test %! assert (isequal (log (infsup (4.940656458412465442e-324, 1.797693134862315708e+308)), infsup (-7.444400719213813318e+02, 7.097827128933840868e+02))); %!test %! assert (isequal (log (infsup (4.940656458412465442e-324, 1.0)), infsup (-7.444400719213813318e+02, 0.0))); %!test %! assert (isequal (log (infsup (2.718281828459045091e+00, 2.718281828459045091e+00)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (log (infsup (2.718281828459045535e+00, 2.718281828459045535e+00)), infsup (1.000000000000000000e+00, 1.000000000000000222e+00))); %!test %! assert (isequal (log (infsup (4.940656458412465442e-324, 2.718281828459045535e+00)), infsup (-7.444400719213813318e+02, 1.000000000000000222e+00))); %!test %! assert (isequal (log (infsup (2.718281828459045091e+00, 32.0)), infsup (9.999999999999998890e-01, 3.465735902799726986e+00))); %!test %! assert (isequal (log (infsup (1.000000000000000056e-01, 3.500000000000000000e+00)), infsup (-2.302585092994045901e+00, 1.252762968495368057e+00))); %!test %! assert (isequal (log (infsup (1.699999999999999956e+00, 5.646546544444444178e+29)), infsup (5.306282510621702642e-01, 6.850601182403603673e+01))); %!test %! assert (isequal (log (infsup (3.445000003400302830e+03, 6.666666666666659713e+07)), infsup (8.144679184434783892e+00, 1.801521563584420349e+01))); ## minimal_log_dec_test %!test %! assert (isequal (log (infsupdec (4.940656458412465442e-324, 1.797693134862315708e+308, "com")), infsupdec (-7.444400719213813318e+02, 7.097827128933840868e+02, "com"))); %! assert (isequal (decorationpart (log (infsupdec (4.940656458412465442e-324, 1.797693134862315708e+308, "com"))){1}, decorationpart (infsupdec (-7.444400719213813318e+02, 7.097827128933840868e+02, "com")){1})); %!test %! assert (isequal (log (infsupdec (0.0, 1.0, "com")), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (log (infsupdec (0.0, 1.0, "com"))){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %!test %! assert (isequal (log (infsupdec (2.718281828459045535e+00, 2.718281828459045535e+00, "def")), infsupdec (1.000000000000000000e+00, 1.000000000000000222e+00, "def"))); %! assert (isequal (decorationpart (log (infsupdec (2.718281828459045535e+00, 2.718281828459045535e+00, "def"))){1}, decorationpart (infsupdec (1.000000000000000000e+00, 1.000000000000000222e+00, "def")){1})); ## minimal_log2_test %!test %! assert (isequal (log2 (infsup), infsup)); %!test %! assert (isequal (log2 (infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (log2 (infsup (-inf, -0.0)), infsup)); %!test %! assert (isequal (log2 (infsup (0.0, 1.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (log2 (infsup (-0.0, 1.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (log2 (infsup (1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (log2 (infsup (0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (log2 (infsup (-0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (log2 (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (log2 (infsup (0.0, 1.797693134862315708e+308)), infsup (-inf, 1024.0))); %!test %! assert (isequal (log2 (infsup (-0.0, 1.797693134862315708e+308)), infsup (-inf, 1024.0))); %!test %! assert (isequal (log2 (infsup (1.0, 1.797693134862315708e+308)), infsup (0.0, 1024.0))); %!test %! assert (isequal (log2 (infsup (4.940656458412465442e-324, 1.797693134862315708e+308)), infsup (-1074.0, 1024.0))); %!test %! assert (isequal (log2 (infsup (4.940656458412465442e-324, 1.0)), infsup (-1074.0, 0.0))); %!test %! assert (isequal (log2 (infsup (4.940656458412465442e-324, 2.0)), infsup (-1074.0, 1.0))); %!test %! assert (isequal (log2 (infsup (2.0, 32.0)), infsup (1.0, 5.0))); %!test %! assert (isequal (log2 (infsup (1.000000000000000056e-01, 3.500000000000000000e+00)), infsup (-3.321928094887362626e+00, 1.807354922057604174e+00))); %!test %! assert (isequal (log2 (infsup (1.699999999999999956e+00, 5.646546544444444178e+29)), infsup (7.655347463629769145e-01, 9.883328352961747498e+01))); %!test %! assert (isequal (log2 (infsup (3.445000003400302830e+03, 6.666666666666659713e+07)), infsup (1.175028826901562873e+01, 2.599046225837774315e+01))); ## minimal_log2_dec_test %!test %! assert (isequal (log2 (infsupdec (4.940656458412465442e-324, 1.797693134862315708e+308, "com")), infsupdec (-1074.0, 1024.0, "com"))); %! assert (isequal (decorationpart (log2 (infsupdec (4.940656458412465442e-324, 1.797693134862315708e+308, "com"))){1}, decorationpart (infsupdec (-1074.0, 1024.0, "com")){1})); %!test %! assert (isequal (log2 (infsupdec (4.940656458412465442e-324, inf, "dac")), infsupdec (-1074.0, inf, "dac"))); %! assert (isequal (decorationpart (log2 (infsupdec (4.940656458412465442e-324, inf, "dac"))){1}, decorationpart (infsupdec (-1074.0, inf, "dac")){1})); %!test %! assert (isequal (log2 (infsupdec (2.0, 32.0, "def")), infsupdec (1.0, 5.0, "def"))); %! assert (isequal (decorationpart (log2 (infsupdec (2.0, 32.0, "def"))){1}, decorationpart (infsupdec (1.0, 5.0, "def")){1})); %!test %! assert (isequal (log2 (infsupdec (0.0, 1.797693134862315708e+308, "com")), infsupdec (-inf, 1024.0, "trv"))); %! assert (isequal (decorationpart (log2 (infsupdec (0.0, 1.797693134862315708e+308, "com"))){1}, decorationpart (infsupdec (-inf, 1024.0, "trv")){1})); ## minimal_log10_test %!test %! assert (isequal (log10 (infsup), infsup)); %!test %! assert (isequal (log10 (infsup (-inf, 0.0)), infsup)); %!test %! assert (isequal (log10 (infsup (-inf, -0.0)), infsup)); %!test %! assert (isequal (log10 (infsup (0.0, 1.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (log10 (infsup (-0.0, 1.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (log10 (infsup (1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (log10 (infsup (0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (log10 (infsup (-0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (log10 (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (log10 (infsup (0.0, 1.797693134862315708e+308)), infsup (-inf, 3.082547155599167468e+02))); %!test %! assert (isequal (log10 (infsup (-0.0, 1.797693134862315708e+308)), infsup (-inf, 3.082547155599167468e+02))); %!test %! assert (isequal (log10 (infsup (1.0, 1.797693134862315708e+308)), infsup (0.0, 3.082547155599167468e+02))); %!test %! assert (isequal (log10 (infsup (4.940656458412465442e-324, 1.797693134862315708e+308)), infsup (-3.233062153431158094e+02, 3.082547155599167468e+02))); %!test %! assert (isequal (log10 (infsup (4.940656458412465442e-324, 1.0)), infsup (-3.233062153431158094e+02, 0.0))); %!test %! assert (isequal (log10 (infsup (4.940656458412465442e-324, 10.0)), infsup (-3.233062153431158094e+02, 1.0))); %!test %! assert (isequal (log10 (infsup (10.0, 100000.0)), infsup (1.0, 5.0))); %!test %! assert (isequal (log10 (infsup (1.000000000000000056e-01, 3.500000000000000000e+00)), infsup (-1.000000000000000000e+00, 5.440680443502756702e-01))); %!test %! assert (isequal (log10 (infsup (1.000000000000000056e-01, 1.000000000000000056e-01)), infsup (-1.000000000000000000e+00, -9.999999999999998890e-01))); %!test %! assert (isequal (log10 (infsup (1.699999999999999956e+00, 5.646546544444444178e+29)), infsup (2.304489213782739132e-01, 2.975178291237777373e+01))); %!test %! assert (isequal (log10 (infsup (3.445000003400302830e+03, 6.666666666666659713e+07)), infsup (3.537189226672304176e+00, 7.823908740944318652e+00))); ## minimal_log10_dec_test %!test %! assert (isequal (log10 (infsupdec (4.940656458412465442e-324, 1.797693134862315708e+308, "com")), infsupdec (-3.233062153431158094e+02, 3.082547155599167468e+02, "com"))); %! assert (isequal (decorationpart (log10 (infsupdec (4.940656458412465442e-324, 1.797693134862315708e+308, "com"))){1}, decorationpart (infsupdec (-3.233062153431158094e+02, 3.082547155599167468e+02, "com")){1})); %!test %! assert (isequal (log10 (infsupdec (0.0, 1.797693134862315708e+308, "dac")), infsupdec (-inf, 3.082547155599167468e+02, "trv"))); %! assert (isequal (decorationpart (log10 (infsupdec (0.0, 1.797693134862315708e+308, "dac"))){1}, decorationpart (infsupdec (-inf, 3.082547155599167468e+02, "trv")){1})); ## minimal_sin_test %!test %! assert (isequal (sin (infsup), infsup)); %!test %! assert (isequal (sin (infsup (0.0, inf)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-0.0, inf)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-inf, 0.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-inf, -0.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (-inf, inf)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sin (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (sin (infsup (-0.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (sin (infsup (1.570796326794896558e+00, 1.570796326794896558e+00)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (sin (infsup (1.570796326794896780e+00, 1.570796326794896780e+00)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (sin (infsup (1.570796326794896558e+00, 1.570796326794896780e+00)), infsup (9.999999999999998890e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (sin (infsup (0.0, 1.570796326794896558e+00)), infsup (0.0, 1.000000000000000000e+00))); %!test %! assert (isequal (sin (infsup (-0.0, 1.570796326794896558e+00)), infsup (0.0, 1.000000000000000000e+00))); %!test %! assert (isequal (sin (infsup (0.0, 1.570796326794896780e+00)), infsup (0.0, 1.000000000000000000e+00))); %!test %! assert (isequal (sin (infsup (-0.0, 1.570796326794896780e+00)), infsup (0.0, 1.000000000000000000e+00))); %!test %! assert (isequal (sin (infsup (3.141592653589793116e+00, 3.141592653589793116e+00)), infsup (1.224646799147352961e-16, 1.224646799147353207e-16))); %!test %! assert (isequal (sin (infsup (3.141592653589793560e+00, 3.141592653589793560e+00)), infsup (-3.216245299353273201e-16, -3.216245299353272708e-16))); %!test %! assert (isequal (sin (infsup (3.141592653589793116e+00, 3.141592653589793560e+00)), infsup (-3.216245299353273201e-16, 1.224646799147353207e-16))); %!test %! assert (isequal (sin (infsup (0.0, 3.141592653589793116e+00)), infsup (0.0, 1.0))); %!test %! assert (isequal (sin (infsup (-0.0, 3.141592653589793116e+00)), infsup (0.0, 1.0))); %!test %! assert (isequal (sin (infsup (0.0, 3.141592653589793560e+00)), infsup (-3.216245299353273201e-16, 1.0))); %!test %! assert (isequal (sin (infsup (-0.0, 3.141592653589793560e+00)), infsup (-3.216245299353273201e-16, 1.0))); %!test %! assert (isequal (sin (infsup (1.570796326794896558e+00, 3.141592653589793116e+00)), infsup (1.224646799147352961e-16, 1.000000000000000000e+00))); %!test %! assert (isequal (sin (infsup (1.570796326794896558e+00, 3.141592653589793560e+00)), infsup (-3.216245299353273201e-16, 1.000000000000000000e+00))); %!test %! assert (isequal (sin (infsup (1.570796326794896780e+00, 3.141592653589793116e+00)), infsup (1.224646799147352961e-16, 1.000000000000000000e+00))); %!test %! assert (isequal (sin (infsup (1.570796326794896780e+00, 3.141592653589793560e+00)), infsup (-3.216245299353273201e-16, 1.000000000000000000e+00))); %!test %! assert (isequal (sin (infsup (-1.570796326794896558e+00, -1.570796326794896558e+00)), infsup (-1.000000000000000000e+00, -9.999999999999998890e-01))); %!test %! assert (isequal (sin (infsup (-1.570796326794896780e+00, -1.570796326794896780e+00)), infsup (-1.000000000000000000e+00, -9.999999999999998890e-01))); %!test %! assert (isequal (sin (infsup (-1.570796326794896780e+00, -1.570796326794896558e+00)), infsup (-1.000000000000000000e+00, -9.999999999999998890e-01))); %!test %! assert (isequal (sin (infsup (-1.570796326794896558e+00, 0.0)), infsup (-1.000000000000000000e+00, 0.0))); %!test %! assert (isequal (sin (infsup (-1.570796326794896558e+00, -0.0)), infsup (-1.000000000000000000e+00, 0.0))); %!test %! assert (isequal (sin (infsup (-1.570796326794896780e+00, 0.0)), infsup (-1.000000000000000000e+00, 0.0))); %!test %! assert (isequal (sin (infsup (-1.570796326794896780e+00, -0.0)), infsup (-1.000000000000000000e+00, 0.0))); %!test %! assert (isequal (sin (infsup (-3.141592653589793116e+00, -3.141592653589793116e+00)), infsup (-1.224646799147353207e-16, -1.224646799147352961e-16))); %!test %! assert (isequal (sin (infsup (-3.141592653589793560e+00, -3.141592653589793560e+00)), infsup (3.216245299353272708e-16, 3.216245299353273201e-16))); %!test %! assert (isequal (sin (infsup (-3.141592653589793560e+00, -3.141592653589793116e+00)), infsup (-1.224646799147353207e-16, 3.216245299353273201e-16))); %!test %! assert (isequal (sin (infsup (-3.141592653589793116e+00, 0.0)), infsup (-1.0, 0.0))); %!test %! assert (isequal (sin (infsup (-3.141592653589793116e+00, -0.0)), infsup (-1.0, 0.0))); %!test %! assert (isequal (sin (infsup (-3.141592653589793560e+00, 0.0)), infsup (-1.0, 3.216245299353273201e-16))); %!test %! assert (isequal (sin (infsup (-3.141592653589793560e+00, -0.0)), infsup (-1.0, 3.216245299353273201e-16))); %!test %! assert (isequal (sin (infsup (-3.141592653589793116e+00, -1.570796326794896558e+00)), infsup (-1.000000000000000000e+00, -1.224646799147352961e-16))); %!test %! assert (isequal (sin (infsup (-3.141592653589793560e+00, -1.570796326794896558e+00)), infsup (-1.000000000000000000e+00, 3.216245299353273201e-16))); %!test %! assert (isequal (sin (infsup (-3.141592653589793116e+00, -1.570796326794896780e+00)), infsup (-1.000000000000000000e+00, -1.224646799147352961e-16))); %!test %! assert (isequal (sin (infsup (-3.141592653589793560e+00, -1.570796326794896780e+00)), infsup (-1.000000000000000000e+00, 3.216245299353273201e-16))); %!test %! assert (isequal (sin (infsup (-1.570796326794896558e+00, 1.570796326794896558e+00)), infsup (-1.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (sin (infsup (-1.570796326794896558e+00, 1.570796326794896780e+00)), infsup (-1.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (sin (infsup (-1.570796326794896780e+00, 1.570796326794896558e+00)), infsup (-1.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (sin (infsup (-1.570796326794896780e+00, 1.570796326794896780e+00)), infsup (-1.000000000000000000e+00, 1.000000000000000000e+00))); %!test %! assert (isequal (sin (infsup (-0.7, 0.1)), infsup (-6.442176872376911279e-01, 9.983341664682816863e-02))); %!test %! assert (isequal (sin (infsup (1.0, 2.0)), infsup (8.414709848078965049e-01, 1.0))); %!test %! assert (isequal (sin (infsup (-3.2, -2.9)), infsup (-2.392493292139824257e-01, 5.837414342758009272e-02))); %!test %! assert (isequal (sin (infsup (2.0, 3.0)), infsup (1.411200080598672135e-01, 9.092974268256817094e-01))); ## minimal_sin_dec_test %!test %! assert (isequal (sin (infsupdec (-3.141592653589793116e+00, -1.570796326794896558e+00, "def")), infsupdec (-1.000000000000000000e+00, -1.224646799147352961e-16, "def"))); %! assert (isequal (decorationpart (sin (infsupdec (-3.141592653589793116e+00, -1.570796326794896558e+00, "def"))){1}, decorationpart (infsupdec (-1.000000000000000000e+00, -1.224646799147352961e-16, "def")){1})); %!test %! assert (isequal (sin (infsupdec (-inf, -0.0, "trv")), infsupdec (-1.0, 1.0, "trv"))); %! assert (isequal (decorationpart (sin (infsupdec (-inf, -0.0, "trv"))){1}, decorationpart (infsupdec (-1.0, 1.0, "trv")){1})); %!test %! assert (isequal (sin (infsupdec (entire, "def")), infsupdec (-1.0, 1.0, "def"))); %! assert (isequal (decorationpart (sin (infsupdec (entire, "def"))){1}, decorationpart (infsupdec (-1.0, 1.0, "def")){1})); ## minimal_cos_test %!test %! assert (isequal (cos (infsup), infsup)); %!test %! assert (isequal (cos (infsup (0.0, inf)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-0.0, inf)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-inf, 0.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-inf, -0.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-inf, inf)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-0.0, -0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (cos (infsup (1.570796326794896558e+00, 1.570796326794896558e+00)), infsup (6.123233995736764803e-17, 6.123233995736766036e-17))); %!test %! assert (isequal (cos (infsup (1.570796326794896780e+00, 1.570796326794896780e+00)), infsup (-1.608122649676636601e-16, -1.608122649676636354e-16))); %!test %! assert (isequal (cos (infsup (1.570796326794896558e+00, 1.570796326794896780e+00)), infsup (-1.608122649676636601e-16, 6.123233995736766036e-17))); %!test %! assert (isequal (cos (infsup (0.0, 1.570796326794896558e+00)), infsup (6.123233995736764803e-17, 1.0))); %!test %! assert (isequal (cos (infsup (-0.0, 1.570796326794896558e+00)), infsup (6.123233995736764803e-17, 1.0))); %!test %! assert (isequal (cos (infsup (0.0, 1.570796326794896780e+00)), infsup (-1.608122649676636601e-16, 1.0))); %!test %! assert (isequal (cos (infsup (-0.0, 1.570796326794896780e+00)), infsup (-1.608122649676636601e-16, 1.0))); %!test %! assert (isequal (cos (infsup (3.141592653589793116e+00, 3.141592653589793116e+00)), infsup (-1.000000000000000000e+00, -9.999999999999998890e-01))); %!test %! assert (isequal (cos (infsup (3.141592653589793560e+00, 3.141592653589793560e+00)), infsup (-1.000000000000000000e+00, -9.999999999999998890e-01))); %!test %! assert (isequal (cos (infsup (3.141592653589793116e+00, 3.141592653589793560e+00)), infsup (-1.000000000000000000e+00, -9.999999999999998890e-01))); %!test %! assert (isequal (cos (infsup (0.0, 3.141592653589793116e+00)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-0.0, 3.141592653589793116e+00)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (0.0, 3.141592653589793560e+00)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-0.0, 3.141592653589793560e+00)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (1.570796326794896558e+00, 3.141592653589793116e+00)), infsup (-1.0, 6.123233995736766036e-17))); %!test %! assert (isequal (cos (infsup (1.570796326794896558e+00, 3.141592653589793560e+00)), infsup (-1.0, 6.123233995736766036e-17))); %!test %! assert (isequal (cos (infsup (1.570796326794896780e+00, 3.141592653589793116e+00)), infsup (-1.0, -1.608122649676636354e-16))); %!test %! assert (isequal (cos (infsup (1.570796326794896780e+00, 3.141592653589793560e+00)), infsup (-1.0, -1.608122649676636354e-16))); %!test %! assert (isequal (cos (infsup (-1.570796326794896558e+00, -1.570796326794896558e+00)), infsup (6.123233995736764803e-17, 6.123233995736766036e-17))); %!test %! assert (isequal (cos (infsup (-1.570796326794896780e+00, -1.570796326794896780e+00)), infsup (-1.608122649676636601e-16, -1.608122649676636354e-16))); %!test %! assert (isequal (cos (infsup (-1.570796326794896780e+00, -1.570796326794896558e+00)), infsup (-1.608122649676636601e-16, 6.123233995736766036e-17))); %!test %! assert (isequal (cos (infsup (-1.570796326794896558e+00, 0.0)), infsup (6.123233995736764803e-17, 1.0))); %!test %! assert (isequal (cos (infsup (-1.570796326794896558e+00, -0.0)), infsup (6.123233995736764803e-17, 1.0))); %!test %! assert (isequal (cos (infsup (-1.570796326794896780e+00, 0.0)), infsup (-1.608122649676636601e-16, 1.0))); %!test %! assert (isequal (cos (infsup (-1.570796326794896780e+00, -0.0)), infsup (-1.608122649676636601e-16, 1.0))); %!test %! assert (isequal (cos (infsup (-3.141592653589793116e+00, -3.141592653589793116e+00)), infsup (-1.000000000000000000e+00, -9.999999999999998890e-01))); %!test %! assert (isequal (cos (infsup (-3.141592653589793560e+00, -3.141592653589793560e+00)), infsup (-1.000000000000000000e+00, -9.999999999999998890e-01))); %!test %! assert (isequal (cos (infsup (-3.141592653589793560e+00, -3.141592653589793116e+00)), infsup (-1.000000000000000000e+00, -9.999999999999998890e-01))); %!test %! assert (isequal (cos (infsup (-3.141592653589793116e+00, 0.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-3.141592653589793116e+00, -0.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-3.141592653589793560e+00, 0.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-3.141592653589793560e+00, -0.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (cos (infsup (-3.141592653589793116e+00, -1.570796326794896558e+00)), infsup (-1.0, 6.123233995736766036e-17))); %!test %! assert (isequal (cos (infsup (-3.141592653589793560e+00, -1.570796326794896558e+00)), infsup (-1.0, 6.123233995736766036e-17))); %!test %! assert (isequal (cos (infsup (-3.141592653589793116e+00, -1.570796326794896780e+00)), infsup (-1.0, -1.608122649676636354e-16))); %!test %! assert (isequal (cos (infsup (-3.141592653589793560e+00, -1.570796326794896780e+00)), infsup (-1.0, -1.608122649676636354e-16))); %!test %! assert (isequal (cos (infsup (-1.570796326794896558e+00, 1.570796326794896558e+00)), infsup (6.123233995736764803e-17, 1.0))); %!test %! assert (isequal (cos (infsup (-1.570796326794896558e+00, 1.570796326794896780e+00)), infsup (-1.608122649676636601e-16, 1.0))); %!test %! assert (isequal (cos (infsup (-1.570796326794896780e+00, 1.570796326794896558e+00)), infsup (-1.608122649676636601e-16, 1.0))); %!test %! assert (isequal (cos (infsup (-1.570796326794896780e+00, 1.570796326794896780e+00)), infsup (-1.608122649676636601e-16, 1.0))); %!test %! assert (isequal (cos (infsup (-0.7, 0.1)), infsup (7.648421872844883840e-01, 1.0))); %!test %! assert (isequal (cos (infsup (1.0, 2.0)), infsup (-4.161468365471424069e-01, 5.403023058681397650e-01))); %!test %! assert (isequal (cos (infsup (-3.2, -2.9)), infsup (-1.0, -9.709581651495904353e-01))); %!test %! assert (isequal (cos (infsup (2.0, 3.0)), infsup (-9.899924966004455262e-01, -4.161468365471423514e-01))); ## minimal_cos_dec_test %!test %! assert (isequal (cos (infsupdec (-1.570796326794896558e+00, -1.570796326794896558e+00, "trv")), infsupdec (6.123233995736764803e-17, 6.123233995736766036e-17, "trv"))); %! assert (isequal (decorationpart (cos (infsupdec (-1.570796326794896558e+00, -1.570796326794896558e+00, "trv"))){1}, decorationpart (infsupdec (6.123233995736764803e-17, 6.123233995736766036e-17, "trv")){1})); %!test %! assert (isequal (cos (infsupdec (-inf, -0.0, "def")), infsupdec (-1.0, 1.0, "def"))); %! assert (isequal (decorationpart (cos (infsupdec (-inf, -0.0, "def"))){1}, decorationpart (infsupdec (-1.0, 1.0, "def")){1})); %!test %! assert (isequal (cos (infsupdec (entire, "def")), infsupdec (-1.0, 1.0, "def"))); %! assert (isequal (decorationpart (cos (infsupdec (entire, "def"))){1}, decorationpart (infsupdec (-1.0, 1.0, "def")){1})); ## minimal_tan_test %!test %! assert (isequal (tan (infsup), infsup)); %!test %! assert (isequal (tan (infsup (0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-0.0, inf)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-inf, 0.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-inf, -0.0)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (tan (infsup (-0.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (tan (infsup (1.570796326794896558e+00, 1.570796326794896558e+00)), infsup (1.633123935319536800e+16, 1.633123935319537000e+16))); %!test %! assert (isequal (tan (infsup (1.570796326794896780e+00, 1.570796326794896780e+00)), infsup (-6.218431163823739000e+15, -6.218431163823738000e+15))); %!test %! assert (isequal (tan (infsup (1.570796326794896558e+00, 1.570796326794896780e+00)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (3.141592653589793116e+00, 3.141592653589793116e+00)), infsup (-1.224646799147353207e-16, -1.224646799147352961e-16))); %!test %! assert (isequal (tan (infsup (3.141592653589793560e+00, 3.141592653589793560e+00)), infsup (3.216245299353272708e-16, 3.216245299353273201e-16))); %!test %! assert (isequal (tan (infsup (0.0, 1.570796326794896558e+00)), infsup (0.0, 1.633123935319537000e+16))); %!test %! assert (isequal (tan (infsup (-0.0, 1.570796326794896558e+00)), infsup (0.0, 1.633123935319537000e+16))); %!test %! assert (isequal (tan (infsup (0.0, 1.570796326794896780e+00)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-0.0, 1.570796326794896780e+00)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (0.0, 3.141592653589793116e+00)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-0.0, 3.141592653589793116e+00)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (0.0, 3.141592653589793560e+00)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-0.0, 3.141592653589793560e+00)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (4.440892098500626162e-16, 3.141592653589793116e+00)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (4.440892098500626162e-16, 3.141592653589793560e+00)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (2.220446049250313081e-16, 3.141592653589793116e+00)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (2.220446049250313081e-16, 3.141592653589793560e+00)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-1.570796326794896558e+00, 1.570796326794896558e+00)), infsup (-1.633123935319537000e+16, 1.633123935319537000e+16))); %!test %! assert (isequal (tan (infsup (-1.570796326794896558e+00, 1.570796326794896780e+00)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-1.570796326794896780e+00, 1.570796326794896558e+00)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-1.570796326794896780e+00, 1.570796326794896780e+00)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (-3.333300000000000152e-01, 1.000000000000000056e-01)), infsup (-3.462498165431488473e-01, 1.003346720854505630e-01))); %!test %! assert (isequal (tan (infsup (5.345555000000000291e+03, 5.346010000000000218e+03)), infsup (-7.356840852049277402e+00, -1.493205097982578833e+00))); %!test %! assert (isequal (tan (infsup (5.345555000000000291e+03, 5.446010000000000218e+03)), infsup (-inf, inf))); %!test %! assert (isequal (tan (infsup (9.899999999999999911e-01, 1.010000000000000009e+00)), infsup (1.523676741017902181e+00, 1.592206024219570581e+00))); ## minimal_tan_dec_test %!test %! assert (isequal (tan (infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (tan (infsupdec (0.0, inf, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tan (infsupdec (-0.0, inf, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (-0.0, inf, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tan (infsupdec (-inf, 0.0, "trv")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (-inf, 0.0, "trv"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tan (infsupdec (-inf, -0.0, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (-inf, -0.0, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tan (infsupdec (entire, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (entire, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tan (infsupdec (0.0, 0.0, "com")), infsupdec (0.0, 0.0, "com"))); %! assert (isequal (decorationpart (tan (infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "com")){1})); %!test %! assert (isequal (tan (infsupdec (-0.0, -0.0, "def")), infsupdec (0.0, 0.0, "def"))); %! assert (isequal (decorationpart (tan (infsupdec (-0.0, -0.0, "def"))){1}, decorationpart (infsupdec (0.0, 0.0, "def")){1})); %!test %! assert (isequal (tan (infsupdec (1.570796326794896558e+00, 1.570796326794896558e+00, "com")), infsupdec (1.633123935319536800e+16, 1.633123935319537000e+16, "com"))); %! assert (isequal (decorationpart (tan (infsupdec (1.570796326794896558e+00, 1.570796326794896558e+00, "com"))){1}, decorationpart (infsupdec (1.633123935319536800e+16, 1.633123935319537000e+16, "com")){1})); %!test %! assert (isequal (tan (infsupdec (1.570796326794896780e+00, 1.570796326794896780e+00, "def")), infsupdec (-6.218431163823739000e+15, -6.218431163823738000e+15, "def"))); %! assert (isequal (decorationpart (tan (infsupdec (1.570796326794896780e+00, 1.570796326794896780e+00, "def"))){1}, decorationpart (infsupdec (-6.218431163823739000e+15, -6.218431163823738000e+15, "def")){1})); %!test %! assert (isequal (tan (infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tan (infsupdec (3.141592653589793116e+00, 3.141592653589793116e+00, "trv")), infsupdec (-1.224646799147353207e-16, -1.224646799147352961e-16, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (3.141592653589793116e+00, 3.141592653589793116e+00, "trv"))){1}, decorationpart (infsupdec (-1.224646799147353207e-16, -1.224646799147352961e-16, "trv")){1})); %!test %! assert (isequal (tan (infsupdec (3.141592653589793560e+00, 3.141592653589793560e+00, "com")), infsupdec (3.216245299353272708e-16, 3.216245299353273201e-16, "com"))); %! assert (isequal (decorationpart (tan (infsupdec (3.141592653589793560e+00, 3.141592653589793560e+00, "com"))){1}, decorationpart (infsupdec (3.216245299353272708e-16, 3.216245299353273201e-16, "com")){1})); %!test %! assert (isequal (tan (infsupdec (0.0, 1.570796326794896558e+00, "dac")), infsupdec (0.0, 1.633123935319537000e+16, "dac"))); %! assert (isequal (decorationpart (tan (infsupdec (0.0, 1.570796326794896558e+00, "dac"))){1}, decorationpart (infsupdec (0.0, 1.633123935319537000e+16, "dac")){1})); %!test %! assert (isequal (tan (infsupdec (-0.0, 1.570796326794896558e+00, "com")), infsupdec (0.0, 1.633123935319537000e+16, "com"))); %! assert (isequal (decorationpart (tan (infsupdec (-0.0, 1.570796326794896558e+00, "com"))){1}, decorationpart (infsupdec (0.0, 1.633123935319537000e+16, "com")){1})); %!test %! assert (isequal (tan (infsupdec (0.0, 1.570796326794896780e+00, "trv")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (0.0, 1.570796326794896780e+00, "trv"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tan (infsupdec (-0.0, 1.570796326794896780e+00, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (-0.0, 1.570796326794896780e+00, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tan (infsupdec (0.0, 3.141592653589793116e+00, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (0.0, 3.141592653589793116e+00, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tan (infsupdec (-0.0, 3.141592653589793116e+00, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (-0.0, 3.141592653589793116e+00, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tan (infsupdec (0.0, 3.141592653589793560e+00, "trv")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (0.0, 3.141592653589793560e+00, "trv"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tan (infsupdec (-0.0, 3.141592653589793560e+00, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (-0.0, 3.141592653589793560e+00, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tan (infsupdec (4.440892098500626162e-16, 3.141592653589793116e+00, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (4.440892098500626162e-16, 3.141592653589793116e+00, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tan (infsupdec (4.440892098500626162e-16, 3.141592653589793560e+00, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (4.440892098500626162e-16, 3.141592653589793560e+00, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tan (infsupdec (2.220446049250313081e-16, 3.141592653589793116e+00, "trv")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (2.220446049250313081e-16, 3.141592653589793116e+00, "trv"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tan (infsupdec (2.220446049250313081e-16, 3.141592653589793560e+00, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (2.220446049250313081e-16, 3.141592653589793560e+00, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tan (infsupdec (-1.570796326794896558e+00, 1.570796326794896558e+00, "com")), infsupdec (-1.633123935319537000e+16, 1.633123935319537000e+16, "com"))); %! assert (isequal (decorationpart (tan (infsupdec (-1.570796326794896558e+00, 1.570796326794896558e+00, "com"))){1}, decorationpart (infsupdec (-1.633123935319537000e+16, 1.633123935319537000e+16, "com")){1})); %!test %! assert (isequal (tan (infsupdec (-1.570796326794896558e+00, 1.570796326794896780e+00, "trv")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (-1.570796326794896558e+00, 1.570796326794896780e+00, "trv"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tan (infsupdec (-1.570796326794896780e+00, 1.570796326794896558e+00, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (-1.570796326794896780e+00, 1.570796326794896558e+00, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tan (infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "dac")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "dac"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tan (infsupdec (-3.333300000000000152e-01, 1.000000000000000056e-01, "com")), infsupdec (-3.462498165431488473e-01, 1.003346720854505630e-01, "com"))); %! assert (isequal (decorationpart (tan (infsupdec (-3.333300000000000152e-01, 1.000000000000000056e-01, "com"))){1}, decorationpart (infsupdec (-3.462498165431488473e-01, 1.003346720854505630e-01, "com")){1})); %!test %! assert (isequal (tan (infsupdec (5.345555000000000291e+03, 5.346010000000000218e+03, "dac")), infsupdec (-7.356840852049277402e+00, -1.493205097982578833e+00, "dac"))); %! assert (isequal (decorationpart (tan (infsupdec (5.345555000000000291e+03, 5.346010000000000218e+03, "dac"))){1}, decorationpart (infsupdec (-7.356840852049277402e+00, -1.493205097982578833e+00, "dac")){1})); %!test %! assert (isequal (tan (infsupdec (5.345555000000000291e+03, 5.446010000000000218e+03, "def")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (5.345555000000000291e+03, 5.446010000000000218e+03, "def"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (tan (infsupdec (9.899999999999999911e-01, 1.010000000000000009e+00, "trv")), infsupdec (1.523676741017902181e+00, 1.592206024219570581e+00, "trv"))); %! assert (isequal (decorationpart (tan (infsupdec (9.899999999999999911e-01, 1.010000000000000009e+00, "trv"))){1}, decorationpart (infsupdec (1.523676741017902181e+00, 1.592206024219570581e+00, "trv")){1})); ## minimal_asin_test %!test %! assert (isequal (asin (infsup), infsup)); %!test %! assert (isequal (asin (infsup (0.0, inf)), infsup (0.0, 1.570796326794896780e+00))); %!test %! assert (isequal (asin (infsup (-0.0, inf)), infsup (0.0, 1.570796326794896780e+00))); %!test %! assert (isequal (asin (infsup (-inf, 0.0)), infsup (-1.570796326794896780e+00, 0.0))); %!test %! assert (isequal (asin (infsup (-inf, -0.0)), infsup (-1.570796326794896780e+00, 0.0))); %!test %! assert (isequal (asin (infsup (-inf, inf)), infsup (-1.570796326794896780e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (asin (infsup (-1.0, 1.0)), infsup (-1.570796326794896780e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (asin (infsup (-inf, -1.0)), infsup (-1.570796326794896780e+00, -1.570796326794896558e+00))); %!test %! assert (isequal (asin (infsup (1.0, inf)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (asin (infsup (-1.0, -1.0)), infsup (-1.570796326794896780e+00, -1.570796326794896558e+00))); %!test %! assert (isequal (asin (infsup (1.0, 1.0)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (asin (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (asin (infsup (-0.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (asin (infsup (-inf, -1.000000000000000222e+00)), infsup)); %!test %! assert (isequal (asin (infsup (1.000000000000000222e+00, inf)), infsup)); %!test %! assert (isequal (asin (infsup (-1.000000000000000056e-01, 1.000000000000000056e-01)), infsup (-1.001674211615598137e-01, 1.001674211615598137e-01))); %!test %! assert (isequal (asin (infsup (-3.300000000000000155e-01, 9.999999999999998890e-01)), infsup (-3.363035751539804052e-01, 1.570796311893735586e+00))); %!test %! assert (isequal (asin (infsup (-9.999999999999998890e-01, 9.999999999999998890e-01)), infsup (-1.570796311893735586e+00, 1.570796311893735586e+00))); ## minimal_asin_dec_test %!test %! assert (isequal (asin (infsupdec (0.0, inf, "dac")), infsupdec (0.0, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (asin (infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (0.0, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (asin (infsupdec (-inf, 0.0, "def")), infsupdec (-1.570796326794896780e+00, 0.0, "trv"))); %! assert (isequal (decorationpart (asin (infsupdec (-inf, 0.0, "def"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 0.0, "trv")){1})); %!test %! assert (isequal (asin (infsupdec (-1.0, 1.0, "com")), infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "com"))); %! assert (isequal (decorationpart (asin (infsupdec (-1.0, 1.0, "com"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "com")){1})); %!test %! assert (isequal (asin (infsupdec (entire, "def")), infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (asin (infsupdec (entire, "def"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (asin (infsupdec (-3.300000000000000155e-01, 9.999999999999998890e-01, "def")), infsupdec (-3.363035751539804052e-01, 1.570796311893735586e+00, "def"))); %! assert (isequal (decorationpart (asin (infsupdec (-3.300000000000000155e-01, 9.999999999999998890e-01, "def"))){1}, decorationpart (infsupdec (-3.363035751539804052e-01, 1.570796311893735586e+00, "def")){1})); ## minimal_acos_test %!test %! assert (isequal (acos (infsup), infsup)); %!test %! assert (isequal (acos (infsup (0.0, inf)), infsup (0.0, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-0.0, inf)), infsup (0.0, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-inf, 0.0)), infsup (1.570796326794896558e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (acos (infsup (-inf, -0.0)), infsup (1.570796326794896558e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (acos (infsup (-inf, inf)), infsup (0.0, 3.141592653589793560e+00))); %!test %! assert (isequal (acos (infsup (-1.0, 1.0)), infsup (0.0, 3.141592653589793560e+00))); %!test %! assert (isequal (acos (infsup (-inf, -1.0)), infsup (3.141592653589793116e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (acos (infsup (1.0, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (acos (infsup (-1.0, -1.0)), infsup (3.141592653589793116e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (acos (infsup (1.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (acos (infsup (0.0, 0.0)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-0.0, -0.0)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (acos (infsup (-inf, -1.000000000000000222e+00)), infsup)); %!test %! assert (isequal (acos (infsup (1.000000000000000222e+00, inf)), infsup)); %!test %! assert (isequal (acos (infsup (-1.000000000000000056e-01, 1.000000000000000056e-01)), infsup (1.470628905633336814e+00, 1.670963747956456524e+00))); %!test %! assert (isequal (acos (infsup (-3.300000000000000155e-01, 9.999999999999998890e-01)), infsup (1.490116119384765625e-08, 1.907099901948877019e+00))); %!test %! assert (isequal (acos (infsup (-9.999999999999998890e-01, 9.999999999999998890e-01)), infsup (1.490116119384765625e-08, 3.141592638688632366e+00))); ## minimal_acos_dec_test %!test %! assert (isequal (acos (infsupdec (0.0, inf, "dac")), infsupdec (0.0, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (acos (infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (0.0, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (acos (infsupdec (-inf, 0.0, "def")), infsupdec (1.570796326794896558e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (acos (infsupdec (-inf, 0.0, "def"))){1}, decorationpart (infsupdec (1.570796326794896558e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (acos (infsupdec (-1.0, 1.0, "com")), infsupdec (0.0, 3.141592653589793560e+00, "com"))); %! assert (isequal (decorationpart (acos (infsupdec (-1.0, 1.0, "com"))){1}, decorationpart (infsupdec (0.0, 3.141592653589793560e+00, "com")){1})); %!test %! assert (isequal (acos (infsupdec (entire, "def")), infsupdec (0.0, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (acos (infsupdec (entire, "def"))){1}, decorationpart (infsupdec (0.0, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (acos (infsupdec (-3.300000000000000155e-01, 9.999999999999998890e-01, "def")), infsupdec (1.490116119384765625e-08, 1.907099901948877019e+00, "def"))); %! assert (isequal (decorationpart (acos (infsupdec (-3.300000000000000155e-01, 9.999999999999998890e-01, "def"))){1}, decorationpart (infsupdec (1.490116119384765625e-08, 1.907099901948877019e+00, "def")){1})); ## minimal_atan_test %!test %! assert (isequal (atan (infsup), infsup)); %!test %! assert (isequal (atan (infsup (0.0, inf)), infsup (0.0, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (-0.0, inf)), infsup (0.0, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (-inf, 0.0)), infsup (-1.570796326794896780e+00, 0.0))); %!test %! assert (isequal (atan (infsup (-inf, -0.0)), infsup (-1.570796326794896780e+00, 0.0))); %!test %! assert (isequal (atan (infsup (-inf, inf)), infsup (-1.570796326794896780e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (atan (infsup (-0.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (atan (infsup (1.0, 4.353453467566999793e+07)), infsup (7.853981633974482790e-01, 1.570796303824627094e+00))); %!test %! assert (isequal (atan (infsup (-5.466754345546680298e+11, -5.658889722000000120e+02)), infsup (-1.570796326793067577e+00, -1.569029197537726406e+00))); ## minimal_atan_dec_test %!test %! assert (isequal (atan (infsupdec (0.0, inf, "dac")), infsupdec (0.0, 1.570796326794896780e+00, "dac"))); %! assert (isequal (decorationpart (atan (infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (0.0, 1.570796326794896780e+00, "dac")){1})); %!test %! assert (isequal (atan (infsupdec (-inf, 0.0, "def")), infsupdec (-1.570796326794896780e+00, 0.0, "def"))); %! assert (isequal (decorationpart (atan (infsupdec (-inf, 0.0, "def"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 0.0, "def")){1})); %!test %! assert (isequal (atan (infsupdec (entire, "def")), infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "def"))); %! assert (isequal (decorationpart (atan (infsupdec (entire, "def"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "def")){1})); %!test %! assert (isequal (atan (infsupdec (1.0, 4.353453467566999793e+07, "trv")), infsupdec (7.853981633974482790e-01, 1.570796303824627094e+00, "trv"))); %! assert (isequal (decorationpart (atan (infsupdec (1.0, 4.353453467566999793e+07, "trv"))){1}, decorationpart (infsupdec (7.853981633974482790e-01, 1.570796303824627094e+00, "trv")){1})); %!test %! assert (isequal (atan (infsupdec (-5.466754345546680298e+11, -5.658889722000000120e+02, "com")), infsupdec (-1.570796326793067577e+00, -1.569029197537726406e+00, "com"))); %! assert (isequal (decorationpart (atan (infsupdec (-5.466754345546680298e+11, -5.658889722000000120e+02, "com"))){1}, decorationpart (infsupdec (-1.570796326793067577e+00, -1.569029197537726406e+00, "com")){1})); ## minimal_atan2_test %!test %! assert (isequal (atan2 (infsup, infsup), infsup)); %!test %! assert (isequal (atan2 (infsup, infsup (-inf, inf)), infsup)); %!test %! assert (isequal (atan2 (infsup, infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup, infsup (-0.0, 0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup, infsup (0.0, -0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup, infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup, infsup (-2.0, -0.1)), infsup)); %!test %! assert (isequal (atan2 (infsup, infsup (-2.0, 0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup, infsup (-2.0, -0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup, infsup (-2.0, 1.0)), infsup)); %!test %! assert (isequal (atan2 (infsup, infsup (0.0, 1.0)), infsup)); %!test %! assert (isequal (atan2 (infsup, infsup (-0.0, 1.0)), infsup)); %!test %! assert (isequal (atan2 (infsup, infsup (0.1, 1.0)), infsup)); %!test %! assert (isequal (atan2 (infsup (-inf, inf), infsup), infsup)); %!test %! assert (isequal (atan2 (infsup (-inf, inf), infsup (-inf, inf)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-inf, inf), infsup (0.0, 0.0)), infsup (-1.570796326794896780e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (-inf, inf), infsup (0.0, -0.0)), infsup (-1.570796326794896780e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (-inf, inf), infsup (-0.0, 0.0)), infsup (-1.570796326794896780e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (-inf, inf), infsup (-0.0, -0.0)), infsup (-1.570796326794896780e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (-inf, inf), infsup (-2.0, -0.1)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-inf, inf), infsup (-2.0, 0.0)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-inf, inf), infsup (-2.0, -0.0)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-inf, inf), infsup (-2.0, 1.0)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-inf, inf), infsup (0.0, 1.0)), infsup (-1.570796326794896780e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (-inf, inf), infsup (-0.0, 1.0)), infsup (-1.570796326794896780e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (-inf, inf), infsup (0.1, 1.0)), infsup (-1.570796326794896780e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 0.0), infsup), infsup)); %!test %! assert (isequal (atan2 (infsup (0.0, 0.0), infsup (-inf, inf)), infsup (0.0, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 0.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup (0.0, 0.0), infsup (-0.0, 0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup (0.0, 0.0), infsup (0.0, -0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup (0.0, 0.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup (0.0, 0.0), infsup (-2.0, -0.1)), infsup (3.141592653589793116e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 0.0), infsup (-2.0, 0.0)), infsup (3.141592653589793116e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 0.0), infsup (-2.0, -0.0)), infsup (3.141592653589793116e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 0.0), infsup (-2.0, 1.0)), infsup (0.0, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 0.0), infsup (0.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (atan2 (infsup (0.0, 0.0), infsup (-0.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (atan2 (infsup (0.0, 0.0), infsup (0.1, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (atan2 (infsup (-0.0, 0.0), infsup), infsup)); %!test %! assert (isequal (atan2 (infsup (-0.0, 0.0), infsup (-inf, inf)), infsup (0.0, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-0.0, 0.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup (-0.0, 0.0), infsup (-0.0, 0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup (-0.0, 0.0), infsup (0.0, -0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup (-0.0, 0.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup (-0.0, 0.0), infsup (-2.0, -0.1)), infsup (3.141592653589793116e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-0.0, 0.0), infsup (-2.0, 0.0)), infsup (3.141592653589793116e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-0.0, 0.0), infsup (-2.0, -0.0)), infsup (3.141592653589793116e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-0.0, 0.0), infsup (-2.0, 1.0)), infsup (0.0, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-0.0, 0.0), infsup (0.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (atan2 (infsup (-0.0, 0.0), infsup (-0.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (atan2 (infsup (-0.0, 0.0), infsup (0.1, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (atan2 (infsup (0.0, -0.0), infsup), infsup)); %!test %! assert (isequal (atan2 (infsup (0.0, -0.0), infsup (-inf, inf)), infsup (0.0, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, -0.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup (0.0, -0.0), infsup (-0.0, 0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup (0.0, -0.0), infsup (0.0, -0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup (0.0, -0.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup (0.0, -0.0), infsup (-2.0, -0.1)), infsup (3.141592653589793116e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, -0.0), infsup (-2.0, 0.0)), infsup (3.141592653589793116e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, -0.0), infsup (-2.0, -0.0)), infsup (3.141592653589793116e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, -0.0), infsup (-2.0, 1.0)), infsup (0.0, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, -0.0), infsup (0.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (atan2 (infsup (0.0, -0.0), infsup (-0.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (atan2 (infsup (0.0, -0.0), infsup (0.1, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (atan2 (infsup (-0.0, -0.0), infsup), infsup)); %!test %! assert (isequal (atan2 (infsup (-0.0, -0.0), infsup (-inf, inf)), infsup (0.0, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-0.0, -0.0), infsup (0.0, 0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup (-0.0, -0.0), infsup (-0.0, 0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup (-0.0, -0.0), infsup (0.0, -0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup (-0.0, -0.0), infsup (-0.0, -0.0)), infsup)); %!test %! assert (isequal (atan2 (infsup (-0.0, -0.0), infsup (-2.0, -0.1)), infsup (3.141592653589793116e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-0.0, -0.0), infsup (-2.0, 0.0)), infsup (3.141592653589793116e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-0.0, -0.0), infsup (-2.0, -0.0)), infsup (3.141592653589793116e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-0.0, -0.0), infsup (-2.0, 1.0)), infsup (0.0, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-0.0, -0.0), infsup (0.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (atan2 (infsup (-0.0, -0.0), infsup (-0.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (atan2 (infsup (-0.0, -0.0), infsup (0.1, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.1), infsup), infsup)); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.1), infsup (-inf, inf)), infsup (-3.141592653589793560e+00, 0.0))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.1), infsup (0.0, 0.0)), infsup (-1.570796326794896780e+00, -1.570796326794896558e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.1), infsup (0.0, -0.0)), infsup (-1.570796326794896780e+00, -1.570796326794896558e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.1), infsup (-0.0, 0.0)), infsup (-1.570796326794896780e+00, -1.570796326794896558e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.1), infsup (0.0, -0.0)), infsup (-1.570796326794896780e+00, -1.570796326794896558e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.1), infsup (-2.0, -0.1)), infsup (-3.091634257867850621e+00, -1.620754722516839275e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.1), infsup (-2.0, 0.0)), infsup (-3.091634257867850621e+00, -1.570796326794896558e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.1), infsup (-2.0, -0.0)), infsup (-3.091634257867850621e+00, -1.570796326794896558e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.1), infsup (-2.0, 1.0)), infsup (-3.091634257867850621e+00, -9.966865249116202419e-02))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.1), infsup (0.0, 1.0)), infsup (-1.570796326794896780e+00, -9.966865249116202419e-02))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.1), infsup (-0.0, 1.0)), infsup (-1.570796326794896780e+00, -9.966865249116202419e-02))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.1), infsup (0.1, 1.0)), infsup (-1.520837931072954063e+00, -9.966865249116202419e-02))); %!test %! assert (isequal (atan2 (infsup (-2.0, 0.0), infsup), infsup)); %!test %! assert (isequal (atan2 (infsup (-2.0, 0.0), infsup (-inf, inf)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 0.0), infsup (0.0, 0.0)), infsup (-1.570796326794896780e+00, -1.570796326794896558e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 0.0), infsup (-0.0, 0.0)), infsup (-1.570796326794896780e+00, -1.570796326794896558e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 0.0), infsup (0.0, -0.0)), infsup (-1.570796326794896780e+00, -1.570796326794896558e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 0.0), infsup (-0.0, -0.0)), infsup (-1.570796326794896780e+00, -1.570796326794896558e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 0.0), infsup (-2.0, -0.1)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 0.0), infsup (-2.0, 0.0)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 0.0), infsup (-2.0, -0.0)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 0.0), infsup (-2.0, 1.0)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 0.0), infsup (0.0, 1.0)), infsup (-1.570796326794896780e+00, 0.0))); %!test %! assert (isequal (atan2 (infsup (-2.0, 0.0), infsup (-0.0, 1.0)), infsup (-1.570796326794896780e+00, 0.0))); %!test %! assert (isequal (atan2 (infsup (-2.0, 0.0), infsup (0.1, 1.0)), infsup (-1.520837931072954063e+00, 0.0))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.0), infsup), infsup)); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.0), infsup (-inf, inf)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.0), infsup (0.0, 0.0)), infsup (-1.570796326794896780e+00, -1.570796326794896558e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.0), infsup (-0.0, 0.0)), infsup (-1.570796326794896780e+00, -1.570796326794896558e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.0), infsup (0.0, -0.0)), infsup (-1.570796326794896780e+00, -1.570796326794896558e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.0), infsup (-0.0, -0.0)), infsup (-1.570796326794896780e+00, -1.570796326794896558e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.0), infsup (-2.0, -0.1)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.0), infsup (-2.0, 0.0)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.0), infsup (-2.0, -0.0)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.0), infsup (-2.0, 1.0)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.0), infsup (0.0, 1.0)), infsup (-1.570796326794896780e+00, 0.0))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.0), infsup (-0.0, 1.0)), infsup (-1.570796326794896780e+00, 0.0))); %!test %! assert (isequal (atan2 (infsup (-2.0, -0.0), infsup (0.1, 1.0)), infsup (-1.520837931072954063e+00, 0.0))); %!test %! assert (isequal (atan2 (infsup (-2.0, 1.0), infsup), infsup)); %!test %! assert (isequal (atan2 (infsup (-2.0, 1.0), infsup (-inf, inf)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 1.0), infsup (0.0, 0.0)), infsup (-1.570796326794896780e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 1.0), infsup (-0.0, 0.0)), infsup (-1.570796326794896780e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 1.0), infsup (0.0, -0.0)), infsup (-1.570796326794896780e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 1.0), infsup (-0.0, -0.0)), infsup (-1.570796326794896780e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 1.0), infsup (-2.0, -0.1)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 1.0), infsup (-2.0, 0.0)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 1.0), infsup (-2.0, -0.0)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 1.0), infsup (-2.0, 1.0)), infsup (-3.141592653589793560e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 1.0), infsup (0.0, 1.0)), infsup (-1.570796326794896780e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 1.0), infsup (-0.0, 1.0)), infsup (-1.570796326794896780e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (-2.0, 1.0), infsup (0.1, 1.0)), infsup (-1.520837931072954063e+00, 1.471127674303734700e+00))); %!test %! assert (isequal (atan2 (infsup (-0.0, 1.0), infsup), infsup)); %!test %! assert (isequal (atan2 (infsup (-0.0, 1.0), infsup (-inf, inf)), infsup (0.0, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-0.0, 1.0), infsup (0.0, 0.0)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (-0.0, 1.0), infsup (-0.0, 0.0)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (-0.0, 1.0), infsup (0.0, -0.0)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (-0.0, 1.0), infsup (-0.0, -0.0)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (-0.0, 1.0), infsup (-2.0, -0.1)), infsup (1.670464979286058638e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-0.0, 1.0), infsup (-2.0, 0.0)), infsup (1.570796326794896558e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-0.0, 1.0), infsup (-2.0, -0.0)), infsup (1.570796326794896558e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-0.0, 1.0), infsup (-2.0, 1.0)), infsup (0.0, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (-0.0, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (-0.0, 1.0), infsup (-0.0, 1.0)), infsup (0.0, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (-0.0, 1.0), infsup (0.1, 1.0)), infsup (0.0, 1.471127674303734700e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 1.0), infsup), infsup)); %!test %! assert (isequal (atan2 (infsup (0.0, 1.0), infsup (-inf, inf)), infsup (0.0, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 1.0), infsup (0.0, 0.0)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 1.0), infsup (-0.0, 0.0)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 1.0), infsup (0.0, -0.0)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 1.0), infsup (-0.0, -0.0)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 1.0), infsup (-2.0, -0.1)), infsup (1.670464979286058638e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 1.0), infsup (-2.0, 0.0)), infsup (1.570796326794896558e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 1.0), infsup (-2.0, -0.0)), infsup (1.570796326794896558e+00, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 1.0), infsup (-2.0, 1.0)), infsup (0.0, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 1.0), infsup (0.0, 1.0)), infsup (0.0, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 1.0), infsup (-0.0, 1.0)), infsup (0.0, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (0.0, 1.0), infsup (0.1, 1.0)), infsup (0.0, 1.471127674303734700e+00))); %!test %! assert (isequal (atan2 (infsup (0.1, 1.0), infsup), infsup)); %!test %! assert (isequal (atan2 (infsup (0.1, 1.0), infsup (-inf, inf)), infsup (0.0, 3.141592653589793560e+00))); %!test %! assert (isequal (atan2 (infsup (0.1, 1.0), infsup (0.0, 0.0)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (0.1, 1.0), infsup (-0.0, 0.0)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (0.1, 1.0), infsup (0.0, -0.0)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (0.1, 1.0), infsup (-0.0, -0.0)), infsup (1.570796326794896558e+00, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (0.1, 1.0), infsup (-2.0, -0.1)), infsup (1.670464979286058638e+00, 3.091634257867850621e+00))); %!test %! assert (isequal (atan2 (infsup (0.1, 1.0), infsup (-2.0, 0.0)), infsup (1.570796326794896558e+00, 3.091634257867850621e+00))); %!test %! assert (isequal (atan2 (infsup (0.1, 1.0), infsup (-2.0, -0.0)), infsup (1.570796326794896558e+00, 3.091634257867850621e+00))); %!test %! assert (isequal (atan2 (infsup (0.1, 1.0), infsup (-2.0, 1.0)), infsup (9.966865249116202419e-02, 3.091634257867850621e+00))); %!test %! assert (isequal (atan2 (infsup (0.1, 1.0), infsup (0.0, 1.0)), infsup (9.966865249116202419e-02, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (0.1, 1.0), infsup (-0.0, 1.0)), infsup (9.966865249116202419e-02, 1.570796326794896780e+00))); %!test %! assert (isequal (atan2 (infsup (0.1, 1.0), infsup (0.1, 1.0)), infsup (9.966865249116202419e-02, 1.471127674303734700e+00))); ## minimal_atan2_dec_test %!test %! assert (isequal (atan2 (infsupdec (empty, "trv"), infsupdec (entire, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (empty, "trv"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (empty, "trv"), infsupdec (0.0, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (empty, "trv"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (empty, "trv"), infsupdec (-0.0, 0.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (empty, "trv"), infsupdec (-0.0, 0.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (empty, "trv"), infsupdec (0.0, -0.0, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (empty, "trv"), infsupdec (0.0, -0.0, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (empty, "trv"), infsupdec (-0.0, -0.0, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (empty, "trv"), infsupdec (-0.0, -0.0, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (empty, "trv"), infsupdec (-2.0, -0.1, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (empty, "trv"), infsupdec (-2.0, -0.1, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (empty, "trv"), infsupdec (-2.0, 0.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (empty, "trv"), infsupdec (-2.0, 0.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (empty, "trv"), infsupdec (-2.0, -0.0, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (empty, "trv"), infsupdec (-2.0, -0.0, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (empty, "trv"), infsupdec (-2.0, 1.0, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (empty, "trv"), infsupdec (-2.0, 1.0, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (empty, "trv"), infsupdec (0.0, 1.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (empty, "trv"), infsupdec (0.0, 1.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (empty, "trv"), infsupdec (-0.0, 1.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (empty, "trv"), infsupdec (-0.0, 1.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (empty, "trv"), infsupdec (0.1, 1.0, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (empty, "trv"), infsupdec (0.1, 1.0, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (entire, "def"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (entire, "def"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (entire, "def"), infsupdec (entire, "def")), infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (entire, "def"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (entire, "def"), infsupdec (0.0, 0.0, "com")), infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (entire, "def"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (entire, "def"), infsupdec (0.0, -0.0, "def")), infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (entire, "def"), infsupdec (0.0, -0.0, "def"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (entire, "def"), infsupdec (-0.0, 0.0, "dac")), infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (entire, "def"), infsupdec (-0.0, 0.0, "dac"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (entire, "def"), infsupdec (-0.0, -0.0, "trv")), infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (entire, "def"), infsupdec (-0.0, -0.0, "trv"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (entire, "def"), infsupdec (-2.0, -0.1, "com")), infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "def"))); %! assert (isequal (decorationpart (atan2 (infsupdec (entire, "def"), infsupdec (-2.0, -0.1, "com"))){1}, decorationpart (infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "def")){1})); %!test %! assert (isequal (atan2 (infsupdec (entire, "def"), infsupdec (-2.0, 0.0, "dac")), infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (entire, "def"), infsupdec (-2.0, 0.0, "dac"))){1}, decorationpart (infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (entire, "def"), infsupdec (-2.0, -0.0, "def")), infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (entire, "def"), infsupdec (-2.0, -0.0, "def"))){1}, decorationpart (infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (entire, "def"), infsupdec (-2.0, 1.0, "trv")), infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (entire, "def"), infsupdec (-2.0, 1.0, "trv"))){1}, decorationpart (infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (entire, "def"), infsupdec (0.0, 1.0, "dac")), infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (entire, "def"), infsupdec (0.0, 1.0, "dac"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (entire, "def"), infsupdec (-0.0, 1.0, "def")), infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (entire, "def"), infsupdec (-0.0, 1.0, "def"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (entire, "def"), infsupdec (0.1, 1.0, "com")), infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "def"))); %! assert (isequal (decorationpart (atan2 (infsupdec (entire, "def"), infsupdec (0.1, 1.0, "com"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "def")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 0.0, "com"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 0.0, "com"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 0.0, "dac"), infsupdec (entire, "def")), infsupdec (0.0, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 0.0, "dac"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (0.0, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 0.0, "def"), infsupdec (0.0, 0.0, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 0.0, "def"), infsupdec (0.0, 0.0, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 0.0, "trv"), infsupdec (-0.0, 0.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 0.0, "trv"), infsupdec (-0.0, 0.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 0.0, "com"), infsupdec (0.0, -0.0, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 0.0, "com"), infsupdec (0.0, -0.0, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 0.0, "dac"), infsupdec (-0.0, -0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 0.0, "dac"), infsupdec (-0.0, -0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 0.0, "com"), infsupdec (-2.0, -0.1, "dac")), infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "dac"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 0.0, "com"), infsupdec (-2.0, -0.1, "dac"))){1}, decorationpart (infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "dac")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 0.0, "trv"), infsupdec (-2.0, 0.0, "com")), infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 0.0, "trv"), infsupdec (-2.0, 0.0, "com"))){1}, decorationpart (infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 0.0, "com"), infsupdec (-2.0, -0.0, "trv")), infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 0.0, "com"), infsupdec (-2.0, -0.0, "trv"))){1}, decorationpart (infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 0.0, "dac"), infsupdec (-2.0, 1.0, "def")), infsupdec (0.0, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 0.0, "dac"), infsupdec (-2.0, 1.0, "def"))){1}, decorationpart (infsupdec (0.0, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 0.0, "def"), infsupdec (0.0, 1.0, "com")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 0.0, "def"), infsupdec (0.0, 1.0, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 0.0, "trv"), infsupdec (-0.0, 1.0, "dac")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 0.0, "trv"), infsupdec (-0.0, 1.0, "dac"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 0.0, "com"), infsupdec (0.1, 1.0, "com")), infsupdec (0.0, 0.0, "com"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 0.0, "com"), infsupdec (0.1, 1.0, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "com")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 0.0, "com"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 0.0, "com"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 0.0, "dac"), infsupdec (entire, "def")), infsupdec (0.0, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 0.0, "dac"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (0.0, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 0.0, "def"), infsupdec (0.0, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 0.0, "def"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 0.0, "trv"), infsupdec (-0.0, 0.0, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 0.0, "trv"), infsupdec (-0.0, 0.0, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 0.0, "com"), infsupdec (0.0, -0.0, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 0.0, "com"), infsupdec (0.0, -0.0, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 0.0, "dac"), infsupdec (-0.0, -0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 0.0, "dac"), infsupdec (-0.0, -0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 0.0, "dac"), infsupdec (-2.0, -0.1, "dac")), infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "dac"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 0.0, "dac"), infsupdec (-2.0, -0.1, "dac"))){1}, decorationpart (infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "dac")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 0.0, "trv"), infsupdec (-2.0, 0.0, "com")), infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 0.0, "trv"), infsupdec (-2.0, 0.0, "com"))){1}, decorationpart (infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 0.0, "com"), infsupdec (-2.0, -0.0, "trv")), infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 0.0, "com"), infsupdec (-2.0, -0.0, "trv"))){1}, decorationpart (infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 0.0, "dac"), infsupdec (-2.0, 1.0, "def")), infsupdec (0.0, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 0.0, "dac"), infsupdec (-2.0, 1.0, "def"))){1}, decorationpart (infsupdec (0.0, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 0.0, "com"), infsupdec (0.0, 1.0, "com")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 0.0, "com"), infsupdec (0.0, 1.0, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 0.0, "def"), infsupdec (-0.0, 1.0, "dac")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 0.0, "def"), infsupdec (-0.0, 1.0, "dac"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 0.0, "com"), infsupdec (0.1, 1.0, "com")), infsupdec (0.0, 0.0, "com"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 0.0, "com"), infsupdec (0.1, 1.0, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "com")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, -0.0, "com"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, -0.0, "com"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, -0.0, "dac"), infsupdec (entire, "def")), infsupdec (0.0, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, -0.0, "dac"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (0.0, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, -0.0, "def"), infsupdec (0.0, 0.0, "dac")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, -0.0, "def"), infsupdec (0.0, 0.0, "dac"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, -0.0, "trv"), infsupdec (-0.0, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, -0.0, "trv"), infsupdec (-0.0, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, -0.0, "dac"), infsupdec (0.0, -0.0, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, -0.0, "dac"), infsupdec (0.0, -0.0, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, -0.0, "com"), infsupdec (-0.0, -0.0, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, -0.0, "com"), infsupdec (-0.0, -0.0, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, -0.0, "com"), infsupdec (-2.0, -0.1, "dac")), infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "dac"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, -0.0, "com"), infsupdec (-2.0, -0.1, "dac"))){1}, decorationpart (infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "dac")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, -0.0, "def"), infsupdec (-2.0, 0.0, "com")), infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, -0.0, "def"), infsupdec (-2.0, 0.0, "com"))){1}, decorationpart (infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, -0.0, "com"), infsupdec (-2.0, -0.0, "dac")), infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, -0.0, "com"), infsupdec (-2.0, -0.0, "dac"))){1}, decorationpart (infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, -0.0, "dac"), infsupdec (-2.0, 1.0, "com")), infsupdec (0.0, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, -0.0, "dac"), infsupdec (-2.0, 1.0, "com"))){1}, decorationpart (infsupdec (0.0, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, -0.0, "com"), infsupdec (0.0, 1.0, "trv")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, -0.0, "com"), infsupdec (0.0, 1.0, "trv"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, -0.0, "def"), infsupdec (-0.0, 1.0, "com")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, -0.0, "def"), infsupdec (-0.0, 1.0, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, -0.0, "com"), infsupdec (0.1, 1.0, "def")), infsupdec (0.0, 0.0, "def"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, -0.0, "com"), infsupdec (0.1, 1.0, "def"))){1}, decorationpart (infsupdec (0.0, 0.0, "def")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, -0.0, "com"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, -0.0, "com"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, -0.0, "def"), infsupdec (entire, "def")), infsupdec (0.0, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, -0.0, "def"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (0.0, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, -0.0, "dac"), infsupdec (0.0, 0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, -0.0, "dac"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, -0.0, "trv"), infsupdec (-0.0, 0.0, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, -0.0, "trv"), infsupdec (-0.0, 0.0, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, -0.0, "com"), infsupdec (0.0, -0.0, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, -0.0, "com"), infsupdec (0.0, -0.0, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, -0.0, "dac"), infsupdec (-0.0, -0.0, "com")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, -0.0, "dac"), infsupdec (-0.0, -0.0, "com"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, -0.0, "def"), infsupdec (-2.0, -0.1, "dac")), infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "def"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, -0.0, "def"), infsupdec (-2.0, -0.1, "dac"))){1}, decorationpart (infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "def")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, -0.0, "trv"), infsupdec (-2.0, 0.0, "def")), infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, -0.0, "trv"), infsupdec (-2.0, 0.0, "def"))){1}, decorationpart (infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, -0.0, "dac"), infsupdec (-2.0, -0.0, "trv")), infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, -0.0, "dac"), infsupdec (-2.0, -0.0, "trv"))){1}, decorationpart (infsupdec (3.141592653589793116e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, -0.0, "def"), infsupdec (-2.0, 1.0, "com")), infsupdec (0.0, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, -0.0, "def"), infsupdec (-2.0, 1.0, "com"))){1}, decorationpart (infsupdec (0.0, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, -0.0, "com"), infsupdec (0.0, 1.0, "com")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, -0.0, "com"), infsupdec (0.0, 1.0, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, -0.0, "trv"), infsupdec (-0.0, 1.0, "dac")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, -0.0, "trv"), infsupdec (-0.0, 1.0, "dac"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, -0.0, "com"), infsupdec (0.1, 1.0, "com")), infsupdec (0.0, 0.0, "com"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, -0.0, "com"), infsupdec (0.1, 1.0, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "com")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.1, "dac"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.1, "dac"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.1, "def"), infsupdec (entire, "def")), infsupdec (-3.141592653589793560e+00, 0.0, "def"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.1, "def"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (-3.141592653589793560e+00, 0.0, "def")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.1, "trv"), infsupdec (0.0, 0.0, "com")), infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.1, "trv"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.1, "com"), infsupdec (0.0, -0.0, "dac")), infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "dac"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.1, "com"), infsupdec (0.0, -0.0, "dac"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "dac")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.1, "dac"), infsupdec (-0.0, 0.0, "def")), infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "def"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.1, "dac"), infsupdec (-0.0, 0.0, "def"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "def")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.1, "com"), infsupdec (0.0, -0.0, "trv")), infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.1, "com"), infsupdec (0.0, -0.0, "trv"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.1, "def"), infsupdec (-2.0, -0.1, "com")), infsupdec (-3.091634257867850621e+00, -1.620754722516839275e+00, "def"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.1, "def"), infsupdec (-2.0, -0.1, "com"))){1}, decorationpart (infsupdec (-3.091634257867850621e+00, -1.620754722516839275e+00, "def")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.1, "com"), infsupdec (-2.0, 0.0, "def")), infsupdec (-3.091634257867850621e+00, -1.570796326794896558e+00, "def"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.1, "com"), infsupdec (-2.0, 0.0, "def"))){1}, decorationpart (infsupdec (-3.091634257867850621e+00, -1.570796326794896558e+00, "def")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.1, "trv"), infsupdec (-2.0, -0.0, "dac")), infsupdec (-3.091634257867850621e+00, -1.570796326794896558e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.1, "trv"), infsupdec (-2.0, -0.0, "dac"))){1}, decorationpart (infsupdec (-3.091634257867850621e+00, -1.570796326794896558e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.1, "def"), infsupdec (-2.0, 1.0, "trv")), infsupdec (-3.091634257867850621e+00, -9.966865249116202419e-02, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.1, "def"), infsupdec (-2.0, 1.0, "trv"))){1}, decorationpart (infsupdec (-3.091634257867850621e+00, -9.966865249116202419e-02, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.1, "com"), infsupdec (0.0, 1.0, "def")), infsupdec (-1.570796326794896780e+00, -9.966865249116202419e-02, "def"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.1, "com"), infsupdec (0.0, 1.0, "def"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, -9.966865249116202419e-02, "def")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.1, "dac"), infsupdec (-0.0, 1.0, "com")), infsupdec (-1.570796326794896780e+00, -9.966865249116202419e-02, "dac"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.1, "dac"), infsupdec (-0.0, 1.0, "com"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, -9.966865249116202419e-02, "dac")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.1, "com"), infsupdec (0.1, 1.0, "com")), infsupdec (-1.520837931072954063e+00, -9.966865249116202419e-02, "com"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.1, "com"), infsupdec (0.1, 1.0, "com"))){1}, decorationpart (infsupdec (-1.520837931072954063e+00, -9.966865249116202419e-02, "com")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 0.0, "def"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 0.0, "def"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 0.0, "def"), infsupdec (entire, "def")), infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 0.0, "def"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 0.0, "dac"), infsupdec (0.0, 0.0, "dac")), infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 0.0, "dac"), infsupdec (0.0, 0.0, "dac"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 0.0, "trv"), infsupdec (-0.0, 0.0, "com")), infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 0.0, "trv"), infsupdec (-0.0, 0.0, "com"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 0.0, "com"), infsupdec (0.0, -0.0, "trv")), infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 0.0, "com"), infsupdec (0.0, -0.0, "trv"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 0.0, "def"), infsupdec (-0.0, -0.0, "def")), infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 0.0, "def"), infsupdec (-0.0, -0.0, "def"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 0.0, "com"), infsupdec (-2.0, -0.1, "dac")), infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "def"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 0.0, "com"), infsupdec (-2.0, -0.1, "dac"))){1}, decorationpart (infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "def")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 0.0, "dac"), infsupdec (-2.0, 0.0, "com")), infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 0.0, "dac"), infsupdec (-2.0, 0.0, "com"))){1}, decorationpart (infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 0.0, "com"), infsupdec (-2.0, -0.0, "dac")), infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 0.0, "com"), infsupdec (-2.0, -0.0, "dac"))){1}, decorationpart (infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 0.0, "trv"), infsupdec (-2.0, 1.0, "com")), infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 0.0, "trv"), infsupdec (-2.0, 1.0, "com"))){1}, decorationpart (infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 0.0, "def"), infsupdec (0.0, 1.0, "def")), infsupdec (-1.570796326794896780e+00, 0.0, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 0.0, "def"), infsupdec (0.0, 1.0, "def"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 0.0, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 0.0, "com"), infsupdec (-0.0, 1.0, "dac")), infsupdec (-1.570796326794896780e+00, 0.0, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 0.0, "com"), infsupdec (-0.0, 1.0, "dac"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 0.0, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 0.0, "com"), infsupdec (0.1, 1.0, "com")), infsupdec (-1.520837931072954063e+00, 0.0, "com"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 0.0, "com"), infsupdec (0.1, 1.0, "com"))){1}, decorationpart (infsupdec (-1.520837931072954063e+00, 0.0, "com")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.0, "trv"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.0, "trv"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.0, "dac"), infsupdec (entire, "def")), infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.0, "dac"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.0, "com"), infsupdec (0.0, 0.0, "com")), infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.0, "com"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.0, "def"), infsupdec (-0.0, 0.0, "dac")), infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.0, "def"), infsupdec (-0.0, 0.0, "dac"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.0, "dac"), infsupdec (0.0, -0.0, "def")), infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.0, "dac"), infsupdec (0.0, -0.0, "def"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.0, "com"), infsupdec (-0.0, -0.0, "trv")), infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.0, "com"), infsupdec (-0.0, -0.0, "trv"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, -1.570796326794896558e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.0, "def"), infsupdec (-2.0, -0.1, "com")), infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "def"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.0, "def"), infsupdec (-2.0, -0.1, "com"))){1}, decorationpart (infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "def")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.0, "com"), infsupdec (-2.0, 0.0, "dac")), infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.0, "com"), infsupdec (-2.0, 0.0, "dac"))){1}, decorationpart (infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.0, "dac"), infsupdec (-2.0, -0.0, "def")), infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.0, "dac"), infsupdec (-2.0, -0.0, "def"))){1}, decorationpart (infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.0, "def"), infsupdec (-2.0, 1.0, "trv")), infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.0, "def"), infsupdec (-2.0, 1.0, "trv"))){1}, decorationpart (infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.0, "trv"), infsupdec (0.0, 1.0, "dac")), infsupdec (-1.570796326794896780e+00, 0.0, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.0, "trv"), infsupdec (0.0, 1.0, "dac"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 0.0, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.0, "com"), infsupdec (-0.0, 1.0, "com")), infsupdec (-1.570796326794896780e+00, 0.0, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.0, "com"), infsupdec (-0.0, 1.0, "com"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 0.0, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, -0.0, "com"), infsupdec (0.1, 1.0, "com")), infsupdec (-1.520837931072954063e+00, 0.0, "com"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, -0.0, "com"), infsupdec (0.1, 1.0, "com"))){1}, decorationpart (infsupdec (-1.520837931072954063e+00, 0.0, "com")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 1.0, "def"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 1.0, "def"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 1.0, "dac"), infsupdec (entire, "def")), infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 1.0, "dac"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 1.0, "def"), infsupdec (0.0, 0.0, "def")), infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 1.0, "def"), infsupdec (0.0, 0.0, "def"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 1.0, "com"), infsupdec (-0.0, 0.0, "dac")), infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 1.0, "com"), infsupdec (-0.0, 0.0, "dac"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 1.0, "trv"), infsupdec (0.0, -0.0, "trv")), infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 1.0, "trv"), infsupdec (0.0, -0.0, "trv"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 1.0, "com"), infsupdec (-0.0, -0.0, "com")), infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 1.0, "com"), infsupdec (-0.0, -0.0, "com"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 1.0, "dac"), infsupdec (-2.0, -0.1, "dac")), infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "def"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 1.0, "dac"), infsupdec (-2.0, -0.1, "dac"))){1}, decorationpart (infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "def")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 1.0, "def"), infsupdec (-2.0, 0.0, "def")), infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 1.0, "def"), infsupdec (-2.0, 0.0, "def"))){1}, decorationpart (infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 1.0, "trv"), infsupdec (-2.0, -0.0, "trv")), infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 1.0, "trv"), infsupdec (-2.0, -0.0, "trv"))){1}, decorationpart (infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 1.0, "dac"), infsupdec (-2.0, 1.0, "com")), infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 1.0, "dac"), infsupdec (-2.0, 1.0, "com"))){1}, decorationpart (infsupdec (-3.141592653589793560e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 1.0, "com"), infsupdec (0.0, 1.0, "dac")), infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 1.0, "com"), infsupdec (0.0, 1.0, "dac"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 1.0, "trv"), infsupdec (-0.0, 1.0, "dac")), infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 1.0, "trv"), infsupdec (-0.0, 1.0, "dac"))){1}, decorationpart (infsupdec (-1.570796326794896780e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-2.0, 1.0, "com"), infsupdec (0.1, 1.0, "com")), infsupdec (-1.520837931072954063e+00, 1.471127674303734700e+00, "com"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-2.0, 1.0, "com"), infsupdec (0.1, 1.0, "com"))){1}, decorationpart (infsupdec (-1.520837931072954063e+00, 1.471127674303734700e+00, "com")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 1.0, "com"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 1.0, "com"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 1.0, "dac"), infsupdec (entire, "def")), infsupdec (0.0, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 1.0, "dac"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (0.0, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 1.0, "def"), infsupdec (0.0, 0.0, "def")), infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 1.0, "def"), infsupdec (0.0, 0.0, "def"))){1}, decorationpart (infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 1.0, "trv"), infsupdec (-0.0, 0.0, "trv")), infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 1.0, "trv"), infsupdec (-0.0, 0.0, "trv"))){1}, decorationpart (infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 1.0, "dac"), infsupdec (0.0, -0.0, "dac")), infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 1.0, "dac"), infsupdec (0.0, -0.0, "dac"))){1}, decorationpart (infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 1.0, "com"), infsupdec (-0.0, -0.0, "def")), infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 1.0, "com"), infsupdec (-0.0, -0.0, "def"))){1}, decorationpart (infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 1.0, "com"), infsupdec (-2.0, -0.1, "com")), infsupdec (1.670464979286058638e+00, 3.141592653589793560e+00, "dac"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 1.0, "com"), infsupdec (-2.0, -0.1, "com"))){1}, decorationpart (infsupdec (1.670464979286058638e+00, 3.141592653589793560e+00, "dac")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 1.0, "def"), infsupdec (-2.0, 0.0, "com")), infsupdec (1.570796326794896558e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 1.0, "def"), infsupdec (-2.0, 0.0, "com"))){1}, decorationpart (infsupdec (1.570796326794896558e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 1.0, "def"), infsupdec (-2.0, -0.0, "def")), infsupdec (1.570796326794896558e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 1.0, "def"), infsupdec (-2.0, -0.0, "def"))){1}, decorationpart (infsupdec (1.570796326794896558e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 1.0, "dac"), infsupdec (-2.0, 1.0, "dac")), infsupdec (0.0, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 1.0, "dac"), infsupdec (-2.0, 1.0, "dac"))){1}, decorationpart (infsupdec (0.0, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 1.0, "dac"), infsupdec (0.0, 1.0, "dac")), infsupdec (0.0, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 1.0, "dac"), infsupdec (0.0, 1.0, "dac"))){1}, decorationpart (infsupdec (0.0, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 1.0, "trv"), infsupdec (-0.0, 1.0, "com")), infsupdec (0.0, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 1.0, "trv"), infsupdec (-0.0, 1.0, "com"))){1}, decorationpart (infsupdec (0.0, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (-0.0, 1.0, "trv"), infsupdec (0.1, 1.0, "com")), infsupdec (0.0, 1.471127674303734700e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (-0.0, 1.0, "trv"), infsupdec (0.1, 1.0, "com"))){1}, decorationpart (infsupdec (0.0, 1.471127674303734700e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 1.0, "def"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 1.0, "def"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 1.0, "dac"), infsupdec (entire, "def")), infsupdec (0.0, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 1.0, "dac"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (0.0, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 1.0, "dac"), infsupdec (0.0, 0.0, "def")), infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 1.0, "dac"), infsupdec (0.0, 0.0, "def"))){1}, decorationpart (infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 1.0, "trv"), infsupdec (-0.0, 0.0, "trv")), infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 1.0, "trv"), infsupdec (-0.0, 0.0, "trv"))){1}, decorationpart (infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 1.0, "trv"), infsupdec (0.0, -0.0, "dac")), infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 1.0, "trv"), infsupdec (0.0, -0.0, "dac"))){1}, decorationpart (infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 1.0, "def"), infsupdec (-0.0, -0.0, "com")), infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 1.0, "def"), infsupdec (-0.0, -0.0, "com"))){1}, decorationpart (infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 1.0, "dac"), infsupdec (-2.0, -0.1, "dac")), infsupdec (1.670464979286058638e+00, 3.141592653589793560e+00, "dac"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 1.0, "dac"), infsupdec (-2.0, -0.1, "dac"))){1}, decorationpart (infsupdec (1.670464979286058638e+00, 3.141592653589793560e+00, "dac")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 1.0, "def"), infsupdec (-2.0, 0.0, "trv")), infsupdec (1.570796326794896558e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 1.0, "def"), infsupdec (-2.0, 0.0, "trv"))){1}, decorationpart (infsupdec (1.570796326794896558e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 1.0, "dac"), infsupdec (-2.0, -0.0, "dac")), infsupdec (1.570796326794896558e+00, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 1.0, "dac"), infsupdec (-2.0, -0.0, "dac"))){1}, decorationpart (infsupdec (1.570796326794896558e+00, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 1.0, "dac"), infsupdec (-2.0, 1.0, "def")), infsupdec (0.0, 3.141592653589793560e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 1.0, "dac"), infsupdec (-2.0, 1.0, "def"))){1}, decorationpart (infsupdec (0.0, 3.141592653589793560e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 1.0, "dac"), infsupdec (0.0, 1.0, "trv")), infsupdec (0.0, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 1.0, "dac"), infsupdec (0.0, 1.0, "trv"))){1}, decorationpart (infsupdec (0.0, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 1.0, "dac"), infsupdec (-0.0, 1.0, "def")), infsupdec (0.0, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 1.0, "dac"), infsupdec (-0.0, 1.0, "def"))){1}, decorationpart (infsupdec (0.0, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.0, 1.0, "com"), infsupdec (0.1, 1.0, "com")), infsupdec (0.0, 1.471127674303734700e+00, "com"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.0, 1.0, "com"), infsupdec (0.1, 1.0, "com"))){1}, decorationpart (infsupdec (0.0, 1.471127674303734700e+00, "com")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.1, 1.0, "dac"), infsupdec (empty, "trv")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.1, 1.0, "dac"), infsupdec (empty, "trv"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.1, 1.0, "dac"), infsupdec (entire, "def")), infsupdec (0.0, 3.141592653589793560e+00, "def"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.1, 1.0, "dac"), infsupdec (entire, "def"))){1}, decorationpart (infsupdec (0.0, 3.141592653589793560e+00, "def")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.1, 1.0, "def"), infsupdec (0.0, 0.0, "com")), infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "def"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.1, 1.0, "def"), infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "def")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.1, 1.0, "trv"), infsupdec (-0.0, 0.0, "def")), infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.1, 1.0, "trv"), infsupdec (-0.0, 0.0, "def"))){1}, decorationpart (infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.1, 1.0, "trv"), infsupdec (0.0, -0.0, "def")), infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.1, 1.0, "trv"), infsupdec (0.0, -0.0, "def"))){1}, decorationpart (infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.1, 1.0, "dac"), infsupdec (-0.0, -0.0, "def")), infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "def"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.1, 1.0, "dac"), infsupdec (-0.0, -0.0, "def"))){1}, decorationpart (infsupdec (1.570796326794896558e+00, 1.570796326794896780e+00, "def")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.1, 1.0, "com"), infsupdec (-2.0, -0.1, "trv")), infsupdec (1.670464979286058638e+00, 3.091634257867850621e+00, "trv"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.1, 1.0, "com"), infsupdec (-2.0, -0.1, "trv"))){1}, decorationpart (infsupdec (1.670464979286058638e+00, 3.091634257867850621e+00, "trv")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.1, 1.0, "com"), infsupdec (-2.0, 0.0, "dac")), infsupdec (1.570796326794896558e+00, 3.091634257867850621e+00, "dac"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.1, 1.0, "com"), infsupdec (-2.0, 0.0, "dac"))){1}, decorationpart (infsupdec (1.570796326794896558e+00, 3.091634257867850621e+00, "dac")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.1, 1.0, "com"), infsupdec (-2.0, -0.0, "dac")), infsupdec (1.570796326794896558e+00, 3.091634257867850621e+00, "dac"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.1, 1.0, "com"), infsupdec (-2.0, -0.0, "dac"))){1}, decorationpart (infsupdec (1.570796326794896558e+00, 3.091634257867850621e+00, "dac")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.1, 1.0, "def"), infsupdec (-2.0, 1.0, "dac")), infsupdec (9.966865249116202419e-02, 3.091634257867850621e+00, "def"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.1, 1.0, "def"), infsupdec (-2.0, 1.0, "dac"))){1}, decorationpart (infsupdec (9.966865249116202419e-02, 3.091634257867850621e+00, "def")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.1, 1.0, "def"), infsupdec (0.0, 1.0, "def")), infsupdec (9.966865249116202419e-02, 1.570796326794896780e+00, "def"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.1, 1.0, "def"), infsupdec (0.0, 1.0, "def"))){1}, decorationpart (infsupdec (9.966865249116202419e-02, 1.570796326794896780e+00, "def")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.1, 1.0, "dac"), infsupdec (-0.0, 1.0, "def")), infsupdec (9.966865249116202419e-02, 1.570796326794896780e+00, "def"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.1, 1.0, "dac"), infsupdec (-0.0, 1.0, "def"))){1}, decorationpart (infsupdec (9.966865249116202419e-02, 1.570796326794896780e+00, "def")){1})); %!test %! assert (isequal (atan2 (infsupdec (0.1, 1.0, "dac"), infsupdec (0.1, 1.0, "def")), infsupdec (9.966865249116202419e-02, 1.471127674303734700e+00, "def"))); %! assert (isequal (decorationpart (atan2 (infsupdec (0.1, 1.0, "dac"), infsupdec (0.1, 1.0, "def"))){1}, decorationpart (infsupdec (9.966865249116202419e-02, 1.471127674303734700e+00, "def")){1})); ## minimal_sinh_test %!test %! assert (isequal (sinh (infsup), infsup)); %!test %! assert (isequal (sinh (infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (sinh (infsup (-0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (sinh (infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (sinh (infsup (-inf, -0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (sinh (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (sinh (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (sinh (infsup (-0.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (sinh (infsup (1.0, 3.005632345000000214e+02)), infsup (1.175201193643801378e+00, 1.705784684221513993e+130))); %!test %! assert (isequal (sinh (infsup (-5.466754345546680298e+11, -5.658889722000000120e+02)), infsup (-inf, -2.893530074810801279e+245))); %!test %! assert (isequal (sinh (infsup (-1.100000000000000089e+00, 2.299999999999999822e+00)), infsup (-1.335647470124176950e+00, 4.936961805545958093e+00))); ## minimal_sinh_dec_test %!test %! assert (isequal (sinh (infsupdec (entire, "def")), infsupdec (entire, "def"))); %! assert (isequal (decorationpart (sinh (infsupdec (entire, "def"))){1}, decorationpart (infsupdec (entire, "def")){1})); %!test %! assert (isequal (sinh (infsupdec (0.0, inf, "dac")), infsupdec (0.0, inf, "dac"))); %! assert (isequal (decorationpart (sinh (infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "dac")){1})); %!test %! assert (isequal (sinh (infsupdec (-inf, 0.0, "def")), infsupdec (-inf, 0.0, "def"))); %! assert (isequal (decorationpart (sinh (infsupdec (-inf, 0.0, "def"))){1}, decorationpart (infsupdec (-inf, 0.0, "def")){1})); %!test %! assert (isequal (sinh (infsupdec (1.0, 3.005632345000000214e+02, "com")), infsupdec (1.175201193643801378e+00, 1.705784684221513993e+130, "com"))); %! assert (isequal (decorationpart (sinh (infsupdec (1.0, 3.005632345000000214e+02, "com"))){1}, decorationpart (infsupdec (1.175201193643801378e+00, 1.705784684221513993e+130, "com")){1})); %!test %! assert (isequal (sinh (infsupdec (-5.466754345546680298e+11, -5.658889722000000120e+02, "com")), infsupdec (-inf, -2.893530074810801279e+245, "dac"))); %! assert (isequal (decorationpart (sinh (infsupdec (-5.466754345546680298e+11, -5.658889722000000120e+02, "com"))){1}, decorationpart (infsupdec (-inf, -2.893530074810801279e+245, "dac")){1})); ## minimal_cosh_test %!test %! assert (isequal (cosh (infsup), infsup)); %!test %! assert (isequal (cosh (infsup (0.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (cosh (infsup (-0.0, inf)), infsup (1.0, inf))); %!test %! assert (isequal (cosh (infsup (-inf, 0.0)), infsup (1.0, inf))); %!test %! assert (isequal (cosh (infsup (-inf, -0.0)), infsup (1.0, inf))); %!test %! assert (isequal (cosh (infsup (-inf, inf)), infsup (1.0, inf))); %!test %! assert (isequal (cosh (infsup (0.0, 0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (cosh (infsup (-0.0, -0.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (cosh (infsup (1.0, 3.005632345000000214e+02)), infsup (1.543080634815243712e+00, 1.705784684221513993e+130))); %!test %! assert (isequal (cosh (infsup (-5.466754345546680298e+11, -5.658889722000000120e+02)), infsup (2.893530074810801279e+245, inf))); %!test %! assert (isequal (cosh (infsup (-1.100000000000000089e+00, 2.299999999999999822e+00)), infsup (1.0, 5.037220649268761896e+00))); ## minimal_cosh_dec_test %!test %! assert (isequal (cosh (infsupdec (0.0, inf, "dac")), infsupdec (1.0, inf, "dac"))); %! assert (isequal (decorationpart (cosh (infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (1.0, inf, "dac")){1})); %!test %! assert (isequal (cosh (infsupdec (-inf, 0.0, "def")), infsupdec (1.0, inf, "def"))); %! assert (isequal (decorationpart (cosh (infsupdec (-inf, 0.0, "def"))){1}, decorationpart (infsupdec (1.0, inf, "def")){1})); %!test %! assert (isequal (cosh (infsupdec (entire, "def")), infsupdec (1.0, inf, "def"))); %! assert (isequal (decorationpart (cosh (infsupdec (entire, "def"))){1}, decorationpart (infsupdec (1.0, inf, "def")){1})); %!test %! assert (isequal (cosh (infsupdec (1.0, 3.005632345000000214e+02, "def")), infsupdec (1.543080634815243712e+00, 1.705784684221513993e+130, "def"))); %! assert (isequal (decorationpart (cosh (infsupdec (1.0, 3.005632345000000214e+02, "def"))){1}, decorationpart (infsupdec (1.543080634815243712e+00, 1.705784684221513993e+130, "def")){1})); %!test %! assert (isequal (cosh (infsupdec (-5.466754345546680298e+11, -5.658889722000000120e+02, "com")), infsupdec (2.893530074810801279e+245, inf, "dac"))); %! assert (isequal (decorationpart (cosh (infsupdec (-5.466754345546680298e+11, -5.658889722000000120e+02, "com"))){1}, decorationpart (infsupdec (2.893530074810801279e+245, inf, "dac")){1})); ## minimal_tanh_test %!test %! assert (isequal (tanh (infsup), infsup)); %!test %! assert (isequal (tanh (infsup (0.0, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (tanh (infsup (-0.0, inf)), infsup (0.0, 1.0))); %!test %! assert (isequal (tanh (infsup (-inf, 0.0)), infsup (-1.0, 0.0))); %!test %! assert (isequal (tanh (infsup (-inf, -0.0)), infsup (-1.0, 0.0))); %!test %! assert (isequal (tanh (infsup (-inf, inf)), infsup (-1.0, 1.0))); %!test %! assert (isequal (tanh (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (tanh (infsup (-0.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (tanh (infsup (1.0, 3.005632345000000214e+02)), infsup (7.615941559557648510e-01, 1.000000000000000000e+00))); %!test %! assert (isequal (tanh (infsup (-5.466754345546680298e+11, -5.658889722000000120e+02)), infsup (-1.000000000000000000e+00, -9.999999999999998890e-01))); %!test %! assert (isequal (tanh (infsup (-1.100000000000000089e+00, 2.299999999999999822e+00)), infsup (-8.004990217606298142e-01, 9.800963962661913831e-01))); ## minimal_tanh_dec_test %!test %! assert (isequal (tanh (infsupdec (0.0, inf, "dac")), infsupdec (0.0, 1.0, "dac"))); %! assert (isequal (decorationpart (tanh (infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (0.0, 1.0, "dac")){1})); %!test %! assert (isequal (tanh (infsupdec (-inf, 0.0, "def")), infsupdec (-1.0, 0.0, "def"))); %! assert (isequal (decorationpart (tanh (infsupdec (-inf, 0.0, "def"))){1}, decorationpart (infsupdec (-1.0, 0.0, "def")){1})); %!test %! assert (isequal (tanh (infsupdec (entire, "def")), infsupdec (-1.0, 1.0, "def"))); %! assert (isequal (decorationpart (tanh (infsupdec (entire, "def"))){1}, decorationpart (infsupdec (-1.0, 1.0, "def")){1})); %!test %! assert (isequal (tanh (infsupdec (1.0, 3.005632345000000214e+02, "com")), infsupdec (7.615941559557648510e-01, 1.000000000000000000e+00, "com"))); %! assert (isequal (decorationpart (tanh (infsupdec (1.0, 3.005632345000000214e+02, "com"))){1}, decorationpart (infsupdec (7.615941559557648510e-01, 1.000000000000000000e+00, "com")){1})); %!test %! assert (isequal (tanh (infsupdec (-5.466754345546680298e+11, -5.658889722000000120e+02, "trv")), infsupdec (-1.000000000000000000e+00, -9.999999999999998890e-01, "trv"))); %! assert (isequal (decorationpart (tanh (infsupdec (-5.466754345546680298e+11, -5.658889722000000120e+02, "trv"))){1}, decorationpart (infsupdec (-1.000000000000000000e+00, -9.999999999999998890e-01, "trv")){1})); ## minimal_asinh_test %!test %! assert (isequal (asinh (infsup), infsup)); %!test %! assert (isequal (asinh (infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (asinh (infsup (-0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (asinh (infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (asinh (infsup (-inf, -0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (asinh (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (asinh (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (asinh (infsup (-0.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (asinh (infsup (1.0, 3.005632345000000214e+02)), infsup (8.813735870195429367e-01, 6.398808110711462938e+00))); %!test %! assert (isequal (asinh (infsup (-5.466754345546680298e+11, -5.658889722000000120e+02)), infsup (-2.772026828834738765e+01, -7.031545858017159922e+00))); %!test %! assert (isequal (asinh (infsup (-1.100000000000000089e+00, 2.299999999999999822e+00)), infsup (-9.503469298211343341e-01, 1.570278543484978195e+00))); ## minimal_asinh_dec_test %!test %! assert (isequal (asinh (infsupdec (0.0, inf, "dac")), infsupdec (0.0, inf, "dac"))); %! assert (isequal (decorationpart (asinh (infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "dac")){1})); %!test %! assert (isequal (asinh (infsupdec (-inf, 0.0, "trv")), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (asinh (infsupdec (-inf, 0.0, "trv"))){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %!test %! assert (isequal (asinh (infsupdec (entire, "def")), infsupdec (entire, "def"))); %! assert (isequal (decorationpart (asinh (infsupdec (entire, "def"))){1}, decorationpart (infsupdec (entire, "def")){1})); %!test %! assert (isequal (asinh (infsupdec (1.0, 3.005632345000000214e+02, "com")), infsupdec (8.813735870195429367e-01, 6.398808110711462938e+00, "com"))); %! assert (isequal (decorationpart (asinh (infsupdec (1.0, 3.005632345000000214e+02, "com"))){1}, decorationpart (infsupdec (8.813735870195429367e-01, 6.398808110711462938e+00, "com")){1})); %!test %! assert (isequal (asinh (infsupdec (-5.466754345546680298e+11, -5.658889722000000120e+02, "def")), infsupdec (-2.772026828834738765e+01, -7.031545858017159922e+00, "def"))); %! assert (isequal (decorationpart (asinh (infsupdec (-5.466754345546680298e+11, -5.658889722000000120e+02, "def"))){1}, decorationpart (infsupdec (-2.772026828834738765e+01, -7.031545858017159922e+00, "def")){1})); ## minimal_acosh_test %!test %! assert (isequal (acosh (infsup), infsup)); %!test %! assert (isequal (acosh (infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (acosh (infsup (-0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (acosh (infsup (1.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (acosh (infsup (-inf, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (acosh (infsup (-inf, 9.999999999999998890e-01)), infsup)); %!test %! assert (isequal (acosh (infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (acosh (infsup (1.0, 1.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (acosh (infsup (1.0, 3.005632345000000214e+02)), infsup (0.0, 6.398802575957843963e+00))); %!test %! assert (isequal (acosh (infsup (1.100000000000000089e+00, 2.299999999999999822e+00)), infsup (4.435682543851153792e-01, 1.475044781241425129e+00))); %!test %! assert (isequal (acosh (infsup (3.543445345434999763e+04, 7.777477475642000437e+08)), infsup (1.116858706759319908e+01, 2.116505997820545559e+01))); ## minimal_acosh_dec_test %!test %! assert (isequal (acosh (infsupdec (0.0, inf, "dac")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (acosh (infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (acosh (infsupdec (1.0, inf, "dac")), infsupdec (0.0, inf, "dac"))); %! assert (isequal (decorationpart (acosh (infsupdec (1.0, inf, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "dac")){1})); %!test %! assert (isequal (acosh (infsupdec (entire, "def")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (acosh (infsupdec (entire, "def"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (acosh (infsupdec (1.0, 1.0, "com")), infsupdec (0.0, 0.0, "com"))); %! assert (isequal (decorationpart (acosh (infsupdec (1.0, 1.0, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "com")){1})); %!test %! assert (isequal (acosh (infsupdec (0.9, 1.0, "com")), infsupdec (0.0, 0.0, "trv"))); %! assert (isequal (decorationpart (acosh (infsupdec (0.9, 1.0, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "trv")){1})); %!test %! assert (isequal (acosh (infsupdec (1.0, 3.005632345000000214e+02, "dac")), infsupdec (0.0, 6.398802575957843963e+00, "dac"))); %! assert (isequal (decorationpart (acosh (infsupdec (1.0, 3.005632345000000214e+02, "dac"))){1}, decorationpart (infsupdec (0.0, 6.398802575957843963e+00, "dac")){1})); %!test %! assert (isequal (acosh (infsupdec (0.9, 3.005632345000000214e+02, "com")), infsupdec (0.0, 6.398802575957843963e+00, "trv"))); %! assert (isequal (decorationpart (acosh (infsupdec (0.9, 3.005632345000000214e+02, "com"))){1}, decorationpart (infsupdec (0.0, 6.398802575957843963e+00, "trv")){1})); %!test %! assert (isequal (acosh (infsupdec (3.543445345434999763e+04, 7.777477475642000437e+08, "def")), infsupdec (1.116858706759319908e+01, 2.116505997820545559e+01, "def"))); %! assert (isequal (decorationpart (acosh (infsupdec (3.543445345434999763e+04, 7.777477475642000437e+08, "def"))){1}, decorationpart (infsupdec (1.116858706759319908e+01, 2.116505997820545559e+01, "def")){1})); ## minimal_atanh_test %!test %! assert (isequal (atanh (infsup), infsup)); %!test %! assert (isequal (atanh (infsup (0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (atanh (infsup (-0.0, inf)), infsup (0.0, inf))); %!test %! assert (isequal (atanh (infsup (1.0, inf)), infsup)); %!test %! assert (isequal (atanh (infsup (-inf, 0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (atanh (infsup (-inf, -0.0)), infsup (-inf, 0.0))); %!test %! assert (isequal (atanh (infsup (-inf, -1.0)), infsup)); %!test %! assert (isequal (atanh (infsup (-1.0, 1.0)), infsup (-inf, inf))); %!test %! assert (isequal (atanh (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (atanh (infsup (-0.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (atanh (infsup (-1.0, -1.0)), infsup)); %!test %! assert (isequal (atanh (infsup (1.0, 1.0)), infsup)); %!test %! assert (isequal (atanh (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (atanh (infsup (3.242344999999999811e-01, 9.999999999999998890e-01)), infsup (3.363718566236145735e-01, 1.871497387511852395e+01))); %!test %! assert (isequal (atanh (infsup (-9.994549339999999615e-01, 1.000000000000000056e-01)), infsup (-4.103739140065865598e+00, 1.003353477310755942e-01))); ## minimal_atanh_dec_test %!test %! assert (isequal (atanh (infsupdec (0.0, inf, "dac")), infsupdec (0.0, inf, "trv"))); %! assert (isequal (decorationpart (atanh (infsupdec (0.0, inf, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "trv")){1})); %!test %! assert (isequal (atanh (infsupdec (-inf, 0.0, "def")), infsupdec (-inf, 0.0, "trv"))); %! assert (isequal (decorationpart (atanh (infsupdec (-inf, 0.0, "def"))){1}, decorationpart (infsupdec (-inf, 0.0, "trv")){1})); %!test %! assert (isequal (atanh (infsupdec (-1.0, 1.0, "com")), infsupdec (entire, "trv"))); %! assert (isequal (decorationpart (atanh (infsupdec (-1.0, 1.0, "com"))){1}, decorationpart (infsupdec (entire, "trv")){1})); %!test %! assert (isequal (atanh (infsupdec (0.0, 0.0, "com")), infsupdec (0.0, 0.0, "com"))); %! assert (isequal (decorationpart (atanh (infsupdec (0.0, 0.0, "com"))){1}, decorationpart (infsupdec (0.0, 0.0, "com")){1})); %!test %! assert (isequal (atanh (infsupdec (1.0, 1.0, "def")), infsupdec (empty, "trv"))); %! assert (isequal (decorationpart (atanh (infsupdec (1.0, 1.0, "def"))){1}, decorationpart (infsupdec (empty, "trv")){1})); %!test %! assert (isequal (atanh (infsupdec (3.242344999999999811e-01, 9.999999999999998890e-01, "com")), infsupdec (3.363718566236145735e-01, 1.871497387511852395e+01, "com"))); %! assert (isequal (decorationpart (atanh (infsupdec (3.242344999999999811e-01, 9.999999999999998890e-01, "com"))){1}, decorationpart (infsupdec (3.363718566236145735e-01, 1.871497387511852395e+01, "com")){1})); %!test %! assert (isequal (atanh (infsupdec (-1.0, 9.999999999999998890e-01, "com")), infsupdec (-inf, 1.871497387511852395e+01, "trv"))); %! assert (isequal (decorationpart (atanh (infsupdec (-1.0, 9.999999999999998890e-01, "com"))){1}, decorationpart (infsupdec (-inf, 1.871497387511852395e+01, "trv")){1})); %!test %! assert (isequal (atanh (infsupdec (-9.994549339999999615e-01, 1.000000000000000056e-01, "def")), infsupdec (-4.103739140065865598e+00, 1.003353477310755942e-01, "def"))); %! assert (isequal (decorationpart (atanh (infsupdec (-9.994549339999999615e-01, 1.000000000000000056e-01, "def"))){1}, decorationpart (infsupdec (-4.103739140065865598e+00, 1.003353477310755942e-01, "def")){1})); %!test %! assert (isequal (atanh (infsupdec (-9.994549339999999615e-01, 1.0, "com")), infsupdec (-4.103739140065865598e+00, inf, "trv"))); %! assert (isequal (decorationpart (atanh (infsupdec (-9.994549339999999615e-01, 1.0, "com"))){1}, decorationpart (infsupdec (-4.103739140065865598e+00, inf, "trv")){1})); ## minimal_sign_test %!test %! assert (isequal (sign (infsup), infsup)); %!test %! assert (isequal (sign (infsup (1.0, 2.0)), infsup (1.0, 1.0))); %!test %! assert (isequal (sign (infsup (-1.0, 2.0)), infsup (-1.0, 1.0))); %!test %! assert (isequal (sign (infsup (-1.0, 0.0)), infsup (-1.0, 0.0))); %!test %! assert (isequal (sign (infsup (0.0, 2.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (sign (infsup (-0.0, 2.0)), infsup (0.0, 1.0))); %!test %! assert (isequal (sign (infsup (-5.0, -2.0)), infsup (-1.0, -1.0))); %!test %! assert (isequal (sign (infsup (0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (sign (infsup (-0.0, -0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (sign (infsup (-0.0, 0.0)), infsup (0.0, 0.0))); %!test %! assert (isequal (sign (infsup (-inf, inf)), infsup (-1.0, 1.0))); ## minimal_sign_dec_test %!test %! assert (isequal (sign (infsupdec (1.0, 2.0, "com")), infsupdec (1.0, 1.0, "com"))); %! assert (isequal (decorationpart (sign (infsupdec (1.0, 2.0, "com"))){1}, decorationpart (infsupdec (1.0, 1.0, "com")){1})); %!test %! assert (isequal (sign (infsupdec (-1.0, 2.0, "com")), infsupdec (-1.0, 1.0, "def"))); %! assert (isequal (decorationpart (sign (infsupdec (-1.0, 2.0, "com"))){1}, decorationpart (infsupdec (-1.0, 1.0, "def")){1})); %!test %! assert (isequal (sign (infsupdec (-1.0, 0.0, "com")), infsupdec (-1.0, 0.0, "def"))); %! assert (isequal (decorationpart (sign (infsupdec (-1.0, 0.0, "com"))){1}, decorationpart (infsupdec (-1.0, 0.0, "def")){1})); %!test %! assert (isequal (sign (infsupdec (0.0, 2.0, "com")), infsupdec (0.0, 1.0, "def"))); %! assert (isequal (decorationpart (sign (infsupdec (0.0, 2.0, "com"))){1}, decorationpart (infsupdec (0.0, 1.0, "def")){1})); %!test %! assert (isequal (sign (infsupdec (-0.0, 2.0, "def")), infsupdec (0.0, 1.0, "def"))); %! assert (isequal (decorationpart (sign (infsupdec (-0.0, 2.0, "def"))){1}, decorationpart (infsupdec (0.0, 1.0, "def")){1})); %!test %! assert (isequal (sign (infsupdec (-5.0, -2.0, "trv")), infsupdec (-1.0, -1.0, "trv"))); %! assert (isequal (decorationpart (sign (infsupdec (-5.0, -2.0, "trv"))){1}, decorationpart (infsupdec (-1.0, -1.0, "trv")){1})); %!test %! assert (isequal (sign (infsupdec (0.0, 0.0, "dac")), infsupdec (0.0, 0.0, "dac"))); %! assert (isequal (decorationpart (sign (infsupdec (0.0, 0.0, "dac"))){1}, decorationpart (infsupdec (0.0, 0.0, "dac")){1})); ## minimal_ceil_test %!test %! assert (isequal (ceil (infsup), infsup)); %!test %! assert (isequal (ceil (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (ceil (infsup (1.1, 2.0)), infsup (2.0, 2.0))); %!test %! assert (isequal (ceil (infsup (-1.1, 2.0)), infsup (-1.0, 2.0))); %!test %! assert (isequal (ceil (infsup (-1.1, 0.0)), infsup (-1.0, 0.0))); %!test %! assert (isequal (ceil (infsup (-1.1, -0.0)), infsup (-1.0, 0.0))); %!test %! assert (isequal (ceil (infsup (-1.1, -0.4)), infsup (-1.0, 0.0))); %!test %! assert (isequal (ceil (infsup (-1.9, 2.2)), infsup (-1.0, 3.0))); %!test %! assert (isequal (ceil (infsup (-1.0, 2.2)), infsup (-1.0, 3.0))); %!test %! assert (isequal (ceil (infsup (0.0, 2.2)), infsup (0.0, 3.0))); %!test %! assert (isequal (ceil (infsup (-0.0, 2.2)), infsup (0.0, 3.0))); %!test %! assert (isequal (ceil (infsup (-1.5, inf)), infsup (-1.0, inf))); %!test %! assert (isequal (ceil (infsup (1.797693134862315708e+308, inf)), infsup (1.797693134862315708e+308, inf))); %!test %! assert (isequal (ceil (infsup (-inf, 2.2)), infsup (-inf, 3.0))); %!test %! assert (isequal (ceil (infsup (-inf, -1.797693134862315708e+308)), infsup (-inf, -1.797693134862315708e+308))); ## minimal_ceil_dec_test %!test %! assert (isequal (ceil (infsupdec (1.1, 2.0, "com")), infsupdec (2.0, 2.0, "dac"))); %! assert (isequal (decorationpart (ceil (infsupdec (1.1, 2.0, "com"))){1}, decorationpart (infsupdec (2.0, 2.0, "dac")){1})); %!test %! assert (isequal (ceil (infsupdec (-1.1, 2.0, "com")), infsupdec (-1.0, 2.0, "def"))); %! assert (isequal (decorationpart (ceil (infsupdec (-1.1, 2.0, "com"))){1}, decorationpart (infsupdec (-1.0, 2.0, "def")){1})); %!test %! assert (isequal (ceil (infsupdec (-1.1, 0.0, "dac")), infsupdec (-1.0, 0.0, "def"))); %! assert (isequal (decorationpart (ceil (infsupdec (-1.1, 0.0, "dac"))){1}, decorationpart (infsupdec (-1.0, 0.0, "def")){1})); %!test %! assert (isequal (ceil (infsupdec (-1.1, -0.0, "trv")), infsupdec (-1.0, 0.0, "trv"))); %! assert (isequal (decorationpart (ceil (infsupdec (-1.1, -0.0, "trv"))){1}, decorationpart (infsupdec (-1.0, 0.0, "trv")){1})); %!test %! assert (isequal (ceil (infsupdec (-1.1, -0.4, "dac")), infsupdec (-1.0, 0.0, "def"))); %! assert (isequal (decorationpart (ceil (infsupdec (-1.1, -0.4, "dac"))){1}, decorationpart (infsupdec (-1.0, 0.0, "def")){1})); %!test %! assert (isequal (ceil (infsupdec (-1.9, 2.2, "com")), infsupdec (-1.0, 3.0, "def"))); %! assert (isequal (decorationpart (ceil (infsupdec (-1.9, 2.2, "com"))){1}, decorationpart (infsupdec (-1.0, 3.0, "def")){1})); %!test %! assert (isequal (ceil (infsupdec (-1.0, 2.2, "dac")), infsupdec (-1.0, 3.0, "def"))); %! assert (isequal (decorationpart (ceil (infsupdec (-1.0, 2.2, "dac"))){1}, decorationpart (infsupdec (-1.0, 3.0, "def")){1})); %!test %! assert (isequal (ceil (infsupdec (0.0, 2.2, "trv")), infsupdec (0.0, 3.0, "trv"))); %! assert (isequal (decorationpart (ceil (infsupdec (0.0, 2.2, "trv"))){1}, decorationpart (infsupdec (0.0, 3.0, "trv")){1})); %!test %! assert (isequal (ceil (infsupdec (-0.0, 2.2, "def")), infsupdec (0.0, 3.0, "def"))); %! assert (isequal (decorationpart (ceil (infsupdec (-0.0, 2.2, "def"))){1}, decorationpart (infsupdec (0.0, 3.0, "def")){1})); %!test %! assert (isequal (ceil (infsupdec (-1.5, inf, "trv")), infsupdec (-1.0, inf, "trv"))); %! assert (isequal (decorationpart (ceil (infsupdec (-1.5, inf, "trv"))){1}, decorationpart (infsupdec (-1.0, inf, "trv")){1})); %!test %! assert (isequal (ceil (infsupdec (1.797693134862315708e+308, inf, "dac")), infsupdec (1.797693134862315708e+308, inf, "def"))); %! assert (isequal (decorationpart (ceil (infsupdec (1.797693134862315708e+308, inf, "dac"))){1}, decorationpart (infsupdec (1.797693134862315708e+308, inf, "def")){1})); %!test %! assert (isequal (ceil (infsupdec (1.797693134862315708e+308, 1.797693134862315708e+308, "com")), infsupdec (1.797693134862315708e+308, 1.797693134862315708e+308, "dac"))); %! assert (isequal (decorationpart (ceil (infsupdec (1.797693134862315708e+308, 1.797693134862315708e+308, "com"))){1}, decorationpart (infsupdec (1.797693134862315708e+308, 1.797693134862315708e+308, "dac")){1})); %!test %! assert (isequal (ceil (infsupdec (-inf, 2.2, "trv")), infsupdec (-inf, 3.0, "trv"))); %! assert (isequal (decorationpart (ceil (infsupdec (-inf, 2.2, "trv"))){1}, decorationpart (infsupdec (-inf, 3.0, "trv")){1})); %!test %! assert (isequal (ceil (infsupdec (-inf, -1.797693134862315708e+308, "dac")), infsupdec (-inf, -1.797693134862315708e+308, "def"))); %! assert (isequal (decorationpart (ceil (infsupdec (-inf, -1.797693134862315708e+308, "dac"))){1}, decorationpart (infsupdec (-inf, -1.797693134862315708e+308, "def")){1})); ## minimal_floor_test %!test %! assert (isequal (floor (infsup), infsup)); %!test %! assert (isequal (floor (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (floor (infsup (1.1, 2.0)), infsup (1.0, 2.0))); %!test %! assert (isequal (floor (infsup (-1.1, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (floor (infsup (-1.1, 0.0)), infsup (-2.0, 0.0))); %!test %! assert (isequal (floor (infsup (-1.1, -0.0)), infsup (-2.0, 0.0))); %!test %! assert (isequal (floor (infsup (-1.1, -0.4)), infsup (-2.0, -1.0))); %!test %! assert (isequal (floor (infsup (-1.9, 2.2)), infsup (-2.0, 2.0))); %!test %! assert (isequal (floor (infsup (-1.0, 2.2)), infsup (-1.0, 2.0))); %!test %! assert (isequal (floor (infsup (0.0, 2.2)), infsup (0.0, 2.0))); %!test %! assert (isequal (floor (infsup (-0.0, 2.2)), infsup (0.0, 2.0))); %!test %! assert (isequal (floor (infsup (-1.5, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (floor (infsup (-inf, 2.2)), infsup (-inf, 2.0))); ## minimal_floor_dec_test %!test %! assert (isequal (floor (infsupdec (1.1, 2.0, "com")), infsupdec (1.0, 2.0, "def"))); %! assert (isequal (decorationpart (floor (infsupdec (1.1, 2.0, "com"))){1}, decorationpart (infsupdec (1.0, 2.0, "def")){1})); %!test %! assert (isequal (floor (infsupdec (-1.1, 2.0, "def")), infsupdec (-2.0, 2.0, "def"))); %! assert (isequal (decorationpart (floor (infsupdec (-1.1, 2.0, "def"))){1}, decorationpart (infsupdec (-2.0, 2.0, "def")){1})); %!test %! assert (isequal (floor (infsupdec (-1.1, 0.0, "dac")), infsupdec (-2.0, 0.0, "def"))); %! assert (isequal (decorationpart (floor (infsupdec (-1.1, 0.0, "dac"))){1}, decorationpart (infsupdec (-2.0, 0.0, "def")){1})); %!test %! assert (isequal (floor (infsupdec (-1.2, -1.1, "com")), infsupdec (-2.0, -2.0, "com"))); %! assert (isequal (decorationpart (floor (infsupdec (-1.2, -1.1, "com"))){1}, decorationpart (infsupdec (-2.0, -2.0, "com")){1})); %!test %! assert (isequal (floor (infsupdec (-1.1, -0.4, "def")), infsupdec (-2.0, -1.0, "def"))); %! assert (isequal (decorationpart (floor (infsupdec (-1.1, -0.4, "def"))){1}, decorationpart (infsupdec (-2.0, -1.0, "def")){1})); %!test %! assert (isequal (floor (infsupdec (-1.9, 2.2, "com")), infsupdec (-2.0, 2.0, "def"))); %! assert (isequal (decorationpart (floor (infsupdec (-1.9, 2.2, "com"))){1}, decorationpart (infsupdec (-2.0, 2.0, "def")){1})); %!test %! assert (isequal (floor (infsupdec (-1.0, 2.2, "trv")), infsupdec (-1.0, 2.0, "trv"))); %! assert (isequal (decorationpart (floor (infsupdec (-1.0, 2.2, "trv"))){1}, decorationpart (infsupdec (-1.0, 2.0, "trv")){1})); %!test %! assert (isequal (floor (infsupdec (0.0, 2.2, "trv")), infsupdec (0.0, 2.0, "trv"))); %! assert (isequal (decorationpart (floor (infsupdec (0.0, 2.2, "trv"))){1}, decorationpart (infsupdec (0.0, 2.0, "trv")){1})); %!test %! assert (isequal (floor (infsupdec (-0.0, 2.2, "com")), infsupdec (0.0, 2.0, "def"))); %! assert (isequal (decorationpart (floor (infsupdec (-0.0, 2.2, "com"))){1}, decorationpart (infsupdec (0.0, 2.0, "def")){1})); %!test %! assert (isequal (floor (infsupdec (-1.5, inf, "dac")), infsupdec (-2.0, inf, "def"))); %! assert (isequal (decorationpart (floor (infsupdec (-1.5, inf, "dac"))){1}, decorationpart (infsupdec (-2.0, inf, "def")){1})); %!test %! assert (isequal (floor (infsupdec (-inf, 2.2, "trv")), infsupdec (-inf, 2.0, "trv"))); %! assert (isequal (decorationpart (floor (infsupdec (-inf, 2.2, "trv"))){1}, decorationpart (infsupdec (-inf, 2.0, "trv")){1})); ## minimal_trunc_test %!test %! assert (isequal (fix (infsup), infsup)); %!test %! assert (isequal (fix (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (fix (infsup (1.1, 2.1)), infsup (1.0, 2.0))); %!test %! assert (isequal (fix (infsup (-1.1, 2.0)), infsup (-1.0, 2.0))); %!test %! assert (isequal (fix (infsup (-1.1, 0.0)), infsup (-1.0, 0.0))); %!test %! assert (isequal (fix (infsup (-1.1, -0.0)), infsup (-1.0, 0.0))); %!test %! assert (isequal (fix (infsup (-1.1, -0.4)), infsup (-1.0, 0.0))); %!test %! assert (isequal (fix (infsup (-1.9, 2.2)), infsup (-1.0, 2.0))); %!test %! assert (isequal (fix (infsup (-1.0, 2.2)), infsup (-1.0, 2.0))); %!test %! assert (isequal (fix (infsup (0.0, 2.2)), infsup (0.0, 2.0))); %!test %! assert (isequal (fix (infsup (-0.0, 2.2)), infsup (0.0, 2.0))); %!test %! assert (isequal (fix (infsup (-1.5, inf)), infsup (-1.0, inf))); %!test %! assert (isequal (fix (infsup (-inf, 2.2)), infsup (-inf, 2.0))); ## minimal_trunc_dec_test %!test %! assert (isequal (fix (infsupdec (1.1, 2.1, "com")), infsupdec (1.0, 2.0, "def"))); %! assert (isequal (decorationpart (fix (infsupdec (1.1, 2.1, "com"))){1}, decorationpart (infsupdec (1.0, 2.0, "def")){1})); %!test %! assert (isequal (fix (infsupdec (1.1, 1.9, "com")), infsupdec (1.0, 1.0, "com"))); %! assert (isequal (decorationpart (fix (infsupdec (1.1, 1.9, "com"))){1}, decorationpart (infsupdec (1.0, 1.0, "com")){1})); %!test %! assert (isequal (fix (infsupdec (-1.1, 2.0, "dac")), infsupdec (-1.0, 2.0, "def"))); %! assert (isequal (decorationpart (fix (infsupdec (-1.1, 2.0, "dac"))){1}, decorationpart (infsupdec (-1.0, 2.0, "def")){1})); %!test %! assert (isequal (fix (infsupdec (-1.1, 0.0, "trv")), infsupdec (-1.0, 0.0, "trv"))); %! assert (isequal (decorationpart (fix (infsupdec (-1.1, 0.0, "trv"))){1}, decorationpart (infsupdec (-1.0, 0.0, "trv")){1})); %!test %! assert (isequal (fix (infsupdec (-1.1, -0.0, "def")), infsupdec (-1.0, 0.0, "def"))); %! assert (isequal (decorationpart (fix (infsupdec (-1.1, -0.0, "def"))){1}, decorationpart (infsupdec (-1.0, 0.0, "def")){1})); %!test %! assert (isequal (fix (infsupdec (-1.1, -0.4, "com")), infsupdec (-1.0, 0.0, "def"))); %! assert (isequal (decorationpart (fix (infsupdec (-1.1, -0.4, "com"))){1}, decorationpart (infsupdec (-1.0, 0.0, "def")){1})); %!test %! assert (isequal (fix (infsupdec (-1.9, 2.2, "def")), infsupdec (-1.0, 2.0, "def"))); %! assert (isequal (decorationpart (fix (infsupdec (-1.9, 2.2, "def"))){1}, decorationpart (infsupdec (-1.0, 2.0, "def")){1})); %!test %! assert (isequal (fix (infsupdec (-1.0, 2.2, "dac")), infsupdec (-1.0, 2.0, "def"))); %! assert (isequal (decorationpart (fix (infsupdec (-1.0, 2.2, "dac"))){1}, decorationpart (infsupdec (-1.0, 2.0, "def")){1})); %!test %! assert (isequal (fix (infsupdec (-1.5, inf, "dac")), infsupdec (-1.0, inf, "def"))); %! assert (isequal (decorationpart (fix (infsupdec (-1.5, inf, "dac"))){1}, decorationpart (infsupdec (-1.0, inf, "def")){1})); %!test %! assert (isequal (fix (infsupdec (-inf, 2.2, "trv")), infsupdec (-inf, 2.0, "trv"))); %! assert (isequal (decorationpart (fix (infsupdec (-inf, 2.2, "trv"))){1}, decorationpart (infsupdec (-inf, 2.0, "trv")){1})); ## minimal_roundTiesToEven_test %!test %! assert (isequal (roundb (infsup), infsup)); %!test %! assert (isequal (roundb (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (roundb (infsup (1.1, 2.1)), infsup (1.0, 2.0))); %!test %! assert (isequal (roundb (infsup (-1.1, 2.0)), infsup (-1.0, 2.0))); %!test %! assert (isequal (roundb (infsup (-1.1, -0.4)), infsup (-1.0, 0.0))); %!test %! assert (isequal (roundb (infsup (-1.1, 0.0)), infsup (-1.0, 0.0))); %!test %! assert (isequal (roundb (infsup (-1.1, -0.0)), infsup (-1.0, 0.0))); %!test %! assert (isequal (roundb (infsup (-1.9, 2.2)), infsup (-2.0, 2.0))); %!test %! assert (isequal (roundb (infsup (-1.0, 2.2)), infsup (-1.0, 2.0))); %!test %! assert (isequal (roundb (infsup (1.5, 2.1)), infsup (2.0, 2.0))); %!test %! assert (isequal (roundb (infsup (-1.5, 2.0)), infsup (-2.0, 2.0))); %!test %! assert (isequal (roundb (infsup (-1.1, -0.5)), infsup (-1.0, 0.0))); %!test %! assert (isequal (roundb (infsup (-1.9, 2.5)), infsup (-2.0, 2.0))); %!test %! assert (isequal (roundb (infsup (0.0, 2.5)), infsup (0.0, 2.0))); %!test %! assert (isequal (roundb (infsup (-0.0, 2.5)), infsup (0.0, 2.0))); %!test %! assert (isequal (roundb (infsup (-1.5, 2.5)), infsup (-2.0, 2.0))); %!test %! assert (isequal (roundb (infsup (-1.5, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (roundb (infsup (-inf, 2.2)), infsup (-inf, 2.0))); ## minimal_roundTiesToEven_dec_test %!test %! assert (isequal (roundb (infsupdec (1.1, 2.1, "com")), infsupdec (1.0, 2.0, "def"))); %! assert (isequal (decorationpart (roundb (infsupdec (1.1, 2.1, "com"))){1}, decorationpart (infsupdec (1.0, 2.0, "def")){1})); %!test %! assert (isequal (roundb (infsupdec (-1.1, 2.0, "trv")), infsupdec (-1.0, 2.0, "trv"))); %! assert (isequal (decorationpart (roundb (infsupdec (-1.1, 2.0, "trv"))){1}, decorationpart (infsupdec (-1.0, 2.0, "trv")){1})); %!test %! assert (isequal (roundb (infsupdec (-1.6, -1.5, "com")), infsupdec (-2.0, -2.0, "dac"))); %! assert (isequal (decorationpart (roundb (infsupdec (-1.6, -1.5, "com"))){1}, decorationpart (infsupdec (-2.0, -2.0, "dac")){1})); %!test %! assert (isequal (roundb (infsupdec (-1.6, -1.4, "com")), infsupdec (-2.0, -1.0, "def"))); %! assert (isequal (decorationpart (roundb (infsupdec (-1.6, -1.4, "com"))){1}, decorationpart (infsupdec (-2.0, -1.0, "def")){1})); %!test %! assert (isequal (roundb (infsupdec (-1.5, inf, "dac")), infsupdec (-2.0, inf, "def"))); %! assert (isequal (decorationpart (roundb (infsupdec (-1.5, inf, "dac"))){1}, decorationpart (infsupdec (-2.0, inf, "def")){1})); %!test %! assert (isequal (roundb (infsupdec (-inf, 2.2, "trv")), infsupdec (-inf, 2.0, "trv"))); %! assert (isequal (decorationpart (roundb (infsupdec (-inf, 2.2, "trv"))){1}, decorationpart (infsupdec (-inf, 2.0, "trv")){1})); ## minimal_roundTiesToAway_test %!test %! assert (isequal (round (infsup), infsup)); %!test %! assert (isequal (round (infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (round (infsup (1.1, 2.1)), infsup (1.0, 2.0))); %!test %! assert (isequal (round (infsup (-1.1, 2.0)), infsup (-1.0, 2.0))); %!test %! assert (isequal (round (infsup (-1.1, 0.0)), infsup (-1.0, 0.0))); %!test %! assert (isequal (round (infsup (-1.1, -0.0)), infsup (-1.0, -0.0))); %!test %! assert (isequal (round (infsup (-1.1, -0.4)), infsup (-1.0, 0.0))); %!test %! assert (isequal (round (infsup (-1.9, 2.2)), infsup (-2.0, 2.0))); %!test %! assert (isequal (round (infsup (-1.0, 2.2)), infsup (-1.0, 2.0))); %!test %! assert (isequal (round (infsup (0.5, 2.1)), infsup (1.0, 2.0))); %!test %! assert (isequal (round (infsup (-2.5, 2.0)), infsup (-3.0, 2.0))); %!test %! assert (isequal (round (infsup (-1.1, -0.5)), infsup (-1.0, -1.0))); %!test %! assert (isequal (round (infsup (-1.9, 2.5)), infsup (-2.0, 3.0))); %!test %! assert (isequal (round (infsup (-1.5, 2.5)), infsup (-2.0, 3.0))); %!test %! assert (isequal (round (infsup (0.0, 2.5)), infsup (0.0, 3.0))); %!test %! assert (isequal (round (infsup (-0.0, 2.5)), infsup (0.0, 3.0))); %!test %! assert (isequal (round (infsup (-1.5, inf)), infsup (-2.0, inf))); %!test %! assert (isequal (round (infsup (-inf, 2.2)), infsup (-inf, 2.0))); ## minimal_roundTiesToAway_dec_test %!test %! assert (isequal (round (infsupdec (1.1, 2.1, "com")), infsupdec (1.0, 2.0, "def"))); %! assert (isequal (decorationpart (round (infsupdec (1.1, 2.1, "com"))){1}, decorationpart (infsupdec (1.0, 2.0, "def")){1})); %!test %! assert (isequal (round (infsupdec (-1.9, 2.2, "com")), infsupdec (-2.0, 2.0, "def"))); %! assert (isequal (decorationpart (round (infsupdec (-1.9, 2.2, "com"))){1}, decorationpart (infsupdec (-2.0, 2.0, "def")){1})); %!test %! assert (isequal (round (infsupdec (1.9, 2.2, "com")), infsupdec (2.0, 2.0, "com"))); %! assert (isequal (decorationpart (round (infsupdec (1.9, 2.2, "com"))){1}, decorationpart (infsupdec (2.0, 2.0, "com")){1})); %!test %! assert (isequal (round (infsupdec (-1.0, 2.2, "trv")), infsupdec (-1.0, 2.0, "trv"))); %! assert (isequal (decorationpart (round (infsupdec (-1.0, 2.2, "trv"))){1}, decorationpart (infsupdec (-1.0, 2.0, "trv")){1})); %!test %! assert (isequal (round (infsupdec (2.5, 2.6, "com")), infsupdec (3.0, 3.0, "dac"))); %! assert (isequal (decorationpart (round (infsupdec (2.5, 2.6, "com"))){1}, decorationpart (infsupdec (3.0, 3.0, "dac")){1})); %!test %! assert (isequal (round (infsupdec (-1.5, inf, "dac")), infsupdec (-2.0, inf, "def"))); %! assert (isequal (decorationpart (round (infsupdec (-1.5, inf, "dac"))){1}, decorationpart (infsupdec (-2.0, inf, "def")){1})); %!test %! assert (isequal (round (infsupdec (-inf, 2.2, "def")), infsupdec (-inf, 2.0, "def"))); %! assert (isequal (decorationpart (round (infsupdec (-inf, 2.2, "def"))){1}, decorationpart (infsupdec (-inf, 2.0, "def")){1})); ## minimal_abs_test %!test %! assert (isequal (abs (infsup), infsup)); %!test %! assert (isequal (abs (infsup (-inf, inf)), infsup (0.0, inf))); %!test %! assert (isequal (abs (infsup (1.1, 2.1)), infsup (1.1, 2.1))); %!test %! assert (isequal (abs (infsup (-1.1, 2.0)), infsup (0.0, 2.0))); %!test %! assert (isequal (abs (infsup (-1.1, 0.0)), infsup (0.0, 1.1))); %!test %! assert (isequal (abs (infsup (-1.1, -0.0)), infsup (0.0, 1.1))); %!test %! assert (isequal (abs (infsup (-1.1, -0.4)), infsup (0.4, 1.1))); %!test %! assert (isequal (abs (infsup (-1.9, 0.2)), infsup (0.0, 1.9))); %!test %! assert (isequal (abs (infsup (0.0, 0.2)), infsup (0.0, 0.2))); %!test %! assert (isequal (abs (infsup (-0.0, 0.2)), infsup (0.0, 0.2))); %!test %! assert (isequal (abs (infsup (-1.5, inf)), infsup (0.0, inf))); %!test %! assert (isequal (abs (infsup (-inf, -2.2)), infsup (2.2, inf))); ## minimal_abs_dec_test %!test %! assert (isequal (abs (infsupdec (-1.1, 2.0, "com")), infsupdec (0.0, 2.0, "com"))); %! assert (isequal (decorationpart (abs (infsupdec (-1.1, 2.0, "com"))){1}, decorationpart (infsupdec (0.0, 2.0, "com")){1})); %!test %! assert (isequal (abs (infsupdec (-1.1, 0.0, "dac")), infsupdec (0.0, 1.1, "dac"))); %! assert (isequal (decorationpart (abs (infsupdec (-1.1, 0.0, "dac"))){1}, decorationpart (infsupdec (0.0, 1.1, "dac")){1})); %!test %! assert (isequal (abs (infsupdec (-1.1, -0.0, "def")), infsupdec (0.0, 1.1, "def"))); %! assert (isequal (decorationpart (abs (infsupdec (-1.1, -0.0, "def"))){1}, decorationpart (infsupdec (0.0, 1.1, "def")){1})); %!test %! assert (isequal (abs (infsupdec (-1.1, -0.4, "trv")), infsupdec (0.4, 1.1, "trv"))); %! assert (isequal (decorationpart (abs (infsupdec (-1.1, -0.4, "trv"))){1}, decorationpart (infsupdec (0.4, 1.1, "trv")){1})); %!test %! assert (isequal (abs (infsupdec (-1.9, 0.2, "dac")), infsupdec (0.0, 1.9, "dac"))); %! assert (isequal (decorationpart (abs (infsupdec (-1.9, 0.2, "dac"))){1}, decorationpart (infsupdec (0.0, 1.9, "dac")){1})); %!test %! assert (isequal (abs (infsupdec (0.0, 0.2, "def")), infsupdec (0.0, 0.2, "def"))); %! assert (isequal (decorationpart (abs (infsupdec (0.0, 0.2, "def"))){1}, decorationpart (infsupdec (0.0, 0.2, "def")){1})); %!test %! assert (isequal (abs (infsupdec (-0.0, 0.2, "com")), infsupdec (0.0, 0.2, "com"))); %! assert (isequal (decorationpart (abs (infsupdec (-0.0, 0.2, "com"))){1}, decorationpart (infsupdec (0.0, 0.2, "com")){1})); %!test %! assert (isequal (abs (infsupdec (-1.5, inf, "dac")), infsupdec (0.0, inf, "dac"))); %! assert (isequal (decorationpart (abs (infsupdec (-1.5, inf, "dac"))){1}, decorationpart (infsupdec (0.0, inf, "dac")){1})); ## minimal_min_test %!test %! assert (isequal (min (infsup, infsup (1.0, 2.0)), infsup)); %!test %! assert (isequal (min (infsup (1.0, 2.0), infsup), infsup)); %!test %! assert (isequal (min (infsup, infsup), infsup)); %!test %! assert (isequal (min (infsup (-inf, inf), infsup (1.0, 2.0)), infsup (-inf, 2.0))); %!test %! assert (isequal (min (infsup (1.0, 2.0), infsup (-inf, inf)), infsup (-inf, 2.0))); %!test %! assert (isequal (min (infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (min (infsup, infsup (-inf, inf)), infsup)); %!test %! assert (isequal (min (infsup (1.0, 5.0), infsup (2.0, 4.0)), infsup (1.0, 4.0))); %!test %! assert (isequal (min (infsup (0.0, 5.0), infsup (2.0, 4.0)), infsup (0.0, 4.0))); %!test %! assert (isequal (min (infsup (-0.0, 5.0), infsup (2.0, 4.0)), infsup (0.0, 4.0))); %!test %! assert (isequal (min (infsup (1.0, 5.0), infsup (2.0, 8.0)), infsup (1.0, 5.0))); %!test %! assert (isequal (min (infsup (1.0, 5.0), infsup (-inf, inf)), infsup (-inf, 5.0))); %!test %! assert (isequal (min (infsup (-7.0, -5.0), infsup (2.0, 4.0)), infsup (-7.0, -5.0))); %!test %! assert (isequal (min (infsup (-7.0, 0.0), infsup (2.0, 4.0)), infsup (-7.0, 0.0))); %!test %! assert (isequal (min (infsup (-7.0, -0.0), infsup (2.0, 4.0)), infsup (-7.0, 0.0))); ## minimal_min_dec_test %!test %! assert (isequal (min (infsupdec (entire, "def"), infsupdec (1.0, 2.0, "com")), infsupdec (-inf, 2.0, "def"))); %! assert (isequal (decorationpart (min (infsupdec (entire, "def"), infsupdec (1.0, 2.0, "com"))){1}, decorationpart (infsupdec (-inf, 2.0, "def")){1})); %!test %! assert (isequal (min (infsupdec (-7.0, -5.0, "trv"), infsupdec (2.0, 4.0, "def")), infsupdec (-7.0, -5.0, "trv"))); %! assert (isequal (decorationpart (min (infsupdec (-7.0, -5.0, "trv"), infsupdec (2.0, 4.0, "def"))){1}, decorationpart (infsupdec (-7.0, -5.0, "trv")){1})); %!test %! assert (isequal (min (infsupdec (-7.0, 0.0, "dac"), infsupdec (2.0, 4.0, "def")), infsupdec (-7.0, 0.0, "def"))); %! assert (isequal (decorationpart (min (infsupdec (-7.0, 0.0, "dac"), infsupdec (2.0, 4.0, "def"))){1}, decorationpart (infsupdec (-7.0, 0.0, "def")){1})); %!test %! assert (isequal (min (infsupdec (-7.0, -0.0, "com"), infsupdec (2.0, 4.0, "com")), infsupdec (-7.0, 0.0, "com"))); %! assert (isequal (decorationpart (min (infsupdec (-7.0, -0.0, "com"), infsupdec (2.0, 4.0, "com"))){1}, decorationpart (infsupdec (-7.0, 0.0, "com")){1})); ## minimal_max_test %!test %! assert (isequal (max (infsup, infsup (1.0, 2.0)), infsup)); %!test %! assert (isequal (max (infsup (1.0, 2.0), infsup), infsup)); %!test %! assert (isequal (max (infsup, infsup), infsup)); %!test %! assert (isequal (max (infsup (-inf, inf), infsup (1.0, 2.0)), infsup (1.0, inf))); %!test %! assert (isequal (max (infsup (1.0, 2.0), infsup (-inf, inf)), infsup (1.0, inf))); %!test %! assert (isequal (max (infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (max (infsup, infsup (-inf, inf)), infsup)); %!test %! assert (isequal (max (infsup (1.0, 5.0), infsup (2.0, 4.0)), infsup (2.0, 5.0))); %!test %! assert (isequal (max (infsup (1.0, 5.0), infsup (2.0, 8.0)), infsup (2.0, 8.0))); %!test %! assert (isequal (max (infsup (-1.0, 5.0), infsup (-inf, inf)), infsup (-1.0, inf))); %!test %! assert (isequal (max (infsup (-7.0, -5.0), infsup (2.0, 4.0)), infsup (2.0, 4.0))); %!test %! assert (isequal (max (infsup (-7.0, -5.0), infsup (0.0, 4.0)), infsup (0.0, 4.0))); %!test %! assert (isequal (max (infsup (-7.0, -5.0), infsup (-0.0, 4.0)), infsup (0.0, 4.0))); %!test %! assert (isequal (max (infsup (-7.0, -5.0), infsup (-2.0, 0.0)), infsup (-2.0, 0.0))); %!test %! assert (isequal (max (infsup (-7.0, -5.0), infsup (-2.0, -0.0)), infsup (-2.0, 0.0))); ## minimal_max_dec_test %!test %! assert (isequal (max (infsupdec (entire, "def"), infsupdec (1.0, 2.0, "com")), infsupdec (1.0, inf, "def"))); %! assert (isequal (decorationpart (max (infsupdec (entire, "def"), infsupdec (1.0, 2.0, "com"))){1}, decorationpart (infsupdec (1.0, inf, "def")){1})); %!test %! assert (isequal (max (infsupdec (-7.0, -5.0, "trv"), infsupdec (2.0, 4.0, "def")), infsupdec (2.0, 4.0, "trv"))); %! assert (isequal (decorationpart (max (infsupdec (-7.0, -5.0, "trv"), infsupdec (2.0, 4.0, "def"))){1}, decorationpart (infsupdec (2.0, 4.0, "trv")){1})); %!test %! assert (isequal (max (infsupdec (-7.0, 5.0, "dac"), infsupdec (2.0, 4.0, "def")), infsupdec (2.0, 5.0, "def"))); %! assert (isequal (decorationpart (max (infsupdec (-7.0, 5.0, "dac"), infsupdec (2.0, 4.0, "def"))){1}, decorationpart (infsupdec (2.0, 5.0, "def")){1})); %!test %! assert (isequal (max (infsupdec (3.0, 3.5, "com"), infsupdec (2.0, 4.0, "com")), infsupdec (3.0, 4.0, "com"))); %! assert (isequal (decorationpart (max (infsupdec (3.0, 3.5, "com"), infsupdec (2.0, 4.0, "com"))){1}, decorationpart (infsupdec (3.0, 4.0, "com")){1})); interval-1.4.1/inst/test/abs_rev.tst0000644000175000017500000001003712657476055017056 0ustar oliveroliver## DO NOT EDIT! Generated automatically from test/abs_rev.itl ## by the Interval Testing Framework for IEEE 1788. ## https://github.com/nehmeier/ITF1788/tree/635bff73cc64ff8aab0ff2031ee8a53980be0115 ## ## Copyright 2015-2016 Oliver Heimlich ## ## This program is free software; you can redistribute it and/or modify ## it under the terms of the GNU General Public License as published by ## the Free Software Foundation; either version 3 of the License, or ## (at your option) any later version. ## ## This program is distributed in the hope that it will be useful, ## but WITHOUT ANY WARRANTY; without even the implied warranty of ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, see . ## %!#Test library imports %!#Arithmetic library imports pkg load interval %!#Preamble try; error ("__FILE__"); catch test (lasterror.stack.file, "quiet", stdout); end_try_catch; %!function assert_warn (observed_value, expected_value) %! if (not (isequal (observed_value, expected_value))) %! observed_expression = regexprep (argn(1, :), '\s+$', ''); %! expected_expression = regexprep (argn(2, :), '\s+$', ''); %! observed_as_char = disp (observed_value)(1 : end - 1); %! expected_as_char = disp(expected_value)(1 : end - 1); %! warning ([observed_expression, " != ", expected_expression, ... %! "\n ", observed_as_char, " != ", expected_as_char]); %! endif %!endfunction ## minimal.absRevBin_test %!test %! assert (isequal (absrev (infsup, infsup (-inf, inf)), infsup)); %!test %! assert (isequal (absrev (infsup (0.0, 1.0), infsup), infsup)); %!test %! assert (isequal (absrev (infsup (0.0, 1.0), infsup (7.0, 9.0)), infsup)); %!test %! assert (isequal (absrev (infsup, infsup (0.0, 1.0)), infsup)); %!test %! assert (isequal (absrev (infsup (-2.0, -1.0), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (absrev (infsup (1.0, 1.0), infsup (-inf, inf)), infsup (-1.0, 1.0))); %!test %! assert (isequal (absrev (infsup (0.0, 0.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (absrev (infsup (-1.0, -1.0), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (absrev (infsup (1.797693134862315708e+308, 1.797693134862315708e+308), infsup (-inf, inf)), infsup (-1.797693134862315708e+308, 1.797693134862315708e+308))); %!test %! assert (isequal (absrev (infsup (2.225073858507201383e-308, 2.225073858507201383e-308), infsup (-inf, inf)), infsup (-2.225073858507201383e-308, 2.225073858507201383e-308))); %!test %! assert (isequal (absrev (infsup (-2.225073858507201383e-308, -2.225073858507201383e-308), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (absrev (infsup (-1.797693134862315708e+308, -1.797693134862315708e+308), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (absrev (infsup (1.0, 2.0), infsup (-inf, inf)), infsup (-2.0, 2.0))); %!test %! assert (isequal (absrev (infsup (1.0, 2.0), infsup (0.0, 2.0)), infsup (1.0, 2.0))); %!test %! assert (isequal (absrev (infsup (0.0, 1.0), infsup (-0.5, 2.0)), infsup (-0.5, 1.0))); %!test %! assert (isequal (absrev (infsup (-1.0, 1.0), infsup (-inf, inf)), infsup (-1.0, 1.0))); %!test %! assert (isequal (absrev (infsup (-1.0, 0.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (absrev (infsup (0.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (absrev (infsup (-inf, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (absrev (infsup (-inf, 0.0), infsup (-inf, inf)), infsup (0.0, 0.0))); %!test %! assert (isequal (absrev (infsup (1.0, inf), infsup (-inf, 0.0)), infsup (-inf, -1.0))); %!test %! assert (isequal (absrev (infsup (-1.0, inf), infsup (-inf, inf)), infsup (-inf, inf))); %!test %! assert (isequal (absrev (infsup (-inf, -1.0), infsup (-inf, inf)), infsup)); %!test %! assert (isequal (absrev (infsup (-inf, 1.0), infsup (-inf, inf)), infsup (-1.0, 1.0)));