Quelle  cxsc.gi   Sprache: unbekannt

#############################################################################
##
#W  cxsc.gi                        GAP library              Laurent Bartholdi
##
#Y  Copyright (C) 2008 Laurent Bartholdi
##
##  This file deals with floats
##

################################################################
# viewers
################################################################
InstallMethod(ViewString, "cxsc:*", [IsCXSCFloat],
        function(obj)
    return STRING_CXSC(obj,0,FLOAT.VIEW_DIG);
end);

InstallOtherMethod(String, "cxsc:*,len,digits", [IsCXSCFloat,IsInt,IsInt],
        STRING_CXSC);

InstallMethod(String, "cxsc:*, int", [IsCXSCFloat, IsInt],
        function(obj,len)
    return STRING_CXSC(obj,0,len);
end);
        
InstallMethod(String, "cxsc:*", [IsCXSCFloat],
        obj->STRING_CXSC(obj,0,FLOAT.DECIMAL_DIG));

BindGlobal("CXSC_STRING", function(s)
    if 'i' in s or 'I' in s then
        return CP_CXSC_STRING(s);
    elif '(' in s and '[' in s then
        return CI_CXSC_STRING(s);
    elif '(' in s then
        return CP_CXSC_STRING(s);
    elif '[' in s then
        return RI_CXSC_STRING(s);
    else
        return RP_CXSC_STRING(s);
    fi;
end);

InstallMethod(PrecisionFloat, "cxsc:*", [IsCXSCFloat], x->CXSC.constants.MANT_DIG);

################################################################
# fields
################################################################
DeclareCategory("IsCXSCPseudoField", IsFloatPseudoField);

BindGlobal("CXSC_PSEUDOFIELD",
        Objectify(NewType(CollectionsFamily(CXSCFloatsFamily),
                IsCXSCPseudoField and IsAttributeStoringRep),rec()));
SetName(CXSC_PSEUDOFIELD, FLOAT_COMPLEX_STRING);

SetIsUFDFamily(CXSCFloatsFamily,true);
SetZero(CXSCFloatsFamily,CXSC_INT(0));
SetOne(CXSCFloatsFamily,CXSC_INT(1));

SetLeftActingDomain(CXSC_PSEUDOFIELD,Rationals);
SetCharacteristic(CXSC_PSEUDOFIELD,0);
SetDimension(CXSC_PSEUDOFIELD,infinity);
SetSize(CXSC_PSEUDOFIELD,infinity);
SetIsWholeFamily(CXSC_PSEUDOFIELD,true);
SetZero(CXSC_PSEUDOFIELD,CXSC_INT(0));
SetOne(CXSC_PSEUDOFIELD,CXSC_INT(1));
InstallMethod( \in, [IsCXSCFloat,IsCXSCPseudoField], ReturnTrue);

################################################################
# constants
################################################################
InstallValue(CXSC, rec(creator := CXSC_STRING,
    eager := 'X',
    filter := IsCXSCFloat,
    field := CXSC_PSEUDOFIELD,
    reals := CXSC, # we don't distinguish the reals and complex fields here
    constants := rec(INFINITY := CXSC_NEWCONSTANT(3),
        NINFINITY := AINV_CXSC_RP(CXSC_NEWCONSTANT(3)),
        MAX := CXSC_NEWCONSTANT(2),
        NAN := CXSC_NEWCONSTANT(5),
        DIG := 15,
        VIEW_DIG := 6,
        MANT_DIG := 53,
        MAX_10_EXP := 308,
        MAX_EXP := 1024,
        MIN_10_EXP := -307,
        MIN_EXP := -1021,
        DECIMAL_DIG := 17,
        I := CP_CXSC_RP_RP(CXSC_INT(0),CXSC_INT(1)),
        2IPI := CP_CXSC_RP_RP(CXSC_INT(0),CXSC_NEWCONSTANT(7))
)));

InstallMethod(ObjByExtRep, [IsCXSCFloatFamily,IsCyclotomicCollection],
        function(family,obj)
    if Length(obj)=2 then
        return OBJBYEXTREP_CXSC_RP(obj);
    else
        Error("Ambiguous: is ",obj," a complex or interval CXSC? Use NewFloat(...)");
    fi;
end);

