jodavies
commented
11 months ago Hi Vlad,
I usually do a little bit more in Mathematica before creating the Fill statements. I Collect against the integral function names on the RHS of the rules, and apply something like GCoeffSimplify2 to the coefficients.
ep does not end up in the prf, which helps stop the terms becoming too big for FORM (and I will later expand in ep in FORM with a routine which acts on the "denep" denominators). If I am expanding in more symbols than just ep, I arrange that they end up in their own "den..." functions also. Then the prf functions contain only symbols which won't be expanded later.
Since performance on the Mathematica side can be an issue for large tables I split each reduction table into many parts and process each part in parallel.
(* Slightly modified, from Arnd Behring *)
crCollect[expr_,pat_,f_:Identity]:=
Module[{patalt,vars,res},
If[expr===0,
Return[f[expr]]
];
patalt=If[Head[pat]===List,Alternatives@@pat,pat];
vars=Union@Cases[expr,patalt,{0,Infinity}];
If[Length[vars]===0,
Return[f[expr]]
];
res=CoefficientRules[expr,vars];
res=Map[Apply[Times,vars^#[[1]]]*f[#[[2]]]&,res];
res=Total[res];
Return[res]
];
GCoeffSimplify2[x_] := Module[{numer,denom,coeff},
coeff = Together[x];
numer = Collect[Numerator[coeff], ep,
num
];
denom = FactorList[Denominator[coeff]];
denom = Map[
(#/.{
{a_/;ContainsAll[Variables[a],{ep}], p_}:>denep[a]^p,
{a_ /; ContainsNone[Variables[a], {ep}], p_} :> den[a]^p
})&
,
denom
];
denom = denom/.List->Times;
coeff = crCollect[numer*denom, {ep,_denep},
(prf[Numerator[#],Denominator[#]]& @ Factor[Together[#/.{num[a_]->a,den[b_]->1/b}]])&
]/.{denep[ep]->1/ep};
Return[coeff];
];As you suggest, you can alternatively create expressions instead of fill statements (wrapping the names in [] makes life much easier here...) and process them in FORM with InParallel; helping performance when processing many tiny expressions. Those results can be converted to fill statements with some simple regex.
vermaseren
vsht
Dear FORM experts,
I apologize if this has already been discussed/asked somewhere else, but I'm just wondering whether there is a straightforward way to apply
polyratfuntofillstatements that are used to populate atablebase.My use case is as follows: I do reduction with FIRE and employ a lightweight Mathematica script that converts the content of the reduction tables into
fillstatements. Since the rational coefficients in front of the masters can be quite complicated, I merely expand them (withDistribute) to make sure that each coefficient can be split into a propernumanddenomfunctions. So no factorization within Mathematica takes place and this task is entirely offloaded to FORM. Here is an example of the output my script producesIn this fashion I can apply
polyratfunonly after having substituted the reduction results into my amplitude. This is obviously not very efficient and I was thinking that it would have been much better to do this in advance.On the other hand, converting each reduction rule into a local variable, applying
polyratfunand then creating afillstatement out of it looks a bit too contrived to me. So perhaps there is a more natural way to integrate FIRE results into a FORM calculation that I'm not aware of.Cheers, Vlad