search

crowlogic / arb4j

arb4j is a Java API for the arbitrary precision ball arithmetic library found at http://arblib.org
Other
1 stars 0 forks source link

HypergeometricPolynomial: NAryOperation's index variable getting mistaken for being the independent variable of a polynomial #393

Closed crowlogic closed 3 months ago

crowlogic commented 3 months ago

( i knew this was going to be an issue should be easy enough to resolve)

crowlogic commented 3 months ago 
parseRoot pFq([-2,3.5,1],[-2,3],1/2-x/2)
new class arb.expressions.nodes.unary.HypergeometricFunction at pos 4
new class arb.expressions.nodes.Vector at pos 5
new class arb.expressions.nodes.LiteralConstant at pos 7
new class arb.expressions.nodes.binary.Subtraction at pos 7
new class arb.expressions.nodes.LiteralConstant at pos 7
new class arb.expressions.nodes.LiteralConstant at pos 11
new class arb.expressions.nodes.LiteralConstant at pos 13
new class arb.expressions.nodes.Vector at pos 16
new class arb.expressions.nodes.LiteralConstant at pos 18
new class arb.expressions.nodes.binary.Subtraction at pos 18
new class arb.expressions.nodes.LiteralConstant at pos 18
new class arb.expressions.nodes.LiteralConstant at pos 20
new class arb.expressions.nodes.LiteralConstant at pos 23
new class arb.expressions.nodes.LiteralConstant at pos 25
new class arb.expressions.nodes.binary.Division at pos 25
new class arb.expressions.nodes.Variable at pos 27