EAGER_FLOAT_LITERAL_CONVERTERS.X := CXSC_STRING;
EAGER_FLOAT_LITERAL_CONVERTERS.R := RP_CXSC_STRING;
EAGER_FLOAT_LITERAL_CONVERTERS.C := CP_CXSC_STRING;
EAGER_FLOAT_LITERAL_CONVERTERS.I := RI_CXSC_STRING;
EAGER_FLOAT_LITERAL_CONVERTERS.B := CI_CXSC_STRING;

################################################################
# unary operations
################################################################
InstallMethod(ZeroMutable,[IsCXSCReal],x->0.0_R);
InstallMethod(ZeroMutable,[IsCXSCComplex],x->0.0_C);
InstallMethod(ZeroMutable,[IsCXSCInterval],x->0.0_I);
InstallMethod(ZeroMutable,[IsCXSCBox],x->0.0_B);
InstallMethod(ZeroSameMutability,[IsCXSCReal],x->0.0_R);
InstallMethod(ZeroSameMutability,[IsCXSCComplex],x->0.0_C);
InstallMethod(ZeroSameMutability,[IsCXSCInterval],x->0.0_I);
InstallMethod(ZeroSameMutability,[IsCXSCBox],x->0.0_B);
InstallMethod(ZeroImmutable,[IsCXSCReal],x->0.0_R);
InstallMethod(ZeroImmutable,[IsCXSCComplex],x->0.0_C);
InstallMethod(ZeroImmutable,[IsCXSCInterval],x->0.0_I);
InstallMethod(ZeroImmutable,[IsCXSCBox],x->0.0_B);

InstallMethod(OneMutable,[IsCXSCReal],x->1.0_R);
InstallMethod(OneMutable,[IsCXSCComplex],x->1.0_C);
InstallMethod(OneMutable,[IsCXSCInterval],x->1.0_I);
InstallMethod(OneMutable,[IsCXSCBox],x->1.0_B);
InstallMethod(OneSameMutability,[IsCXSCReal],x->1.0_R);
InstallMethod(OneSameMutability,[IsCXSCComplex],x->1.0_C);
InstallMethod(OneSameMutability,[IsCXSCInterval],x->1.0_I);
InstallMethod(OneSameMutability,[IsCXSCBox],x->1.0_B);
InstallMethod(OneImmutable,[IsCXSCReal],x->1.0_R);
InstallMethod(OneImmutable,[IsCXSCComplex],x->1.0_C);
InstallMethod(OneImmutable,[IsCXSCInterval],x->1.0_I);
InstallMethod(OneImmutable,[IsCXSCBox],x->1.0_B);

InstallMethod(Int, [IsCXSCReal], function(x)
    local i, w, n;
    w := INT_CXSC(x);
    if w=fail then
        i := 1;
        repeat
            n := INT_CXSC(x/i);
            i := 2*i;
        until n<>fail;
        i := i/2;
        w := 0;
        repeat
            w := w+n*i;
            x := x-n*i;
            i := i/2;
            n := INT_CXSC(x/i);
        until i=1;
    fi;
    return w;
end);
InstallMethod(Int, [IsCXSCInterval], x->Int(Sup(x)));

