|
#############################################################################
##
#W mpfi.gi GAP library Laurent Bartholdi
##
#Y Copyright (C) 2008 Laurent Bartholdi
##
## This file deals with interval floats
##
################################################################
# viewers
################################################################
InstallMethod(ViewString, "float", [IsMPFIFloat],
function(obj)
return VIEWSTRING_MPFI(obj,FLOAT.VIEW_DIG);
end);
InstallMethod(String, "float, int", [IsMPFIFloat, IsInt],
function(obj,len)
return STRING_MPFI(obj,len);
end);
InstallMethod(String, "float", [IsMPFIFloat],
obj->STRING_MPFI(obj,0));
BindGlobal("MPFIBITS@", function(obj)
local s;
s := ValueOption("bits");
if IsInt(s) then return s; fi;
if IsMPFIFloat(obj) then return PrecisionFloat(obj); fi;
return MPFI.constants.MANT_DIG;
end);
BindGlobal("MPFIFLOAT_STRING", s->MPFI_STRING(s,MPFIBITS@(fail)));
################################################################
# constants
################################################################
EAGER_FLOAT_LITERAL_CONVERTERS.i := MPFIFLOAT_STRING;
DeclareCategory("IsMPFIPseudoField", IsFloatPseudoField);
BindGlobal("MPFI_PSEUDOFIELD",
Objectify(NewType(CollectionsFamily(MPFIFloatsFamily),
IsMPFIPseudoField and IsAttributeStoringRep),rec()));
SetName(MPFI_PSEUDOFIELD, Concatenation("(",FLOAT_REAL_STRING,",",FLOAT_REAL_STRING,")"));
SetLeftActingDomain(MPFI_PSEUDOFIELD,Rationals);
SetCharacteristic(MPFI_PSEUDOFIELD,0);
SetDimension(MPFI_PSEUDOFIELD,infinity);
SetSize(MPFI_PSEUDOFIELD,infinity);
SetIsWholeFamily(MPFI_PSEUDOFIELD,true);
SetZero(MPFI_PSEUDOFIELD,MPFI_INT(0));
SetOne(MPFI_PSEUDOFIELD,MPFI_INT(1));
InstallMethod( \in, [IsMPFIFloat,IsMPFIPseudoField], ReturnTrue);
SetIsUFDFamily(MPFIFloatsFamily,true);
SetZero(MPFIFloatsFamily,MPFI_INT(0));
SetOne(MPFIFloatsFamily,MPFI_INT(1));
InstallValue(MPFI, rec(
creator := MPFIFLOAT_STRING,
eager := 'i',
filter := IsMPFIFloat,
field := MPFI_PSEUDOFIELD,
constants := rec(INFINITY := MPFI_MAKEINFINITY(1),
NINFINITY := MPFI_MAKEINFINITY(-1),
VIEW_DIG := 6,
MANT_DIG := 100,
NAN := MPFI_MAKENAN(1),
recompute := function(r,prec)
r.PI := MPFI_PI(prec);
r.1_PI := Inverse(r.PI);
r.2PI := MPFI_INT(2)*r.PI;
r.2_PI := MPFI_INT(2)*r.1_PI;
r.2_SQRTPI := MPFI_INT(2)/Sqrt(r.PI);
r.PI_2 := r.PI/MPFI_INT(2);
r.PI_4 := r.PI_2/MPFI_INT(2);
r.SQRT2 := Sqrt(MPFI_INTPREC(2,prec));
r.1_SQRT2 := Inverse(r.SQRT2);
r.E := Exp(MPFI_INTPREC(1,prec));
r.LN2 := Log(MPFI_INTPREC(2,prec));
r.LN10 := Log(MPFI_INTPREC(10,prec));
r.LOG10E := Inverse(r.LN10);
r.LOG2E := Inverse(r.LN2);
end)));
InstallMethod(ObjByExtRep, [IsMPFIFloatFamily,IsCyclotomicCollection],
function(family,obj)
return OBJBYEXTREP_MPFI(obj);
end);
################################################################
# unary operations
################################################################
CallFuncList(function(arg)
local i;
for i in arg do
InstallOtherMethod(VALUE_GLOBAL(i[1]), "MPFI float", [IsMPFIFloat], i[2]);
od;
end, [["AdditiveInverseSameMutability",AINV_MPFI],
["AdditiveInverseMutable",AINV_MPFI],
["InverseMutable",INV_MPFI],
["InverseSameMutability",INV_MPFI],
["Int",INT_MPFI],
["AbsoluteValue",ABS_MPFI],
["ZeroMutable",ZERO_MPFI],
["ZeroImmutable",ZERO_MPFI],
["ZeroSameMutability",ZERO_MPFI],
["OneMutable",ONE_MPFI],
["OneImmutable",ONE_MPFI],
["OneSameMutability",ONE_MPFI],
["Sqrt",SQRT_MPFI],
["Cos",COS_MPFI],
["Sin",SIN_MPFI],
["Tan",TAN_MPFI],
["Sec",SEC_MPFI],
["Csc",CSC_MPFI],
["Cot",COT_MPFI],
["Asin",ASIN_MPFI],
["Acos",ACOS_MPFI],
["Atan",ATAN_MPFI],
["Cosh",COSH_MPFI],
["Sinh",SINH_MPFI],
["Tanh",TANH_MPFI],
["Sech",SECH_MPFI],
["Csch",CSCH_MPFI],
["Coth",COTH_MPFI],
["Asinh",ASINH_MPFI],
["Acosh",ACOSH_MPFI],
["Atanh",ATANH_MPFI],
["Log",LOG_MPFI],
["Log2",LOG2_MPFI],
["Log10",LOG10_MPFI],
["Exp",EXP_MPFI],
["Exp2",EXP2_MPFI],
["Exp10",EXP10_MPFI],
["CubeRoot",CBRT_MPFI],
["Square",SQR_MPFI],
["Inf", LEFT_MPFI],
["Sup", RIGHT_MPFI],
["Mid", MID_MPFI],
["AbsoluteDiameter", DIAM_MPFI],
["RelativeDiameter", DIAM_REL_MPFI],
["BisectInterval", BISECT_MPFI],
["Ceil",CEIL_MPFI],
["Floor",FLOOR_MPFI],
["Round",ROUND_MPFI],
["Trunc",TRUNC_MPFI],
["Frac",FRAC_MPFI],
["FrExp",FREXP_MPFI],
["Norm",SQR_MPFI],
["Argument",ZERO_MPFI],
["SignFloat",SIGN_MPFI],
["IsXInfinity",ISXINF_MPFI],
["IsPInfinity",ISPINF_MPFI],
["IsNInfinity",ISNINF_MPFI],
["IsFinite",ISNUMBER_MPFI],
["IsNaN",ISNAN_MPFI],
["IsZero",ISZERO_MPFI],
["IsEmpty",ISEMPTY_MPFI],
["ExtRepOfObj",EXTREPOFOBJ_MPFI],
["RealPart",x->x],
["ImaginaryPart",ZERO_MPFI],
["ComplexConjugate",x->x],
["PrecisionFloat",PREC_MPFI]]);
################################################################
# binary operations
################################################################
CallFuncList(function(arg)
local i;
for i in arg do
InstallMethod(VALUE_GLOBAL(i), "MPFI float, MPFI float", [IsMPFIFloat, IsMPFIFloat],
VALUE_GLOBAL(Concatenation(i,"_MPFI")));
InstallMethod(VALUE_GLOBAL(i), "MPFI float, MPFR float", [IsMPFIFloat, IsMPFRFloat],
VALUE_GLOBAL(Concatenation(i,"_MPFI_MPFR")));
InstallMethod(VALUE_GLOBAL(i), "MPFR float, MPFI float", [IsMPFRFloat, IsMPFIFloat],
VALUE_GLOBAL(Concatenation(i,"_MPFR_MPFI")));
od;
end, ["SUM","DIFF","QUO","PROD","LQUO","EQ","LT"]);
InstallMethod(LdExp, "MPFI float, int", [IsMPFIFloat, IsInt], LDEXP_MPFI);
InstallMethod(Atan2, "float", [IsMPFIFloat, IsMPFIFloat], ATAN2_MPFI);
InstallMethod(\^, "float, rat", [IsMPFIFloat, IsRat],
function(f,r)
if DenominatorRat(r)=1 then
TryNextMethod();
fi;
if NumeratorRat(r)<>1 then
f := f^NumeratorRat(r);
fi;
return ROOT_MPFI(f,DenominatorRat(r));
end);
InstallMethod(IsSubset, [IsMPFIFloat, IsMPFIFloat], ISINSIDE_MPFI);
InstallMethod(IN, [IsMPFIFloat, IsMPFIFloat], SUM_FLAGS, ISINSIDE_MPFI);
InstallMethod(IN, [IsMPFRFloat, IsMPFIFloat], SUM_FLAGS, ISINSIDE_MPFRMPFI);
InstallMethod(Intersection2, [IsMPFIFloat, IsMPFIFloat], INTERSECT_MPFI);
InstallMethod(Union2, [IsMPFIFloat, IsMPFIFloat], UNION_MPFI);
InstallMethod(IncreaseInterval, [IsMPFIFloat, IsMPFRFloat], BLOWUP_MPFI);
InstallMethod(IncreaseInterval, [IsMPFIFloat, IsMPFIFloat],
function(x,y) return INCREASE_MPFI(x,Sup(y)); end);
InstallMethod(BlowupInterval, [IsMPFIFloat, IsMPFIFloat], BLOWUP_MPFI);
InstallMethod(BlowupInterval, [IsMPFIFloat, IsMPFIFloat],
function(x,y) return BLOWUP_MPFI(x,Sup(y)); end);
################################################################
# constructor
################################################################
INSTALLFLOATCREATOR("for list", [IsMPFIFloat,IsList],
function(filter,list)
return OBJBYEXTREP_MPFI(list);
end);
INSTALLFLOATCREATOR("for integers", [IsMPFIFloat,IsInt], 20,
function(filter,int)
return MPFI_INTPREC(int,MPFIBITS@(filter));
end);
INSTALLFLOATCREATOR("for rationals", [IsMPFIFloat,IsRat], 10,
function(filter,rat)
local n, d, prec;
n := NumeratorRat(rat);
d := DenominatorRat(rat);
prec := MPFIBITS@(filter);
return MPFI_INTPREC(n,prec)/MPFI_INTPREC(d,prec);
end);
INSTALLFLOATCREATOR("for strings", [IsMPFIFloat,IsString],
function(filter,s)
return MPFI_STRING(s,MPFIBITS@(filter));
end);
INSTALLFLOATCREATOR("for MPFI float", [IsMPFIFloat,IsMPFIFloat],
function(filter,obj)
return MPFI_MPFIPREC(obj,MPFIBITS@(filter));
end);
INSTALLFLOATCREATOR("for MPFR float", [IsMPFIFloat,IsMPFRFloat],
function(filter,obj)
return MPFI_MPFR(obj);
end);
DECLAREFLOATCREATOR(IsMPFIFloat,IsMPFRFloat,IsMPFRFloat);
INSTALLFLOATCREATOR("for 2 MPFR floats", [IsMPFIFloat,IsMPFRFloat,IsMPFRFloat],
function(filter,re,im)
return MPFI_2MPFR(re,im);
end);
DECLAREFLOATCREATOR(IsMPFIFloat,IsInt,IsInt);
INSTALLFLOATCREATOR("for 2 ints", [IsMPFIFloat,IsInt,IsInt],
function(filter,re,im)
return MPFI_2MPFR(MPFR_INT(re),MPFR_INT(im));
end);
INSTALLFLOATCREATOR("for macfloat", [IsMPFIFloat,IsIEEE754FloatRep],
function(filter,obj)
return MPFI_MPFR(MPFR_MACFLOAT(obj));
end);
INSTALLFLOATCONSTRUCTORS(MPFI);
MPFI.constants.recompute(MPFI.constants,MPFI.constants.MANT_DIG);
#############################################################################
##
#E
[ Dauer der Verarbeitung: 0.28 Sekunden
(vorverarbeitet)
]
|
