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

cache resolved variables #433

Closed crowlogic closed 1 month ago

crowlogic commented 1 month ago 
parseRoot n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2) of Expression(#1381713434)

Variable(#192881625).resolveReference(reference=v) expression=n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2)

Declaring v as a contextual variable of type class arb.Real

Variable(#992768706).resolveReference(reference=n) expression=n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2)

Variable(#992768706).resolveIndependentVariable: declaring n as the input node to n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2) which currently has input variable n

Variable(#2075495587).resolveReference(reference=z) expression=n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2)

Expression(#1381713434) declaring z to be the indeterminant in n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2)
variables=Variables(#206835546)[[v]]

Variable(#1279309678).resolveReference(reference=n) expression=n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2)

Variable(#1279309678).resolveIndependentVariable: declaring n as the input node to n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2) which currently has input variable n

Variable(#360067785).resolveReference(reference=n) expression=n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2)

Variable(#360067785).resolveIndependentVariable: declaring n as the input node to n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2) which currently has input variable n

Variable(#1860250540).resolveReference(reference=n) expression=n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2)

Variable(#1860250540).resolveIndependentVariable: declaring n as the input node to n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2) which currently has input variable n

Variable(#1426329391).resolveReference(reference=v) expression=n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2)

Declaring v as a contextual variable of type class arb.Real

Variable(#1690859824).resolveReference(reference=n) expression=n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2)

Variable(#1690859824).resolveIndependentVariable: declaring n as the input node to n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2) which currently has input variable n

Variable(#1074593562).resolveReference(reference=v) expression=n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2)

Declaring v as a contextual variable of type class arb.Real

Variable(#660017404).resolveReference(reference=n) expression=n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2)

Variable(#660017404).resolveIndependentVariable: declaring n as the input node to n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2) which currently has input variable n

Variable(#1381965390).resolveReference(reference=z) expression=n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2)

Expression(#1381713434) declaring z to be the indeterminant in n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2)
variables=Variables(#206835546)[[v]]

-- ((v⋰n)*((z/2)^(-n)))*(pFq(-z^2))
   |-- (v⋰n)*((z/2)^(-n))
   |   |-- v⋰n
   |   |   |-- v
   |   |   ⋰-- n
   |   *-- (z/2)^(-n)
   |      |-- z/2
   |      |   |-- z
   |      |   /-- 2
   |      ^-- -n
   |         f-- n
   *-- pFq(-z^2)
      f-- -z^2
         f-- z^2
            |-- z
            ^-- 2

Instantiating n➔((v⋰n)*((z/2)^(-n)))*(pFq(-z^2))

Expression(#1381713434).defineClass(expression=n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2)
,className=R
, context=Context(#1452012306)[functions=[],variables=[v]])

Expression(#1381713434).generate() className=R

Expression(#1381713434) Generating n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2)

BinaryOperation.generate( this=((v⋰n)*((z/2)^(-n)))*(pFq(-z^2)),
                          left=(v⋰n)*((z/2)^(-n)),
                          left.type=class arb.RealQuasiPolynomial,
                          operation=mul,
                          right=pFq(-z^2),
                          right.type=class arb.RealQuasiPolynomial,
                          resultType=class arb.RealQuasiPolynomial )

BinaryOperation.generate( this=(v⋰n)*((z/2)^(-n)),
                          left=v⋰n,
                          left.type=class arb.Real,
                          operation=mul,
                          right=(z/2)^(-n),
                          right.type=class arb.RealQuasiPolynomial,
                          resultType=class arb.RealQuasiPolynomial )

BinaryOperation.generate( this=v⋰n,
                          left=v,
                          left.type=class arb.Real,
                          operation=ascendingFactorial,
                          right=n,
                          right.type=class arb.Integer,
                          resultType=class arb.Real )

Variable(#192881625).generate( this=v, resultType=class arb.Real)

Variable(#992768706).generate( this=n, resultType=class arb.Integer)

BinaryOperation.generate( this=(z/2)^(-n),
                          left=z/2,
                          left.type=class arb.RealQuasiPolynomial,
                          operation=pow,
                          right=-n,
                          right.type=class arb.RealQuasiPolynomial,
                          resultType=class arb.RealQuasiPolynomial )

BinaryOperation.generate( this=z/2,
                          left=z,
                          left.type=class arb.RealQuasiPolynomial,
                          operation=div,
                          right=2,
                          right.type=class arb.Integer,
                          resultType=class arb.RealQuasiPolynomial )

Variable(#2075495587).generate( this=z, resultType=class arb.RealQuasiPolynomial)

FunctionCall.generate: this=-n resultType=class arb.RealQuasiPolynomial

Variable(#1279309678).generate( this=n, resultType=class arb.Integer)

pFq.generate(resultType=class arb.RealQuasiPolynomial
)
pFq.isQuasiPolynomial=true
Vector(#558922244).generating 1-th element of node class arb.expressions.nodes.binary.Subtraction whose type is class arb.Real:  (1/2)-(n/2)
BinaryOperation.generate( this=(1/2)-(n/2),
                          left=1/2,
                          left.type=class arb.Real,
                          operation=sub,
                          right=n/2,
                          right.type=class arb.Real,
                          resultType=class arb.Real )

BinaryOperation.generate( this=1/2,
                          left=1,
                          left.type=class arb.Integer,
                          operation=div,
                          right=2,
                          right.type=class arb.Integer,
                          resultType=class arb.Real )

BinaryOperation.generate( this=n/2,
                          left=n,
                          left.type=class arb.Integer,
                          operation=div,
                          right=2,
                          right.type=class arb.Integer,
                          resultType=class arb.Real )

Variable(#360067785).generate( this=n, resultType=class arb.Integer)

Vector(#558922244).generating 2-th element of node class arb.expressions.nodes.unary.Negation whose type is class arb.RealQuasiPolynomial:  -n/2
FunctionCall.generate: this=-n/2 resultType=class arb.Real

BinaryOperation.generate( this=n/2,
                          left=n,
                          left.type=class arb.Integer,
                          operation=div,
                          right=2,
                          right.type=class arb.Integer,
                          resultType=class arb.Real )

Variable(#1860250540).generate( this=n, resultType=class arb.Integer)

Vector(#339099861).generating 1-th element of node class arb.expressions.nodes.Variable whose type is class arb.Real:  v
Variable(#1426329391).generate( this=v, resultType=class arb.Real)

Vector(#339099861).generating 2-th element of node class arb.expressions.nodes.unary.Negation whose type is class arb.RealQuasiPolynomial:  -n
FunctionCall.generate: this=-n resultType=class arb.Real

Variable(#1690859824).generate( this=n, resultType=class arb.Integer)

Vector(#339099861).generating 3-th element of node class arb.expressions.nodes.binary.Subtraction whose type is class arb.Real:  (1-v)-n
BinaryOperation.generate( this=(1-v)-n,
                          left=1-v,
                          left.type=class arb.Real,
                          operation=sub,
                          right=n,
                          right.type=class arb.Integer,
                          resultType=class arb.Real )

BinaryOperation.generate( this=1-v,
                          left=1,
                          left.type=class arb.Integer,
                          operation=sub,
                          right=v,
                          right.type=class arb.Real,
                          resultType=class arb.Real )

Variable(#1074593562).generate( this=v, resultType=class arb.Real)

Variable(#660017404).generate( this=n, resultType=class arb.Integer)

Declaring variable of R: v=v=0.5
referencedFunctions={}
generateToStringMethod(expression=n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2))
generateTypesetMethod(expression=n➔v₍ₙ₎*(z/2)^(-n)*pFq([1/2-n/2,-n/2],[v,-n,1-v-n],-z^2))
Compiler.loadFunctionClass R
defineClass( className=R, ... )
compiledClasses.keys=[]

Injecting references n➔((v⋰n)*((z/2)^(-n)))*(pFq(-z^2))
Context(#1452012306).injectVariableReferences(f=R)