CallFuncList(function(arg)
    local i;
    for i in arg do
        InstallOtherMethod(VALUE_GLOBAL(i[1]), "cxsc:rp", [IsCXSCReal],
                VALUE_GLOBAL(Concatenation(i[2],"_RP")));
        InstallOtherMethod(VALUE_GLOBAL(i[1]), "cxsc:cp", [IsCXSCComplex],
                VALUE_GLOBAL(Concatenation(i[2],"_CP")));
        InstallOtherMethod(VALUE_GLOBAL(i[1]), "cxsc:ri", [IsCXSCInterval],
                VALUE_GLOBAL(Concatenation(i[2],"_RI")));
        InstallOtherMethod(VALUE_GLOBAL(i[1]), "cxsc:ci", [IsCXSCBox],
                VALUE_GLOBAL(Concatenation(i[2],"_CI")));
    od;
end,   [["AdditiveInverseSameMutability","AINV_CXSC"],
        ["AdditiveInverseMutable","AINV_CXSC"],
        ["InverseMutable","INV_CXSC"],
        ["InverseSameMutability","INV_CXSC"],
        ["AbsoluteValue","ABS_CXSC"],
        ["Sqrt","SQRT_CXSC"],
        ["Cos","COS_CXSC"],
        ["Sin","SIN_CXSC"],
        ["Tan","TAN_CXSC"],
        ["Cot","COT_CXSC"],
        ["Asin","ASIN_CXSC"],
        ["Acos","ACOS_CXSC"],
        ["Atan","ATAN_CXSC"],
        ["Cosh","COSH_CXSC"],
        ["Sinh","SINH_CXSC"],
        ["Tanh","TANH_CXSC"],
        ["Coth","COTH_CXSC"],
        ["Asinh","ASINH_CXSC"],
        ["Acosh","ACOSH_CXSC"],
        ["Atanh","ATANH_CXSC"],
        ["Log","LOG_CXSC"],
        ["Log1p","LOG1P_CXSC"],
        ["Log2","LOG2_CXSC"],
        ["Log10","LOG10_CXSC"],
        ["Exp","EXP_CXSC"],
        ["Expm1","EXPM1_CXSC"],
        ["FrExp","FREXP_CXSC"],
        ["ExtRepOfObj","EXTREPOFOBJ_CXSC"],
        ["IsNaN","ISNAN_CXSC"],
        ["IsFinite","ISNUMBER_CXSC"],
        ["IsPInfinity","ISPINF_CXSC"],
        ["IsNInfinity","ISNINF_CXSC"],
        ["IsXInfinity","ISXINF_CXSC"],
        ["IsZero","ISZERO_CXSC"],
        ["IsOne","ISONE_CXSC"],
        ["Square","SQR_CXSC"]]);

InstallMethod(SignFloat, "cxsc:rp", [IsCXSCReal], SIGN_CXSC_RP);
InstallMethod(SignFloat, "cxsc:ri", [IsCXSCInterval], SIGN_CXSC_RI);
InstallMethod(Hypothenuse, "cxsc:rp", [IsCXSCReal,IsCXSCReal], HYPOT_CXSC_RP2);

################################################################
# interval stuff
################################################################

InstallMethod(Inf, "cxsc:ri", [IsCXSCInterval], INF_CXSC_RI);
InstallMethod(Sup, "cxsc:ri", [IsCXSCInterval], SUP_CXSC_RI);
InstallMethod(Mid, "cxsc:ri", [IsCXSCInterval], MID_CXSC_RI);
InstallMethod(AbsoluteDiameter, "cxsc:ri", [IsCXSCInterval], DIAM_CXSC_RI);
InstallMethod(RelativeDiameter, "cxsc:ri", [IsCXSCInterval], DIAM_REL_CXSC_RI);
InstallMethod(Inf, "cxsc:ci", [IsCXSCBox], INF_CXSC_CI);
InstallMethod(Sup, "cxsc:ci", [IsCXSCBox], SUP_CXSC_CI);
InstallMethod(Mid, "cxsc:ci", [IsCXSCBox], MID_CXSC_CI);
InstallMethod(AbsoluteDiameter, "cxsc:ci", [IsCXSCBox], DIAM_CXSC_CI);
InstallMethod(RelativeDiameter, "cxsc:ci", [IsCXSCBox], DIAM_REL_CXSC_CI);

InstallMethod(IsDisjoint, "cxsc:ri,ri", [IsCXSCInterval,IsCXSCInterval],
        DISJOINT_CXSC_RI_RI);
InstallMethod(IN, "cxsc:rp,ri", [IsCXSCReal,IsCXSCInterval], SUM_FLAGS,
        IN_CXSC_RP_RI);
InstallMethod(IN, "cxsc:ri,ri", [IsCXSCInterval,IsCXSCInterval], SUM_FLAGS,
        IN_CXSC_RI_RI);
InstallMethod(IN, "cxsc:rp,ci", [IsCXSCReal,IsCXSCBox], SUM_FLAGS,
        IN_CXSC_RP_CI);
InstallMethod(IN, "cxsc:cp,ci", [IsCXSCComplex,IsCXSCBox], SUM_FLAGS,
        IN_CXSC_CP_CI);
InstallMethod(IN, "cxsc:ri,ci", [IsCXSCInterval,IsCXSCBox], SUM_FLAGS,
        IN_CXSC_RI_CI);
