Movatterモバイル変換

{-# LANGUAGE Trustworthy #-}{-# LANGUAGE CPP           , NoImplicitPrelude           , MagicHash           , UnboxedTuples           , ForeignFunctionInterface  #-}-- We believe we could deorphan this module, by moving lots of things-- around, but we haven't got there yet:{-# OPTIONS_GHC -fno-warn-orphans #-}{-# OPTIONS_HADDOCK hide #-}------------------------------------------------------------------------------- |-- Module      :  GHC.Float-- Copyright   :  (c) The University of Glasgow 1994-2002-- License     :  see libraries/base/LICENSE---- Maintainer  :  cvs-ghc@haskell.org-- Stability   :  internal-- Portability :  non-portable (GHC Extensions)---- The types 'Float' and 'Double', and the classes 'Floating' and 'RealFloat'.-------------------------------------------------------------------------------#include "ieee-flpt.h"-- #hidemoduleGHC.Float(moduleGHC.Float,Float(..),Double(..),Float#,Double#,double2Int,int2Double,float2Int,int2Float)whereimportData.MaybeimportData.BitsimportGHC.BaseimportGHC.ListimportGHC.EnumimportGHC.ShowimportGHC.NumimportGHC.RealimportGHC.ArrimportGHC.Float.RealFracMethodsimportGHC.Float.ConversionUtilsimportGHC.Integer.Logarithms(integerLogBase#)importGHC.Integer.Logarithms.Internalsinfixr8**

-- | Trigonometric and hyperbolic functions and related functions.---- Minimal complete definition:--      'pi', 'exp', 'log', 'sin', 'cos', 'sinh', 'cosh',--      'asin', 'acos', 'atan', 'asinh', 'acosh' and 'atanh'class(Fractionala)=>Floatingawherepi::aexp,log,sqrt::a->a(**),logBase::a->a->asin,cos,tan::a->aasin,acos,atan::a->asinh,cosh,tanh::a->aasinh,acosh,atanh::a->a{-# INLINE (**) #-}{-# INLINE logBase #-}{-# INLINE sqrt #-}{-# INLINE tan #-}{-# INLINE tanh #-}x**y=exp(logx*y)logBasexy=logy/logxsqrtx=x**0.5tanx=sinx/cosxtanhx=sinhx/coshx-- | Efficient, machine-independent access to the components of a-- floating-point number.---- Minimal complete definition:--      all except 'exponent', 'significand', 'scaleFloat' and 'atan2'class(RealFraca,Floatinga)=>RealFloatawhere-- | a constant function, returning the radix of the representation-- (often @2@)floatRadix::a->Integer-- | a constant function, returning the number of digits of-- 'floatRadix' in the significandfloatDigits::a->Int-- | a constant function, returning the lowest and highest values-- the exponent may assumefloatRange::a->(Int,Int)-- | The function 'decodeFloat' applied to a real floating-point-- number returns the significand expressed as an 'Integer' and an-- appropriately scaled exponent (an 'Int').  If @'decodeFloat' x@-- yields @(m,n)@, then @x@ is equal in value to @m*b^^n@, where @b@-- is the floating-point radix, and furthermore, either @m@ and @n@-- are both zero or else @b^(d-1) <= m < b^d@, where @d@ is the value-- of @'floatDigits' x@.  In particular, @'decodeFloat' 0 = (0,0)@.decodeFloat::a->(Integer,Int)-- | 'encodeFloat' performs the inverse of 'decodeFloat'encodeFloat::Integer->Int->a-- | the second component of 'decodeFloat'.exponent::a->Int-- | the first component of 'decodeFloat', scaled to lie in the open-- interval (@-1@,@1@)significand::a->a-- | multiplies a floating-point number by an integer power of the radixscaleFloat::Int->a->a-- | 'True' if the argument is an IEEE \"not-a-number\" (NaN) valueisNaN::a->Bool-- | 'True' if the argument is an IEEE infinity or negative infinityisInfinite::a->Bool-- | 'True' if the argument is too small to be represented in-- normalized formatisDenormalized::a->Bool-- | 'True' if the argument is an IEEE negative zeroisNegativeZero::a->Bool-- | 'True' if the argument is an IEEE floating point numberisIEEE::a->Bool-- | a version of arctangent taking two real floating-point arguments.-- For real floating @x@ and @y@, @'atan2' y x@ computes the angle-- (from the positive x-axis) of the vector from the origin to the-- point @(x,y)@.  @'atan2' y x@ returns a value in the range [@-pi@,-- @pi@].  It follows the Common Lisp semantics for the origin when-- signed zeroes are supported.  @'atan2' y 1@, with @y@ in a type-- that is 'RealFloat', should return the same value as @'atan' y@.-- A default definition of 'atan2' is provided, but implementors-- can provide a more accurate implementation.atan2::a->a->aexponentx=ifm==0then0elsen+floatDigitsxwhere(m,n)=decodeFloatxsignificandx=encodeFloatm(negate(floatDigitsx))where(m,_)=decodeFloatxscaleFloatkx=encodeFloatm(n+clampbk)where(m,n)=decodeFloatx(l,h)=floatRangexd=floatDigitsxb=h-l+4*d-- n+k may overflow, which would lead-- to wrong results, hence we clamp the-- scaling parameter.-- If n + k would be larger than h,-- n + clamp b k must be too, simliar-- for smaller than l - d.-- Add a little extra to keep clear-- from the boundary cases.atan2yx|x>0=atan(y/x)|x==0&&y>0=pi/2|x<0&&y>0=pi+atan(y/x)|(x<=0&&y<0)||(x<0&&isNegativeZeroy)||(isNegativeZerox&&isNegativeZeroy)=-atan2(-y)x|y==0&&(x<0||isNegativeZerox)=pi-- must be after the previous test on zero y|x==0&&y==0=y-- must be after the other double zero tests|otherwise=x+y-- x or y is a NaN, return a NaN (via +)

instanceNumFloatwhere(+)xy=plusFloatxy(-)xy=minusFloatxynegatex=negateFloatx(*)xy=timesFloatxyabsx|x>=0.0=x|otherwise=negateFloatxsignumx|x==0.0=0|x>0.0=1|otherwise=negate1{-# INLINE fromInteger #-}fromIntegeri=F#(floatFromIntegeri)instanceRealFloatwheretoRational(F#x#)=casedecodeFloat_Int#x#of(#m#,e##)|e#>=#0#->(smallIntegerm#`shiftLInteger`e#):%1|(int2Word#m#`and#`1##)`eqWord#`0##->caseelimZerosInt#m#(negateInt#e#)of(#n,d##)->n:%shiftLInteger1d#|otherwise->smallIntegerm#:%shiftLInteger1(negateInt#e#)instanceFractionalFloatwhere(/)xy=divideFloatxyfromRational(n:%0)|n==0=0/0|n<0=(-1)/0|otherwise=1/0fromRational(n:%d)|n==0=encodeFloat00|n<0=-(fromRat''minExmantDigs(-n)d)|otherwise=fromRat''minExmantDigsndwhereminEx=FLT_MIN_EXPmantDigs=FLT_MANT_DIGrecipx=1.0/x-- RULES for Integer and Int{-# RULES"properFraction/Float->Integer"     properFraction = properFractionFloatInteger"truncate/Float->Integer"           truncate = truncateFloatInteger"floor/Float->Integer"              floor = floorFloatInteger"ceiling/Float->Integer"            ceiling = ceilingFloatInteger"round/Float->Integer"              round = roundFloatInteger"properFraction/Float->Int"         properFraction = properFractionFloatInt"truncate/Float->Int"               truncate = float2Int"floor/Float->Int"                  floor = floorFloatInt"ceiling/Float->Int"                ceiling = ceilingFloatInt"round/Float->Int"                  round = roundFloatInt  #-}instanceRealFracFloatwhere-- ceiling, floor, and truncate are all small{-# INLINE [1] ceiling #-}{-# INLINE [1] floor #-}{-# INLINE [1] truncate #-}-- We assume that FLT_RADIX is 2 so that we can use more efficient code#if FLT_RADIX != 2#error FLT_RADIX must be 2#endifproperFraction(F#x#)=casedecodeFloat_Int#x#of(#m#,n##)->letm=I#m#n=I#n#inifn>=0then(fromIntegralm*(2^n),0.0)elseleti=ifm>=0thenm`shiftR`negatenelsenegate(negatem`shiftR`negaten)f=m-(i`shiftL`negaten)in(fromIntegrali,encodeFloat(fromIntegralf)n)truncatex=caseproperFractionxof(n,_)->nroundx=caseproperFractionxof(n,r)->letm=ifr<0.0thenn-1elsen+1half_down=absr-0.5incase(comparehalf_down0.0)ofLT->nEQ->ifevennthennelsemGT->mceilingx=caseproperFractionxof(n,r)->ifr>0.0thenn+1elsenfloorx=caseproperFractionxof(n,r)->ifr<0.0thenn-1elseninstanceFloatingFloatwherepi=3.141592653589793238expx=expFloatxlogx=logFloatxsqrtx=sqrtFloatxsinx=sinFloatxcosx=cosFloatxtanx=tanFloatxasinx=asinFloatxacosx=acosFloatxatanx=atanFloatxsinhx=sinhFloatxcoshx=coshFloatxtanhx=tanhFloatx(**)xy=powerFloatxylogBasexy=logy/logxasinhx=log(x+sqrt(1.0+x*x))acoshx=log(x+(x+1.0)*sqrt((x-1.0)/(x+1.0)))atanhx=0.5*log((1.0+x)/(1.0-x))instanceRealFloatFloatwherefloatRadix_=FLT_RADIX-- from float.hfloatDigits_=FLT_MANT_DIG-- dittofloatRange_=(FLT_MIN_EXP,FLT_MAX_EXP)-- dittodecodeFloat(F#f#)=casedecodeFloat_Int#f#of(#i,e#)->(smallIntegeri,I#e)encodeFloati(I#e)=F#(encodeFloatIntegerie)exponentx=casedecodeFloatxof(m,n)->ifm==0then0elsen+floatDigitsxsignificandx=casedecodeFloatxof(m,_)->encodeFloatm(negate(floatDigitsx))scaleFloatkx=casedecodeFloatxof(m,n)->encodeFloatm(n+clampbfk)wherebf=FLT_MAX_EXP-(FLT_MIN_EXP)+4*FLT_MANT_DIGisNaNx=0/=isFloatNaNxisInfinitex=0/=isFloatInfinitexisDenormalizedx=0/=isFloatDenormalizedxisNegativeZerox=0/=isFloatNegativeZeroxisIEEE_=TrueinstanceShowFloatwhereshowsPrecx=showSignedFloatshowFloatxshowList=showList__(showsPrec0)

instanceNumDoublewhere(+)xy=plusDoublexy(-)xy=minusDoublexynegatex=negateDoublex(*)xy=timesDoublexyabsx|x>=0.0=x|otherwise=negateDoublexsignumx|x==0.0=0|x>0.0=1|otherwise=negate1{-# INLINE fromInteger #-}fromIntegeri=D#(doubleFromIntegeri)instanceRealDoublewheretoRational(D#x#)=casedecodeDoubleIntegerx#of(#m,e##)|e#>=#0#->shiftLIntegerme#:%1|(int2Word#(integerToIntm)`and#`1##)`eqWord#`0##->caseelimZerosIntegerm(negateInt#e#)of(#n,d##)->n:%shiftLInteger1d#|otherwise->m:%shiftLInteger1(negateInt#e#)instanceFractionalDoublewhere(/)xy=divideDoublexyfromRational(n:%0)|n==0=0/0|n<0=(-1)/0|otherwise=1/0fromRational(n:%d)|n==0=encodeFloat00|n<0=-(fromRat''minExmantDigs(-n)d)|otherwise=fromRat''minExmantDigsndwhereminEx=DBL_MIN_EXPmantDigs=DBL_MANT_DIGrecipx=1.0/xinstanceFloatingDoublewherepi=3.141592653589793238expx=expDoublexlogx=logDoublexsqrtx=sqrtDoublexsinx=sinDoublexcosx=cosDoublextanx=tanDoublexasinx=asinDoublexacosx=acosDoublexatanx=atanDoublexsinhx=sinhDoublexcoshx=coshDoublextanhx=tanhDoublex(**)xy=powerDoublexylogBasexy=logy/logxasinhx=log(x+sqrt(1.0+x*x))acoshx=log(x+(x+1.0)*sqrt((x-1.0)/(x+1.0)))atanhx=0.5*log((1.0+x)/(1.0-x))-- RULES for Integer and Int{-# RULES"properFraction/Double->Integer"    properFraction = properFractionDoubleInteger"truncate/Double->Integer"          truncate = truncateDoubleInteger"floor/Double->Integer"             floor = floorDoubleInteger"ceiling/Double->Integer"           ceiling = ceilingDoubleInteger"round/Double->Integer"             round = roundDoubleInteger"properFraction/Double->Int"        properFraction = properFractionDoubleInt"truncate/Double->Int"              truncate = double2Int"floor/Double->Int"                 floor = floorDoubleInt"ceiling/Double->Int"               ceiling = ceilingDoubleInt"round/Double->Int"                 round = roundDoubleInt  #-}instanceRealFracDoublewhere-- ceiling, floor, and truncate are all small{-# INLINE [1] ceiling #-}{-# INLINE [1] floor #-}{-# INLINE [1] truncate #-}properFractionx=case(decodeFloatx)of{(m,n)->ifn>=0then(fromIntegerm*2^n,0.0)elsecase(quotRemm(2^(negaten)))of{(w,r)->(fromIntegerw,encodeFloatrn)}}truncatex=caseproperFractionxof(n,_)->nroundx=caseproperFractionxof(n,r)->letm=ifr<0.0thenn-1elsen+1half_down=absr-0.5incase(comparehalf_down0.0)ofLT->nEQ->ifevennthennelsemGT->mceilingx=caseproperFractionxof(n,r)->ifr>0.0thenn+1elsenfloorx=caseproperFractionxof(n,r)->ifr<0.0thenn-1elseninstanceRealFloatDoublewherefloatRadix_=FLT_RADIX-- from float.hfloatDigits_=DBL_MANT_DIG-- dittofloatRange_=(DBL_MIN_EXP,DBL_MAX_EXP)-- dittodecodeFloat(D#x#)=casedecodeDoubleIntegerx#of(#i,j#)->(i,I#j)encodeFloati(I#j)=D#(encodeDoubleIntegerij)exponentx=casedecodeFloatxof(m,n)->ifm==0then0elsen+floatDigitsxsignificandx=casedecodeFloatxof(m,_)->encodeFloatm(negate(floatDigitsx))scaleFloatkx=casedecodeFloatxof(m,n)->encodeFloatm(n+clampbdk)wherebd=DBL_MAX_EXP-(DBL_MIN_EXP)+4*DBL_MANT_DIGisNaNx=0/=isDoubleNaNxisInfinitex=0/=isDoubleInfinitexisDenormalizedx=0/=isDoubleDenormalizedxisNegativeZerox=0/=isDoubleNegativeZeroxisIEEE_=TrueinstanceShowDoublewhereshowsPrecx=showSignedFloatshowFloatxshowList=showList__(showsPrec0)

instanceEnumFloatwheresuccx=x+1predx=x-1toEnum=int2FloatfromEnum=fromInteger.truncate-- may overflowenumFrom=numericEnumFromenumFromTo=numericEnumFromToenumFromThen=numericEnumFromThenenumFromThenTo=numericEnumFromThenToinstanceEnumDoublewheresuccx=x+1predx=x-1toEnum=int2DoublefromEnum=fromInteger.truncate-- may overflowenumFrom=numericEnumFromenumFromTo=numericEnumFromToenumFromThen=numericEnumFromThenenumFromThenTo=numericEnumFromThenTo

-- | Show a signed 'RealFloat' value to full precision-- using standard decimal notation for arguments whose absolute value lies-- between @0.1@ and @9,999,999@, and scientific notation otherwise.showFloat::(RealFloata)=>a->ShowSshowFloatx=showString(formatRealFloatFFGenericNothingx)-- These are the format types.  This type is not exported.dataFFFormat=FFExponent|FFFixed|FFGenericformatRealFloat::(RealFloata)=>FFFormat->MaybeInt->a->StringformatRealFloatfmtdecsx|isNaNx="NaN"|isInfinitex=ifx<0then"-Infinity"else"Infinity"|x<0||isNegativeZerox='-':doFmtfmt(floatToDigits(toIntegerbase)(-x))|otherwise=doFmtfmt(floatToDigits(toIntegerbase)x)wherebase=10doFmtformat(is,e)=letds=mapintToDigitisincaseformatofFFGeneric->doFmt(ife<0||e>7thenFFExponentelseFFFixed)(is,e)FFExponent->casedecsofNothing->letshow_e'=show(e-1)incasedsof"0"->"0.0e0"[d]->d:".0e"++show_e'(d:ds')->d:'.':ds'++"e"++show_e'[]->error"formatRealFloat/doFmt/FFExponent: []"Justdec->letdec'=maxdec1incaseisof[0]->'0':'.':takedec'(repeat'0')++"e0"_->let(ei,is')=roundTobase(dec'+1)is(d:ds')=mapintToDigit(ifei>0theninitis'elseis')ind:'.':ds'++'e':show(e-1+ei)FFFixed->letmk0ls=caselsof{""->"0";_->ls}incasedecsofNothing|e<=0->"0."++replicate(-e)'0'++ds|otherwise->letf0srs=mk0(reverses)++'.':mk0rsfns""=f(n-1)('0':s)""fns(r:rs)=f(n-1)(r:s)rsinfe""dsJustdec->letdec'=maxdec0inife>=0thenlet(ei,is')=roundTobase(dec'+e)is(ls,rs)=splitAt(e+ei)(mapintToDigitis')inmk0ls++(ifnullrsthen""else'.':rs)elselet(ei,is')=roundTobasedec'(replicate(-e)0++is)d:ds'=mapintToDigit(ifei>0thenis'else0:is')ind:(ifnullds'then""else'.':ds')roundTo::Int->Int->[Int]->(Int,[Int])roundTobasedis=casefdisofx@(0,_)->x(1,xs)->(1,1:xs)_->error"roundTo: bad Value"whereb2=base`div`2fn[]=(0,replicaten0)f0(x:_)=(ifx>=b2then1else0,[])fn(i:xs)|i'==base=(1,0:ds)|otherwise=(0,i':ds)where(c,ds)=f(n-1)xsi'=c+i-- Based on "Printing Floating-Point Numbers Quickly and Accurately"-- by R.G. Burger and R.K. Dybvig in PLDI 96.-- This version uses a much slower logarithm estimator. It should be improved.-- | 'floatToDigits' takes a base and a non-negative 'RealFloat' number,-- and returns a list of digits and an exponent.-- In particular, if @x>=0@, and---- > floatToDigits base x = ([d1,d2,...,dn], e)---- then----      (1) @n >= 1@----      (2) @x = 0.d1d2...dn * (base**e)@----      (3) @0 <= di <= base-1@floatToDigits::(RealFloata)=>Integer->a->([Int],Int)floatToDigits_0=([0],0)floatToDigitsbasex=let(f0,e0)=decodeFloatx(minExp0,_)=floatRangexp=floatDigitsxb=floatRadixxminExp=minExp0-p-- the real minimum exponent-- Haskell requires that f be adjusted so denormalized numbers-- will have an impossibly low exponent.  Adjust for this.(f,e)=letn=minExp-e0inifn>0then(f0`quot`(exptbn),e0+n)else(f0,e0)(r,s,mUp,mDn)=ife>=0thenletbe=exptbeiniff==exptb(p-1)then(f*be*b*2,2*b,be*b,be)-- according to Burger and Dybvigelse(f*be*2,2,be,be)elseife>minExp&&f==exptb(p-1)then(f*b*2,exptb(-e+1)*2,b,1)else(f*2,exptb(-e)*2,1,1)k::Intk=letk0::Intk0=ifb==2&&base==10then-- logBase 10 2 is very slightly larger than 8651/28738-- (about 5.3558e-10), so if log x >= 0, the approximation-- k1 is too small, hence we add one and need one fixup step less.-- If log x < 0, the approximation errs rather on the high side.-- That is usually more than compensated for by ignoring the-- fractional part of logBase 2 x, but when x is a power of 1/2-- or slightly larger and the exponent is a multiple of the-- denominator of the rational approximation to logBase 10 2,-- k1 is larger than logBase 10 x. If k1 > 1 + logBase 10 x,-- we get a leading zero-digit we don't want.-- With the approximation 3/10, this happened for-- 0.5^1030, 0.5^1040, ..., 0.5^1070 and values close above.-- The approximation 8651/28738 guarantees k1 < 1 + logBase 10 x-- for IEEE-ish floating point types with exponent fields-- <= 17 bits and mantissae of several thousand bits, earlier-- convergents to logBase 10 2 would fail for long double.-- Using quot instead of div is a little faster and requires-- fewer fixup steps for negative lx.letlx=p-1+e0k1=(lx*8651)`quot`28738iniflx>=0thenk1+1elsek1else-- f :: Integer, log :: Float -> Float,--               ceiling :: Float -> Intceiling((log(fromInteger(f+1)::Float)+fromIntegrale*log(fromIntegerb))/log(fromIntegerbase))--WAS:            fromInt e * log (fromInteger b))fixupn=ifn>=0thenifr+mUp<=exptbasen*sthennelsefixup(n+1)elseifexptbase(-n)*(r+mUp)<=sthennelsefixup(n+1)infixupk0gendsrnsNmUpNmDnN=let(dn,rn')=(rn*base)`quotRem`sNmUpN'=mUpN*basemDnN'=mDnN*baseincase(rn'<mDnN',rn'+mUpN'>sN)of(True,False)->dn:ds(False,True)->dn+1:ds(True,True)->ifrn'*2<sNthendn:dselsedn+1:ds(False,False)->gen(dn:ds)rn'sNmUpN'mDnN'rds=ifk>=0thengen[]r(s*exptbasek)mUpmDnelseletbk=exptbase(-k)ingen[](r*bk)s(mUp*bk)(mDn*bk)in(mapfromIntegral(reverserds),k)

-- | Converts a 'Rational' value into any type in class 'RealFloat'.{-# RULES"fromRat/Float"     fromRat = (fromRational :: Rational -> Float)"fromRat/Double"    fromRat = (fromRational :: Rational -> Double)  #-}fromRat::(RealFloata)=>Rational->a-- Deal with special cases first, delegating the real work to fromRat'fromRat(n:%0)|n>0=1/0-- +Infinity|n<0=-1/0-- -Infinity|otherwise=0/0-- NaNfromRat(n:%d)|n>0=fromRat'(n:%d)|n<0=-fromRat'((-n):%d)|otherwise=encodeFloat00-- Zero-- Conversion process:-- Scale the rational number by the RealFloat base until-- it lies in the range of the mantissa (as used by decodeFloat/encodeFloat).-- Then round the rational to an Integer and encode it with the exponent-- that we got from the scaling.-- To speed up the scaling process we compute the log2 of the number to get-- a first guess of the exponent.fromRat'::(RealFloata)=>Rational->a-- Invariant: argument is strictly positivefromRat'x=rwhereb=floatRadixrp=floatDigitsr(minExp0,_)=floatRangerminExp=minExp0-p-- the real minimum exponentxMin=toRational(exptb(p-1))xMax=toRational(exptbp)p0=(integerLogBaseb(numeratorx)-integerLogBaseb(denominatorx)-p)`max`minExpf=ifp0<0then1%exptb(-p0)elseexptbp0%1(x',p')=scaleRat(toRationalb)minExpxMinxMaxp0(x/f)r=encodeFloat(roundx')p'-- Scale x until xMin <= x < xMax, or p (the exponent) <= minExp.scaleRat::Rational->Int->Rational->Rational->Int->Rational->(Rational,Int)scaleRatbminExpxMinxMaxpx|p<=minExp=(x,p)|x>=xMax=scaleRatbminExpxMinxMax(p+1)(x/b)|x<xMin=scaleRatbminExpxMinxMax(p-1)(x*b)|otherwise=(x,p)-- Exponentiation with a cache for the most common numbers.minExpt,maxExpt::IntminExpt=0maxExpt=1100expt::Integer->Int->Integerexptbasen=ifbase==2&&n>=minExpt&&n<=maxExptthenexpts!nelseifbase==10&&n<=maxExpt10thenexpts10!nelsebase^nexpts::ArrayIntIntegerexpts=array(minExpt,maxExpt)[(n,2^n)|n<-[minExpt..maxExpt]]maxExpt10::IntmaxExpt10=324expts10::ArrayIntIntegerexpts10=array(minExpt,maxExpt10)[(n,10^n)|n<-[minExpt..maxExpt10]]-- Compute the (floor of the) log of i in base b.-- Simplest way would be just divide i by b until it's smaller then b, but that would-- be very slow!  We are just slightly more clever, except for base 2, where-- we take advantage of the representation of Integers.-- The general case could be improved by a lookup table for-- approximating the result by integerLog2 i / integerLog2 b.integerLogBase::Integer->Integer->IntintegerLogBasebi|i<b=0|b==2=I#(integerLog2#i)|otherwise=I#(integerLogBase#bi)

{-# SPECIALISE fromRat'' :: Int -> Int -> Integer -> Integer -> Float,                            Int -> Int -> Integer -> Integer -> Double #-}fromRat''::RealFloata=>Int->Int->Integer->Integer->afromRat''minEx@(I#me#)mantDigs@(I#md#)nd=caseintegerLog2IsPowerOf2#dof(#ld#,pw##)|pw#==#0#->caseintegerLog2#nofln#|ln#>#(ld#+#me#)->ifln#<#md#thenencodeFloat(n`shiftL`(I#(md#-#1#-#ln#)))(I#(ln#+#1#-#ld#-#md#))elseletn'=n`shiftR`(I#(ln#+#1#-#md#))n''=caseroundingMode#n(ln#-#md#)of0#->n'2#->n'+1_->casefromIntegern'.&.(1::Int)of0->n'_->n'+1inencodeFloatn''(I#(ln#-#ld#+#1#-#md#))|otherwise->caseld#+#(me#-#md#)ofld'#|ld'#>#(ln#+#1#)->encodeFloat00|ld'#==#(ln#+#1#)->caseintegerLog2IsPowerOf2#nof(#_,0##)->encodeFloat00(#_,_#)->encodeFloat1(minEx-mantDigs)|ld'#<=#0#->encodeFloatn(I#((me#-#md#)-#ld'#))|otherwise->letn'=n`shiftR`(I#ld'#)incaseroundingMode#n(ld'#-#1#)of0#->encodeFloatn'(minEx-mantDigs)1#->iffromIntegern'.&.(1::Int)==0thenencodeFloatn'(minEx-mantDigs)elseencodeFloat(n'+1)(minEx-mantDigs)_->encodeFloat(n'+1)(minEx-mantDigs)|otherwise->letln=I#(integerLog2#n)ld=I#ld#p0=maxminEx(ln-ld)(n',d')|p0<mantDigs=(n`shiftL`(mantDigs-p0),d)|p0==mantDigs=(n,d)|otherwise=(n,d`shiftL`(p0-mantDigs))scalepab|p<=minEx-mantDigs=(p,a,b)|a<(b`shiftL`(mantDigs-1))=(p-1,a`shiftL`1,b)|(b`shiftL`mantDigs)<=a=(p+1,a,b`shiftL`1)|otherwise=(p,a,b)(p',n'',d'')=scale(p0-mantDigs)n'd'rdq=casen''`quotRem`d''of(q,r)->casecompare(r`shiftL`1)d''ofLT->qEQ->iffromIntegerq.&.(1::Int)==0thenqelseq+1GT->q+1inencodeFloatrdqp'

plusFloat,minusFloat,timesFloat,divideFloat::Float->Float->FloatplusFloat(F#x)(F#y)=F#(plusFloat#xy)minusFloat(F#x)(F#y)=F#(minusFloat#xy)timesFloat(F#x)(F#y)=F#(timesFloat#xy)divideFloat(F#x)(F#y)=F#(divideFloat#xy)negateFloat::Float->FloatnegateFloat(F#x)=F#(negateFloat#x)gtFloat,geFloat,eqFloat,neFloat,ltFloat,leFloat::Float->Float->BoolgtFloat(F#x)(F#y)=gtFloat#xygeFloat(F#x)(F#y)=geFloat#xyeqFloat(F#x)(F#y)=eqFloat#xyneFloat(F#x)(F#y)=neFloat#xyltFloat(F#x)(F#y)=ltFloat#xyleFloat(F#x)(F#y)=leFloat#xyexpFloat,logFloat,sqrtFloat::Float->FloatsinFloat,cosFloat,tanFloat::Float->FloatasinFloat,acosFloat,atanFloat::Float->FloatsinhFloat,coshFloat,tanhFloat::Float->FloatexpFloat(F#x)=F#(expFloat#x)logFloat(F#x)=F#(logFloat#x)sqrtFloat(F#x)=F#(sqrtFloat#x)sinFloat(F#x)=F#(sinFloat#x)cosFloat(F#x)=F#(cosFloat#x)tanFloat(F#x)=F#(tanFloat#x)asinFloat(F#x)=F#(asinFloat#x)acosFloat(F#x)=F#(acosFloat#x)atanFloat(F#x)=F#(atanFloat#x)sinhFloat(F#x)=F#(sinhFloat#x)coshFloat(F#x)=F#(coshFloat#x)tanhFloat(F#x)=F#(tanhFloat#x)powerFloat::Float->Float->FloatpowerFloat(F#x)(F#y)=F#(powerFloat#xy)-- definitions of the boxed PrimOps; these will be-- used in the case of partial applications, etc.plusDouble,minusDouble,timesDouble,divideDouble::Double->Double->DoubleplusDouble(D#x)(D#y)=D#(x+##y)minusDouble(D#x)(D#y)=D#(x-##y)timesDouble(D#x)(D#y)=D#(x*##y)divideDouble(D#x)(D#y)=D#(x/##y)negateDouble::Double->DoublenegateDouble(D#x)=D#(negateDouble#x)gtDouble,geDouble,eqDouble,neDouble,leDouble,ltDouble::Double->Double->BoolgtDouble(D#x)(D#y)=x>##ygeDouble(D#x)(D#y)=x>=##yeqDouble(D#x)(D#y)=x==##yneDouble(D#x)(D#y)=x/=##yltDouble(D#x)(D#y)=x<##yleDouble(D#x)(D#y)=x<=##ydouble2Float::Double->Floatdouble2Float(D#x)=F#(double2Float#x)float2Double::Float->Doublefloat2Double(F#x)=D#(float2Double#x)expDouble,logDouble,sqrtDouble::Double->DoublesinDouble,cosDouble,tanDouble::Double->DoubleasinDouble,acosDouble,atanDouble::Double->DoublesinhDouble,coshDouble,tanhDouble::Double->DoubleexpDouble(D#x)=D#(expDouble#x)logDouble(D#x)=D#(logDouble#x)sqrtDouble(D#x)=D#(sqrtDouble#x)sinDouble(D#x)=D#(sinDouble#x)cosDouble(D#x)=D#(cosDouble#x)tanDouble(D#x)=D#(tanDouble#x)asinDouble(D#x)=D#(asinDouble#x)acosDouble(D#x)=D#(acosDouble#x)atanDouble(D#x)=D#(atanDouble#x)sinhDouble(D#x)=D#(sinhDouble#x)coshDouble(D#x)=D#(coshDouble#x)tanhDouble(D#x)=D#(tanhDouble#x)powerDouble::Double->Double->DoublepowerDouble(D#x)(D#y)=D#(x**##y)

foreignimportccallunsafe"isFloatNaN"isFloatNaN::Float->Intforeignimportccallunsafe"isFloatInfinite"isFloatInfinite::Float->Intforeignimportccallunsafe"isFloatDenormalized"isFloatDenormalized::Float->Intforeignimportccallunsafe"isFloatNegativeZero"isFloatNegativeZero::Float->Intforeignimportccallunsafe"isDoubleNaN"isDoubleNaN::Double->Intforeignimportccallunsafe"isDoubleInfinite"isDoubleInfinite::Double->Intforeignimportccallunsafe"isDoubleDenormalized"isDoubleDenormalized::Double->Intforeignimportccallunsafe"isDoubleNegativeZero"isDoubleNegativeZero::Double->Int

{-# RULES"fromIntegral/Int->Float"   fromIntegral = int2Float"fromIntegral/Int->Double"  fromIntegral = int2Double"realToFrac/Float->Float"   realToFrac   = id :: Float -> Float"realToFrac/Float->Double"  realToFrac   = float2Double"realToFrac/Double->Float"  realToFrac   = double2Float"realToFrac/Double->Double" realToFrac   = id :: Double -> Double"realToFrac/Int->Double"    realToFrac   = int2Double-- See Note [realToFrac int-to-float]"realToFrac/Int->Float"     realToFrac   = int2Float-- ..ditto    #-}

showSignedFloat::(RealFloata)=>(a->ShowS)-- ^ a function that can show unsigned values->Int-- ^ the precedence of the enclosing context->a-- ^ the value to show->ShowSshowSignedFloatshowPospx|x<0||isNegativeZerox=showParen(p>6)(showChar'-'.showPos(-x))|otherwise=showPosx

clamp::Int->Int->Intclampbdk=max(-bd)(minbdk)