Variable(#366590980).resolveReference(reference=x)
Checking if x is the indeterminant variable in a polynomial expression
Expression(#103536485) declaring x to be the indeterminant
variables=null
new class arb.expressions.nodes.LiteralConstant at pos 29
new class arb.expressions.nodes.binary.Division at pos 29
new class arb.expressions.nodes.binary.Subtraction at pos 29
Expression(#103536485).compile() className=pFqopensubminus2comma3point5comma1commasubminus2comma3comma1over2minusxover2close
Expression(#103536485) Generating pFq([-2,3.5,1],[-2,3],1/2-x/2)

Vector(#1371006431).generating 1-th element of type class arb.Integer
new class arb.expressions.nodes.LiteralConstant at pos 30
BinaryOperation.generate( this=0-2,
                          left=0,
                          left.type=class arb.Integer,
                          operation=sub,
                          right=2,
                          right.type=class arb.Integer,
                          resultType=class arb.Real )

Vector(#1371006431).generating 2-th element of type class arb.Real
Vector(#1371006431).generating 3-th element of type class arb.Integer
index 2: Converting from type class arb.Integer to class arb.Real
Vector(#107241811).generating 1-th element of type class arb.Integer
new class arb.expressions.nodes.LiteralConstant at pos 30
BinaryOperation.generate( this=0-2,
                          left=0,
                          left.type=class arb.Integer,
                          operation=sub,
                          right=2,
                          right.type=class arb.Integer,
                          resultType=class arb.Real )

Vector(#107241811).generating 2-th element of type class arb.Integer
index 1: Converting from type class arb.Integer to class arb.Real

Expression(#103536485).defineClass(expression=pFq([-2,3.5,1],[-2,3],1/2-x/2)
,className=pFqopensubminus2comma3point5comma1commasubminus2comma3comma1over2minusxover2close
, context=Context(#1582071873)[functions=FunctionMappings(#1908981452)[map={}] ,
 variables=Variables(#433287555)[[]]
, intermediateVariableCounters={vℝ=3, ℝ=5}])

Compiler.loadFunctionClass pFqopensubminus2comma3point5comma1commasubminus2comma3comma1over2minusxover2close
defineClass( className=pFqopensubminus2comma3point5comma1commasubminus2comma3comma1over2minusxover2close, ... )
parseRoot (1/2)-(x/2)
new class arb.expressions.nodes.LiteralConstant at pos 2
new class arb.expressions.nodes.LiteralConstant at pos 4
new class arb.expressions.nodes.binary.Division at pos 4
new class arb.expressions.nodes.Variable at pos 8

Variable(#2131952342).resolveReference(reference=x)
new class arb.expressions.nodes.LiteralConstant at pos 10
Declaring x as the input node to x➔(1/2)-(x/2) (Expression#1139700454)

new class arb.expressions.nodes.binary.Division at pos 10
new class arb.expressions.nodes.binary.Subtraction at pos 11
parseRoot Σn➔z^n*∏k➔α[k]₍ₙ₎{k=1…p}/(n!*∏k➔β[k]₍ₙ₎{k=1…q}){n=0…N}
new class arb.expressions.nodes.nary.Summation at pos 1
new class arb.expressions.nodes.LiteralConstant at pos 51
new class arb.expressions.nodes.Variable at pos 53

Variable(#384294141).resolveReference(reference=N)
Declaring N as a contextual variable of type class arb.Integer
F before substitution Σz^n*∏k➔α[k]₍ₙ₎{k=1…p}/(n!*∏k➔β[k]₍ₙ₎{k=1…q}){n=0…N} (Expression#1024597427)

need bewbs 1
need bewbs 2
need bewbs 1/2
need bewbs x
need bewbs 2
need bewbs x/2
need bewbs (1/2)-(x/2)
Expression(#1024597427).substitute x➔(1/2)-(x/2) (Expression#1139700454)
 for z into Σz^n*∏k➔α[k]₍ₙ₎{k=1…p}/(n!*∏k➔β[k]₍ₙ₎{k=1…q}){n=0…N} (Expression#1024597427)

 this.context=Context(#349420578)[functions=FunctionMappings(#315932542)[map={}] ,
 variables=Variables(#1277009227)[[p, q, α, β, N]]
, intermediateVariableCounters={}]
 substitution.context=null
Summation.assignFieldNames(resultType=class arb.RealPolynomial,
                           factorFunctionFieldName=factorXℝ1,
                           factorValueFieldName=valueXℝ1)

Summation.generateFactorClass( expr=z^n*∏k➔α[k]₍ₙ₎{k=1…p}/(n!*∏k➔β[k]₍ₙ₎{k=1…q}),resultType=class arb.RealPolynomial)

parseRoot z^n*∏k➔α[k]₍ₙ₎{k=1…p}/(n!*∏k➔β[k]₍ₙ₎{k=1…q})
new class arb.expressions.nodes.Variable at pos 1

Variable(#2065857933).resolveReference(reference=z)
Declaring z as the input node to z➔z^n*∏k➔α[k]₍ₙ₎{k=1…p}/(n!*∏k➔β[k]₍ₙ₎{k=1…q}) (Expression#1914301543)

new class arb.expressions.nodes.Variable at pos 3

Variable(#1708570683).resolveReference(reference=n)
Checking if n is the indeterminant variable in a polynomial expression
Expression(#1914301543) declaring n to be the indeterminant
variables=Variables(#1277009227)[[p, q, α, β, N]]
new class arb.expressions.nodes.binary.Exponentiation at pos 3
new class arb.expressions.nodes.nary.NaryMultiplication at pos 5
new class arb.expressions.nodes.LiteralConstant at pos 18
new class arb.expressions.nodes.Variable at pos 20

Variable(#2045766957).resolveReference(reference=p)
Declaring p as a contextual variable of type class arb.Integer
new class arb.expressions.nodes.binary.Multiplication at pos 21
new class arb.expressions.nodes.Variable at pos 24

Variable(#690521419).resolveReference(reference=n)
Checking if n is the indeterminant variable in a polynomial expression
Expression(#1914301543) declaring n to be the indeterminant
variables=Variables(#1277009227)[[p, q, α, β, N]]
new class arb.expressions.nodes.unary.Factorialization at pos 25

Variable(#690521419).resolveReference(reference=n)
Checking if n is the indeterminant variable in a polynomial expression
Expression(#1914301543) declaring n to be the indeterminant
variables=Variables(#1277009227)[[p, q, α, β, N]]
new class arb.expressions.nodes.nary.NaryMultiplication at pos 27
new class arb.expressions.nodes.LiteralConstant at pos 40
new class arb.expressions.nodes.Variable at pos 42

Variable(#689401025).resolveReference(reference=q)
Declaring q as a contextual variable of type class arb.Integer
new class arb.expressions.nodes.binary.Multiplication at pos 43
new class arb.expressions.nodes.binary.Division at pos 44

Expression(#1914301543).defineClass(expression=z^n*∏k➔α[k]₍ₙ₎{k=1…p}/(n!*∏k➔β[k]₍ₙ₎{k=1…q})
,className=factorXℝ1
, context=Context(#349420578)[functions=FunctionMappings(#315932542)[map={}] ,
 variables=Variables(#1277009227)[[p, q, α, β, N]]
, intermediateVariableCounters={valueXℝ=2, factorXℝ=2}])

Expression(#1914301543).compile() className=factorXℝ1
Expression(#1914301543) Generating z^n*∏k➔α[k]₍ₙ₎{k=1…p}/(n!*∏k➔β[k]₍ₙ₎{k=1…q})

Variable(#1708570683).resolveReference(reference=n)
Checking if n is the indeterminant variable in a polynomial expression
Expression(#1914301543) declaring n to be the indeterminant
variables=Variables(#1277009227)[[p, q, α, β, N]]
BinaryOperation.generate( this=((z^n)*Πα[k]₍ₙ₎{k=1…p})/((n!)*Πβ[k]₍ₙ₎{k=1…q}),
                          left=(z^n)*Πα[k]₍ₙ₎{k=1…p},
                          left.type=class arb.RealPolynomial,
                          operation=div,
                          right=(n!)*Πβ[k]₍ₙ₎{k=1…q},
                          right.type=class arb.Real,
                          resultType=class arb.RealPolynomial )

BinaryOperation.generate( this=(z^n)*Πα[k]₍ₙ₎{k=1…p},
                          left=z^n,
                          left.type=class arb.RealPolynomial,
                          operation=mul,
                          right=Πα[k]₍ₙ₎{k=1…p},
                          right.type=class arb.Real,
                          resultType=class arb.RealPolynomial )

BinaryOperation.generate( this=z^n,
                          left=z,
                          left.type=class arb.Integer,
                          operation=pow,
                          right=n,
                          right.type=class arb.RealPolynomial,
                          resultType=class arb.RealPolynomial )

Variable(#2065857933).generate( this=z, resultType=class arb.Integer)

Variable(#1708570683).generate( this=n, resultType=class arb.RealPolynomial)

NaryMultiplication.assignFieldNames(resultType=class arb.Real,
                                    factorFunctionFieldName=factorℝ1,
                                    factorValueFieldName=valueℝ1)

NaryMultiplication.generateFactorClass( expr=k➔α[k]₍ₙ₎,resultType=class arb.Real)

new class arb.expressions.nodes.Variable at pos -1

Variable(#1769193365).resolveReference(reference=k)
Declaring k as the input node to k➔k➔α[k]₍ₙ₎ (Expression#769429195)

parseRoot k➔α[k]₍ₙ₎
new class arb.expressions.nodes.Variable at pos 5

Variable(#580718781).resolveReference(reference=k)
Declaring k as the input node to k➔k➔α[k]₍ₙ₎ (Expression#769429195)

new class arb.expressions.nodes.Variable at pos 6

Variable(#1196695891).resolveReference(reference=α[k])
Declaring α[k] as a contextual variable of type class arb.Real
new class arb.expressions.nodes.Variable at pos 8

Variable(#867148091).resolveReference(reference=n)
Checking if n is the indeterminant variable in a polynomial expression
Expression(#769429195) declaring n to be the indeterminant
variables=Variables(#1277009227)[[p, q, α, β, N]]
new class arb.expressions.nodes.binary.AscendingFactorialization at pos 9

Expression(#769429195).defineClass(expression=k➔α[k]₍ₙ₎
,className=factorℝ1
, context=Context(#349420578)[functions=FunctionMappings(#315932542)[map={}] ,
 variables=Variables(#1277009227)[[p, q, α, β, N]]
, intermediateVariableCounters={Xℝ=2, factorℝ=2, valueXℝ=2, valueℝ=2, factorXℝ=2}])

Expression(#769429195).compile() className=factorℝ1
Expression(#769429195) Generating k➔α[k]₍ₙ₎

Variable(#867148091).resolveReference(reference=n)
Checking if n is the indeterminant variable in a polynomial expression
Expression(#769429195) declaring n to be the indeterminant
variables=Variables(#1277009227)[[p, q, α, β, N]]
BinaryOperation.generate( this=α[k]⋰n,
                          left=α[k],
                          left.type=class arb.Real,
                          operation=ascendingFactorial,
                          right=n,
                          right.type=class arb.RealPolynomial,
                          resultType=class arb.Real )

Variable(#1196695891).generate( this=α[k], resultType=class arb.Real)

Variable(#580718781).generate( this=k, resultType=class arb.Integer)

Variable(#867148091).generate( this=n, resultType=class arb.RealPolynomial)

Declaring variable of factorℝ1: p=p=3
Declaring variable of factorℝ1: q=q=2
Declaring variable of factorℝ1: α=α=[-2, 3.5, 1]
Declaring variable of factorℝ1: β=β=[-2, 3]
Declaring variable of factorℝ1: N=0
Compiler.loadFunctionClass factorℝ1
defineClass( className=factorℝ1, ... )
Context(#349420578).registerFunction( functionName = factorℝ1, function = factorℝ1:k➔α[k]₍ₙ₎, domainType=class arb.Integer, rangeType=class arb.Real )
NaryMultiplication.propagateInputToFactorClass( factorFunctionFieldName=factorℝ1,
                                                independentVariableNode=z,
                                                independentVariableNode.type=class arb.Integer)

NAryOperation.getField(functionClass=factorXℝ1,
         fieldName=k,
         fieldTypeSignature=Larb/Integer;

Variable(#2045766957).generate( this=p, resultType=class arb.Integer)

NaryMultiplication.designateLabel( label=L1671846437,
                                   addTypeToStackMap=false)

NaryMultiplication.loadResultvariable( resultVariable= prodℝ1, generatedType=class arb.Real )
NAryOperation.getField(functionClass=factorXℝ1,
         fieldName=k,
         fieldTypeSignature=Larb/Integer;

NaryMultiplication.loadResultvariable( resultVariable= prodℝ1, generatedType=class arb.Real )
BinaryOperation.generate( this=(n!)*Πβ[k]₍ₙ₎{k=1…q},
                          left=n!,
                          left.type=class arb.Integer,
                          operation=mul,
                          right=Πβ[k]₍ₙ₎{k=1…q},
                          right.type=class arb.Real,
                          resultType=class arb.Real )

FunctionCall.generate: this=n! resultType=class arb.Integer

Variable(#690521419).generate( this=n, resultType=class arb.RealPolynomial)

NaryMultiplication.assignFieldNames(resultType=class arb.Real,
                                    factorFunctionFieldName=factorℝ2,
                                    factorValueFieldName=valueℝ2)

NaryMultiplication.generateFactorClass( expr=k➔β[k]₍ₙ₎,resultType=class arb.Real)

new class arb.expressions.nodes.Variable at pos -1

Variable(#1422222071).resolveReference(reference=k)
Declaring k as the input node to k➔k➔β[k]₍ₙ₎ (Expression#831236296)

parseRoot k➔β[k]₍ₙ₎
new class arb.expressions.nodes.Variable at pos 5

Variable(#1840976765).resolveReference(reference=k)
Declaring k as the input node to k➔k➔β[k]₍ₙ₎ (Expression#831236296)

new class arb.expressions.nodes.Variable at pos 6

Variable(#1016925085).resolveReference(reference=β[k])
Declaring β[k] as a contextual variable of type class arb.Real
new class arb.expressions.nodes.Variable at pos 8

Variable(#1127224355).resolveReference(reference=n)
Checking if n is the indeterminant variable in a polynomial expression
Expression(#831236296) declaring n to be the indeterminant
variables=Variables(#1277009227)[[p, q, α, β, N]]
new class arb.expressions.nodes.binary.AscendingFactorialization at pos 9

Expression(#831236296).defineClass(expression=k➔β[k]₍ₙ₎
,className=factorℝ2
, context=Context(#349420578)[functions=FunctionMappings(#315932542)[map={factorℝ1=FunctionMapping(#789653861)[name=factorℝ1,
 instance=factorℝ1:k➔α[k]₍ₙ₎,
 domain=arb.Integer,
 range=arb.Real,
 functionInterface=interface arb.functions.Function]}] ,
 variables=Variables(#1277009227)[[p, q, α, β, N]]
, intermediateVariableCounters={endIndexℤ=2, ℤ=2, Xℝ=3, factorℝ=3, valueXℝ=2, valueℝ=3, prodℝ=2, factorXℝ=2}])

Expression(#831236296).compile() className=factorℝ2
Expression(#831236296) Generating k➔β[k]₍ₙ₎

Variable(#1127224355).resolveReference(reference=n)
Checking if n is the indeterminant variable in a polynomial expression
Expression(#831236296) declaring n to be the indeterminant
variables=Variables(#1277009227)[[p, q, α, β, N]]
BinaryOperation.generate( this=β[k]⋰n,
                          left=β[k],
                          left.type=class arb.Real,
                          operation=ascendingFactorial,
                          right=n,
                          right.type=class arb.RealPolynomial,
                          resultType=class arb.Real )

Variable(#1016925085).generate( this=β[k], resultType=class arb.Real)

Variable(#1840976765).generate( this=k, resultType=class arb.Integer)

Variable(#1127224355).generate( this=n, resultType=class arb.RealPolynomial)

Declaring variable of factorℝ2: p=p=3
Declaring variable of factorℝ2: q=q=2
Declaring variable of factorℝ2: α=α=[-2, 3.5, 1]
Declaring variable of factorℝ2: β=β=[-2, 3]
Declaring variable of factorℝ2: N=0
Compiler.loadFunctionClass factorℝ2
defineClass( className=factorℝ2, ... )
Context(#349420578).registerFunction( functionName = factorℝ2, function = factorℝ2:k➔β[k]₍ₙ₎, domainType=class arb.Integer, rangeType=class arb.Real )
NaryMultiplication.propagateInputToFactorClass( factorFunctionFieldName=factorℝ2,
                                                independentVariableNode=z,
                                                independentVariableNode.type=class arb.Integer)

NAryOperation.getField(functionClass=factorXℝ1,
         fieldName=k,
         fieldTypeSignature=Larb/Integer;

Variable(#689401025).generate( this=q, resultType=class arb.Integer)

NaryMultiplication.designateLabel( label=L733943822,
                                   addTypeToStackMap=false)

NaryMultiplication.loadResultvariable( resultVariable= prodℝ2, generatedType=class arb.Real )
NAryOperation.getField(functionClass=factorXℝ1,
         fieldName=k,
         fieldTypeSignature=Larb/Integer;

NaryMultiplication.loadResultvariable( resultVariable= prodℝ2, generatedType=class arb.Real )
Declaring variable of factorXℝ1: p=p=3
Declaring variable of factorXℝ1: q=q=2
Declaring variable of factorXℝ1: α=α=[-2, 3.5, 1]
Declaring variable of factorXℝ1: β=β=[-2, 3]
Declaring variable of factorXℝ1: N=0
Compiler.loadFunctionClass factorXℝ1
defineClass( className=factorXℝ1, ... )
Context(#349420578).registerFunction( functionName = factorXℝ1, function = factorXℝ1:z^n*∏k➔α[k]₍ₙ₎{k=1…p}/(n!*∏k➔β[k]₍ₙ₎{k=1…q}), domainType=class arb.Integer, rangeType=class arb.RealPolynomial )
arb.expressions.nodes.nary.Summation Substituting (1/2)-(x/2) for z in Σz^n*∏k➔α[k]₍ₙ₎{k=1…p}/(n!*∏k➔β[k]₍ₙ₎{k=1…q}){n=0…N} (Expression#1024597427)

BinaryOperation.substitute(name=z, transformation=(1/2)-(x/2)) into this=((z^n)*Πα[k]₍ₙ₎{k=1…p})/((n!)*Πβ[k]₍ₙ₎{k=1…q})
BinaryOperation.substitute(name=z, transformation=(1/2)-(x/2)) into this=(z^n)*Πα[k]₍ₙ₎{k=1…p}
BinaryOperation.substitute(name=z, transformation=(1/2)-(x/2)) into this=z^n
BinaryOperation.substituteOperand (1/2)-(x/2) for z in z^n of Expression(#1914301543)
new class arb.expressions.nodes.LiteralConstant at pos 11
new class arb.expressions.nodes.LiteralConstant at pos 11
new class arb.expressions.nodes.binary.Division at pos 11
new class arb.expressions.nodes.Variable at pos 11

Variable(#1637061418).resolveReference(reference=x)
Declaring x as the input node to x➔(1/2)-(x/2) (Expression#1139700454)

new class arb.expressions.nodes.LiteralConstant at pos 11
new class arb.expressions.nodes.binary.Division at pos 11
new class arb.expressions.nodes.binary.Subtraction at pos 11
factorExpression is already set to k➔α[k]⋰n (Expression#769429195)
 and factorExpressionString is α[k]₍ₙ₎
arb.expressions.nodes.nary.NaryMultiplication Substituting (1/2)-(x/2) for z in z➔((((1/2)-(x/2))^n)*Πα[k]₍ₙ₎{k=1…p})/((n!)*Πβ[k]₍ₙ₎{k=1…q}) (Expression#1914301543)

BinaryOperation.substitute(name=z, transformation=(1/2)-(x/2)) into this=α[k]⋰n
BinaryOperation.substitute(name=z, transformation=(1/2)-(x/2)) into this=(n!)*Πβ[k]₍ₙ₎{k=1…q}
factorExpression is already set to k➔β[k]⋰n (Expression#831236296)
 and factorExpressionString is β[k]₍ₙ₎
arb.expressions.nodes.nary.NaryMultiplication Substituting (1/2)-(x/2) for z in z➔((((1/2)-(x/2))^n)*Πα[k]₍ₙ₎{k=1…p})/(n*Πβ[k]₍ₙ₎{k=1…q}) (Expression#1914301543)

BinaryOperation.substitute(name=z, transformation=(1/2)-(x/2)) into this=β[k]⋰n
before subst: Σz^n*∏k➔α[k]₍ₙ₎{k=1…p}/(n!*∏k➔β[k]₍ₙ₎{k=1…q}){n=0…N}
after subst: Σz^n*∏k➔α[k]₍ₙ₎{k=1…p}/(n!*∏k➔β[k]₍ₙ₎{k=1…q}){n=0…N}
F after substitution Σz^n*∏k➔α[k]₍ₙ₎{k=1…p}/(n!*∏k➔β[k]₍ₙ₎{k=1…q}){n=0…N} (Expression#1024597427)

Expression(#1024597427).defineClass(expression=Σn➔z^n*∏k➔α[k]₍ₙ₎{k=1…p}/(n!*∏k➔β[k]₍ₙ₎{k=1…q}){n=0…N}
,className=F
, context=Context(#349420578)[functions=FunctionMappings(#315932542)[map={factorℝ2=FunctionMapping(#1686100174)[name=factorℝ2,
 instance=factorℝ2:k➔β[k]₍ₙ₎,
 domain=arb.Integer,
 range=arb.Real,
 functionInterface=interface arb.functions.Function], factorXℝ1=FunctionMapping(#22671767)[name=factorXℝ1,
 instance=factorXℝ1:z^n*∏k➔α[k]₍ₙ₎{k=1…p}/(n!*∏k➔β[k]₍ₙ₎{k=1…q}),
 domain=arb.Integer,
 range=arb.RealPolynomial,
 functionInterface=interface arb.functions.Function], factorℝ1=FunctionMapping(#789653861)[name=factorℝ1,
 instance=factorℝ1:k➔α[k]₍ₙ₎,
 domain=arb.Integer,
 range=arb.Real,
 functionInterface=interface arb.functions.Function]}] ,
 variables=Variables(#1277009227)[[p, q, α, β, N]]
, intermediateVariableCounters={endIndexℤ=3, ℤ=2, Xℝ=3, factorℝ=3, valueXℝ=2, valueℝ=3, prodℝ=3, ℝ=2, factorXℝ=2}])

Expression(#1024597427).compile() className=F
Expression(#1024597427) Generating Σn➔z^n*∏k➔α[k]₍ₙ₎{k=1…p}/(n!*∏k➔β[k]₍ₙ₎{k=1…q}){n=0…N}

NAryOperation.getField(functionClass=F,
         fieldName=n,
         fieldTypeSignature=Larb/Integer;

Variable(#384294141).generate( this=N, resultType=class arb.Integer)

Summation.designateLabel( label=L2024453272,
                                   addTypeToStackMap=false)

Summation.loadResultvariable( resultVariable= sumXℝ1, generatedType=class arb.RealPolynomial )
NAryOperation.getField(functionClass=F,
         fieldName=n,
         fieldTypeSignature=Larb/Integer;

Summation.loadResultvariable( resultVariable= sumXℝ1, generatedType=class arb.RealPolynomial )
Declaring variable of F: p=p=3
Declaring variable of F: q=q=2
Declaring variable of F: α=α=[-2, 3.5, 1]
Declaring variable of F: β=β=[-2, 3]
Declaring variable of F: N=0
Compiler.loadFunctionClass F
defineClass( className=F, ... )