InstallMethod(IN, "cxsc:ci,ci", [IsCXSCBox,IsCXSCBox], SUM_FLAGS,
        IN_CXSC_CI_CI);
InstallMethod(IsSubset, "cxsc:ri,ri", [IsCXSCInterval,IsCXSCInterval], SUM_FLAGS,
        IN_CXSC_RI_RI);
InstallMethod(IsSubset, "cxsc:ri,ci", [IsCXSCInterval,IsCXSCBox], SUM_FLAGS,
        IN_CXSC_RI_CI);
InstallMethod(IsSubset, "cxsc:ci,ci", [IsCXSCBox,IsCXSCBox], SUM_FLAGS,
        IN_CXSC_CI_CI);
InstallMethod(IsDisjoint, "cxsc:ci,ci", [IsCXSCBox,IsCXSCBox],
        DISJOINT_CXSC_CI_CI);
InstallOtherMethod(Union2, "cxsc:ri,ri", [IsCXSCInterval,IsCXSCInterval],
        OR_CXSC_RI_RI);
InstallOtherMethod(Union2, "cxsc:ri,ci", [IsCXSCInterval,IsCXSCBox],
        OR_CXSC_RI_CI);
InstallOtherMethod(Union2, "cxsc:ci,ri", [IsCXSCBox,IsCXSCInterval],
        OR_CXSC_CI_RI);
InstallOtherMethod(Union2, "cxsc:ci,ci", [IsCXSCBox,IsCXSCBox],
        OR_CXSC_CI_CI);
InstallOtherMethod(Intersection2, "cxsc:ri,ri", [IsCXSCInterval,IsCXSCInterval],
        AND_CXSC_RI_RI);
InstallOtherMethod(Intersection2, "cxsc:ri,ci", [IsCXSCInterval,IsCXSCBox],
        AND_CXSC_RI_CI);
InstallOtherMethod(Intersection2, "cxsc:ci,ri", [IsCXSCBox,IsCXSCInterval],
        AND_CXSC_CI_RI);
InstallOtherMethod(Intersection2, "cxsc:ci,ci", [IsCXSCBox,IsCXSCBox],
        AND_CXSC_CI_CI);

InstallMethod(Value, [IsFloatUnivariatePolynomial, IsCXSCReal],
        function(poly,r)
    local v;
    poly := CoefficientsOfUnivariatePolynomial(poly);
    if not ForAll(poly,c->IsCXSCReal(c) or IsCXSCComplex(c)) then
        TryNextMethod();
    fi;
    v := EVALPOLY_CXSC(poly,r);
    if v=fail then TryNextMethod(); fi;
    return v[1];
end);

InstallMethod(ValueInterval, [IsFloatUnivariatePolynomial, IsCXSCReal],
        function(poly,r)
    local v;
    poly := CoefficientsOfUnivariatePolynomial(poly);
    if not ForAll(poly,c->IsCXSCReal(c) or IsCXSCComplex(c)) then
        TryNextMethod();
    fi;
    v := EVALPOLY_CXSC(poly,r);
    if v=fail then TryNextMethod(); fi;
    return v[2];
end);

################################################################
# complex stuff
################################################################
InstallMethod(RealPart, "cxsc:rp", [IsCXSCReal], x->x);
InstallMethod(RealPart, "cxsc:ri", [IsCXSCInterval], x->x);
InstallMethod(RealPart, "cxsc:cp", [IsCXSCComplex], REAL_CXSC_CP);
InstallMethod(RealPart, "cxsc:ci", [IsCXSCBox], REAL_CXSC_CI);
InstallMethod(ImaginaryPart, "cxsc:cp", [IsCXSCReal], x->0.0_R);
InstallMethod(ImaginaryPart, "cxsc:ci", [IsCXSCInterval], x->0.0_I);
InstallMethod(ImaginaryPart, "cxsc:cp", [IsCXSCComplex], IMAG_CXSC_CP);
InstallMethod(ImaginaryPart, "cxsc:ci", [IsCXSCBox], IMAG_CXSC_CI);
InstallMethod(ComplexConjugate, "cxsc:rp", [IsCXSCReal], x->x);
InstallMethod(ComplexConjugate, "cxsc:ri", [IsCXSCInterval], x->x);
InstallMethod(ComplexConjugate, "cxsc:cp", [IsCXSCComplex], CONJ_CXSC_CP);
InstallMethod(ComplexConjugate, "cxsc:ci", [IsCXSCBox], CONJ_CXSC_CI);
InstallMethod(Norm, "cxsc:rp", [IsCXSCReal], SQR_CXSC_RP);
InstallMethod(Norm, "cxsc:ri", [IsCXSCInterval], SQR_CXSC_RI);
InstallMethod(Norm, "cxsc:cp", [IsCXSCComplex], NORM_CXSC_CP);
InstallMethod(Norm, "cxsc:ci", [IsCXSCBox], NORM_CXSC_CI);
        
################################################################
# binary operations
################################################################
CallFuncList(function(arg)
    local i, j;
    for i in arg do
        for j in Tuples([["RP",IsCXSCReal],["CP",IsCXSCComplex],["RI",IsCXSCInterval],["CI",IsCXSCBox]],2) do
            InstallMethod(VALUE_GLOBAL(i), Concatenation("cxsc:",j[1][1],",",j[2][1]),
                    j{[1..2]}[2], VALUE_GLOBAL(Concatenation(i,"_CXSC_",j[1][1],"_",j[2][1])));
        od;
        CallFuncList(function(oper)
            InstallOtherMethod(oper,"float,cyc",[IsCXSCFloatRep,IsCyc],
                    function(x,y)
                return oper(x,MakeFloat(x,y));
            end);
            InstallOtherMethod(oper,"float,any",[IsCyc,IsCXSCFloatRep],
                    function(x,y)
                return oper(MakeFloat(y,x),y);
            end);
        end,[VALUE_GLOBAL(i)]);
    od;
end, ["SUM","DIFF","QUO","PROD","POW","EQ","LT"]);

BindGlobal("CXSC_POW_RAT", function(f,r,POWER,ROOT)
    local d, n;
    d := DenominatorRat(r);
    n := NumeratorRat(r);
    if AbsoluteValue(n)<2^28 then
        f := POWER(f,n);
    else
        TryNextMethod();
    fi;
    if d<2^28 then
        f := ROOT(f,d);
    else
        TryNextMethod();
    fi;
    return f;
end);

InstallMethod(\^, "cxsc:, rat", [IsCXSCReal, IsRat],
        function(f,r)
    return CXSC_POW_RAT(f,r,POWER_CXSC_RP,ROOT_CXSC_RP);
end);
InstallMethod(\^, "cxsc:, rat", [IsCXSCComplex, IsRat],
        function(f,r)
    return CXSC_POW_RAT(f,r,POWER_CXSC_CP,ROOT_CXSC_CP);
end);
InstallMethod(\^, "cxsc:, rat", [IsCXSCInterval, IsRat],
        function(f,r)
    return CXSC_POW_RAT(f,r,POWER_CXSC_RI,ROOT_CXSC_RI);
end);
InstallMethod(\^, "cxsc:, rat", [IsCXSCBox, IsRat],
        function(f,r)
    return CXSC_POW_RAT(f,r,POWER_CXSC_CI,ROOT_CXSC_CI);
end);

InstallMethod(Atan2, "cxsc:rp,rp", [IsCXSCReal,IsCXSCReal], ATAN2_CXSC_RP_RP);
InstallOtherMethod(Atan2, "cxsc:cp", [IsCXSCComplex], ATAN2_CXSC_CP);
InstallOtherMethod(Atan2, "cxsc:ci", [IsCXSCBox], ATAN2_CXSC_CI);

InstallMethod(LdExp, "cxsc:rp, int", [IsCXSCReal, IsInt], LDEXP_CXSC_RP);
InstallMethod(LdExp, "cxsc:ri, int", [IsCXSCInterval, IsInt], LDEXP_CXSC_RI);
InstallMethod(LdExp, "cxsc:cp, int", [IsCXSCComplex, IsInt], LDEXP_CXSC_CP);
InstallMethod(LdExp, "cxsc:ci, int", [IsCXSCBox, IsInt], LDEXP_CXSC_CI);

################################################################
# roots
################################################################
InstallMethod(RootsFloatOp, "cxsc: list, cxsc:ci", [IsList,IsCXSCFloat],
        function(p,filter)
    return ROOTPOLY_CXSC(p,false);
end);

################################################################
# default constructors
################################################################
INSTALLFLOATCREATOR("for lists", [IsCXSCFloat,IsList],
        function(filter,list)
    return OBJBYEXTREP_CXSC_RP(list);
end);

INSTALLFLOATCREATOR("for integers", [IsCXSCFloat,IsInt],
        function(filter,int)
    local f, m;
    f := 0.0_R;
    m := 1.0_R;
    while int <> 0 do
        f := f + m*CXSC_INT(RemInt(int,2^27));
        int := QuoInt(int,2^27);
        m := LdExp(m,27);
    od;
    return f;
end);

INSTALLFLOATCREATOR("for strings", [IsCXSCFloat,IsString],
        function(filter,s)
    if 'i' in s or 'I' in s then
        return CP_CXSC_STRING(s);
    else
        return RP_CXSC_STRING(s);
    fi;
end);

INSTALLFLOATCREATOR("for strings", [IsCXSCReal,IsFloat],
        function(filter,s)
    return RP_CXSC_STRING(s);
end);

INSTALLFLOATCREATOR("for cxsc:rp", [IsCXSCReal,IsIEEE754FloatRep],
        function(filter,x)
    return CXSC_IEEE754(x);
end);

################################################################
# real constructors
################################################################
INSTALLFLOATCREATOR("for lists", [IsCXSCReal,IsList],
        function(filter,list)
    return OBJBYEXTREP_CXSC_RP(list);
end);

INSTALLFLOATCREATOR("for integers", [IsCXSCReal,IsInt],
        function(filter,int)
    local f, m;
    f := 0.0_R;
    m := 1.0_R;
    while int <> 0 do
        f := f + m*CXSC_INT(RemInt(int,2^27));
        int := QuoInt(int,2^27);
        m := LdExp(m,27);
    od;
    return f;
end);

INSTALLFLOATCREATOR("for strings", [IsCXSCReal,IsString],
        function(filter,s)
    return RP_CXSC_STRING(s);
end);

INSTALLFLOATCREATOR("for cxsc:rp", [IsCXSCReal,IsCXSCReal],
        function(filter,x)
    return x;
end);

INSTALLFLOATCONSTRUCTORS(rec(filter:=IsCXSCReal, constants := CXSC.constants));

################################################################
# complex constructors
################################################################
INSTALLFLOATCREATOR("for lists", [IsCXSCComplex,IsList],
        function(filter,list)
    return OBJBYEXTREP_CXSC_CP(list);
end);

INSTALLFLOATCREATOR("for ints", [IsCXSCComplex,IsInt],
        function(filter,x)
    return CP_CXSC_RP(NewFloat(IsCXSCReal,x));
end);

DECLAREFLOATCREATOR(IsCXSCComplex,IsCXSCReal,IsCXSCReal);
INSTALLFLOATCREATOR("for two reals", [IsCXSCComplex,IsCXSCReal,IsCXSCReal],
        function(filter,x,y)
    return CP_CXSC_RP_RP(x,y);
end);
                
DECLAREFLOATCREATOR(IsCXSCComplex,IsInt,IsInt);
INSTALLFLOATCREATOR("for two ints", [IsCXSCComplex,IsInt,IsInt],
        function(filter,x,y)
    return CP_CXSC_RP_RP(NewFloat(IsCXSCReal,x),NewFloat(IsCXSCReal,y));
end);
                
INSTALLFLOATCREATOR("for strings", [IsCXSCComplex,IsString],
        function(filter,s)
    return CP_CXSC_STRING(s);
end);

INSTALLFLOATCREATOR("for a real", [IsCXSCComplex,IsCXSCReal],
        function(filter,x)
    return CP_CXSC_RP(x);
end);

INSTALLFLOATCREATOR("for a complex", [IsCXSCComplex,IsCXSCComplex],
        function(filter,x)
    return x;
end);

INSTALLFLOATCONSTRUCTORS(rec(filter:=IsCXSCComplex));

################################################################
# interval constructors
################################################################
INSTALLFLOATCREATOR("for lists", [IsCXSCInterval,IsList],
        function(filter,list)
    return OBJBYEXTREP_CXSC_RI(list);
end);

INSTALLFLOATCREATOR("for ints", [IsCXSCInterval,IsInt],
        function(filter,x)
    return RI_CXSC_RP(NewFloat(IsCXSCReal,x));
end);

DECLAREFLOATCREATOR(IsCXSCInterval,IsCXSCReal,IsCXSCReal);
INSTALLFLOATCREATOR("for two reals", [IsCXSCInterval,IsCXSCReal,IsCXSCReal],
        function(filter,x,y)
    return RI_CXSC_RP_RP(x,y);
end);
                
DECLAREFLOATCREATOR(IsCXSCInterval,IsInt,IsInt);
INSTALLFLOATCREATOR("for two integers", [IsCXSCInterval,IsInt,IsInt],
        function(filter,x,y)
    return RI_CXSC_RP_RP(NewFloat(IsCXSCReal,x),NewFloat(IsCXSCReal,y));
end);
                
INSTALLFLOATCREATOR("for strings", [IsCXSCInterval,IsString],
        function(filter,s)
    return RI_CXSC_STRING(s);
end);

INSTALLFLOATCREATOR("for a real", [IsCXSCInterval,IsCXSCReal],
        function(filter,x)
    return RI_CXSC_RP(x);
end);

INSTALLFLOATCREATOR("for an interval", [IsCXSCInterval,IsCXSCInterval],
        function(filter,x)
    return x;
end);

INSTALLFLOATCONSTRUCTORS(rec(filter:=IsCXSCInterval));

################################################################
# complex interval constructors
################################################################
INSTALLFLOATCREATOR("for lists", [IsCXSCBox,IsList],
        function(filter,list)
    return OBJBYEXTREP_CXSC_CP(list);
end);

INSTALLFLOATCREATOR("for ints", [IsCXSCBox,IsInt],
        function(filter,x)
    return CI_CXSC_RI_RI(NewFloat(IsCXSCInterval,x),0.0_I);
end);

DeclareConstructor("NewFloat", [IsCXSCBox,IsCXSCReal,IsCXSCReal]);
DeclareOperation("MakeFloat", [IsCXSCBox,IsCXSCReal,IsCXSCReal]);
DeclareConstructor("NewFloat", [IsCXSCBox,IsCXSCComplex,IsCXSCComplex]);
DeclareOperation("MakeFloat", [IsCXSCBox,IsCXSCComplex,IsCXSCComplex]);
DeclareConstructor("NewFloat", [IsCXSCBox,IsCXSCInterval,IsCXSCInterval]);
DeclareOperation("MakeFloat", [IsCXSCBox,IsCXSCInterval,IsCXSCInterval]);

INSTALLFLOATCREATOR("for two reals", [IsCXSCBox,IsCXSCReal,IsCXSCReal],
        function(filter,x,y)
    return CI_CXSC_CP(CP_CXSC_RP_RP(x,y));
end);
                
INSTALLFLOATCREATOR("for two complexes", [IsCXSCBox,IsCXSCComplex,IsCXSCComplex],
        function(filter,x,y)
    return CI_CXSC_CP_CP(x,y);
end);
                
INSTALLFLOATCREATOR("for two intervals", [IsCXSCBox,IsCXSCInterval,IsCXSCInterval],
        function(filter,x,y)
    return CI_CXSC_RI_RI(x,y);
end);
                
INSTALLFLOATCREATOR("for strings", [IsCXSCBox,IsString],
        function(filter,s)
    return CI_CXSC_STRING(s);
end);

INSTALLFLOATCREATOR("for a real", [IsCXSCBox,IsCXSCReal],
        function(filter,x)
    return CI_CXSC_CP(CP_CXSC_RP(x));
end);

INSTALLFLOATCREATOR("for a complex", [IsCXSCBox,IsCXSCComplex],
        function(filter,x)
    return CI_CXSC_CP(x);
end);

INSTALLFLOATCREATOR("for an interval", [IsCXSCBox,IsCXSCInterval],
        function(filter,x)
    return CI_CXSC_RI_RI(x,0.0_I);
end);

INSTALLFLOATCREATOR("for a box", [IsCXSCBox,IsCXSCBox],
        function(filter,x)
    return x;
end);

INSTALLFLOATCONSTRUCTORS(rec(filter:=IsCXSCBox));

#############################################################################
##
#E

[ Dauer der Verarbeitung: 0.37 Sekunden  (vorverarbeitet)  ]