File size: 478,000 Bytes
803451e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | {"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\n#IsDigit := c -> c in \"0123456789\";\n#var.prefix := meth( self )\n# local p;\n# p := FirstPosition(self.id,IsDigit);\n# p := SplitAt(self.id,When(p>0,p-1,0))[1];\n# Constraint(p <> \"\");\n# return p;\n#end;\n\nClass(VarGenBase, rec(\n __call__ := self >> WithBases(self, rec(counter:=rec(), pfx := \"\")),\n\n suffix := n -> StringInt(n),\n\n reset := meth(self) self.counter := rec(); end,\n\n nextu := (self, t) >> When(self.pfx=\"\", self.next(t, \"u\"), self.next(t, \"\")),\n\n next := meth(self, t, pfx)\n local p;\n\tConstraint(IsString(pfx)); Constraint(IsType(t));\n\tpfx := Concat(self.pfx, pfx);\n\tif not IsBound(self.counter.(pfx)) then \n # first will be plain \"pfx\", then \"pfx2\" \n\t p := self.var(t, pfx); \n\t self.counter.(pfx) := 2;\n\telse\n\t p := self.var(t, Concat(pfx, self.suffix(self.counter.(pfx))));\n\t self.counter.(pfx) := self.counter.(pfx) + 1;\n\tfi;\n\treturn p;\n end,\n\n nextName := (self, pfx) >> self.next(TInt, pfx).id,\n \n var := (t, pfx) -> Error(\"must be implemented in subclasses\"),\n\n # creates a cloned generator with aliased .counter, and an extra prefix\n # that will be added to all params created with .next()\n withPrefix := (self, pfx) >> When(\n pfx=\"i\",\n Error(\"i prefix is RESERVED for loop variables!\"),\n WithBases(self, rec(pfx := Concat(self.pfx, pfx))))\n));\n\n\nClass(VarGenNumeric, VarGenBase, rec(\n var := (t, name) -> var(name, t)\n));\n\n\nClass(VarGenSymbolic, VarGenBase, rec(\n var := (t, name) -> var(name, t),\n suffix := VarNameInt\n));\n\n\nClass(ParamGenNumeric, VarGenBase, rec(\n var := (t, name) -> param(t, name)\n));\n\n\nClass(ParamGenSymbolic, VarGenBase, rec(\n var := (t, name) -> param(t, name),\n suffix := VarNameInt\n));\n\n\nClass(NewInt,rec(\n\t__call__ := meth(self)\n\t self.n := self.n + 1;\n\t return self.n;\n\tend,\n\n\tn := 0,\n));\n\n\nClass(VarMapper, rec(\n __call__ := (self, vargen) >> WithBases(self, rec(\n\t sn := NewInt(),\n\t bindings := tab(),\n\t vargen := vargen)),\n\n reset := meth(self)\n\tself.vargen.reset();\n\tself.bindings := tab();\n\tself.sn := NewInt();\n end,\n\n ignore := (self, var) >> false,\n\n alreadyMapped := (self,var) >> IsBound(var.sn) and var.sn = self.sn,\n\n map := meth(self, var) \n local newvar;\n\tif self.ignore(var) or (IsBound(var.NoReMap) and var.NoReMap) or self.alreadyMapped(var) then\n\t return var;\n\tfi;\n if IsBound(self.bindings.(var.id)) then \n\t return self.bindings.(var.id);\n\telse\n\t newvar := self.vargen.next(var.t, var.id{[1]});\n\t newvar.sn := self.sn;\n\t self.bindings.(var.id):=newvar;\n\t return newvar;\n\tfi;\n end\n));\n\nProperName := function(o)\n o.properName := true;\n return o;\nend;\n\n_RemapVars := function(c, ignore_list, varGen )\n local vmapper;\n vmapper := CopyFields(VarMapper(varGen), \n rec(ignore := (self, var) >> IsBound(var.properName) and var.properName=true\n or var.id in ignore_list));\n return SubstTopDownRules(c, [\n\t [var,v->vmapper.map(v)],\n\t [decl,d->decl(List(d.vars,v->vmapper.map(v)),d.cmd)],\n\t [data,d->data(vmapper.map(d.var),d.value,d.cmd)] ]);\nend;\n\nRemapVars := c -> _RemapVars(c, [\"X\", \"Y\"], VarGenNumeric);\n\nRemapVarsIgnore := (c, ignore_list) -> _RemapVars(c, Concatenation([\"X\", \"Y\"], ignore_list));\n\nRemapVarsSafe := function(c, ignore_list)\n local free, args, init;\n free := c.free();\n args := Set(ConcatList( Collect(c, @(1, [func])), x->x.params));\n init := Collect(c, @(1, [var,param], x->IsBound(x.value) or IsBound(x.init))); # .value and .init: this is a hack!\n return _RemapVars(c, List(free::args, x->x.id) :: init :: ignore_list, ParamGenSymbolic());\nend;\n\n\nClass(RemoveUnusedVars,rec(__call__:=function(code)\n local usedvars,declvars,unusedvars;\n \n usedvars := Set(Flat([\n\t\t \tCollect(code,var)\t# all used vars in operands of assign-cmds\n\t\t]));\n\n declvars := Set(Flat([\n## \t\t\t X, Y, # implicitly they are arguments of DFT kernel\n\t\t\t List(Collect(code,decl),d->d.vars)\n\t\t]));\n\n unusedvars := declvars;\n SubtractSet(unusedvars,usedvars);\n\n # remove unused vars\n\tcode := SubstTopDown(code,decl,d->decl(Difference(d.vars, unusedvars),d.cmd));\n\n return code;\nend));\n\n## # Maybe, it would be usefull to add someting else to remove unused loops, data...\n## Class(RemoveUnused...,rec(__call__:=function(code)\n## local usedvars,declvars,unusedvars,v;\n## declvars := Set(Flat([\n## \t\t\t List(Collect(code,data),d->d.var),\n## \t\t\t List(Collect(code,loop),l->l.var)\n## \t\t]));\n## unusedvars := declvars;\n## SubtractSet(unusedvars,usedvars);\n## \n##\t\t\t# NOTE: prefixes for data and loop var-names?\n## for v in unusedvars do\n## if v.id[1] = 'D' then\n## code := SubstTopDown(code,data,d->Cond(d.var=v,d.cmd,d));\n## elif v.id[1] = 'i' then\n## code := SubstTopDown(code,loop,d->Cond(d.var=v,d.cmd,d));\n## else # decls\n## code := SubstTopDown(code,decl,d->decl(RemoveList(d.vars,v),d.cmd));\n## fi;\n## od;\n", "meta": {"hexsha": "5fdb14ab590596ac89ba091c2ebb7e157dfe81de", "size": 5126, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/code/gen.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/code/gen.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/code/gen.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 27.5591397849, "max_line_length": 118, "alphanum_fraction": 0.5926648459, "num_tokens": 1531, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4416730056646256, "lm_q2_score": 0.09670578743859412, "lm_q1q2_score": 0.04271233580316826}}
{"text": "#############################################################################\n####\n##\n#A anusp.gi ANUPQ package Eamonn O'Brien\n#A Alice Niemeyer \n##\n#Y Copyright 1993-2001, Lehrstuhl D fuer Mathematik, RWTH Aachen, Germany\n#Y Copyright 1993-2001, School of Mathematical Sciences, ANU, Australia\n##\n\n#############################################################################\n##\n#F ANUPQSPerror( <param> ) . . . . . . . . . . . . report illegal parameter\n##\nInstallGlobalFunction( ANUPQSPerror, function( param )\n Error(\n \"Valid Options:\\n\",\n \" \\\"ClassBound\\\", <bound>\\n\",\n \" \\\"PcgsAutomorphisms\\\"\\n\",\n \" \\\"Exponent\\\", <exponent>\\n\",\n \" \\\"Metabelian\\\"\\n\",\n \" \\\"OutputLevel\\\", <level>\\n\",\n \" \\\"SetupFile\\\", <file>\\n\",\n \"Illegal Parameter: \\\"\", param, \"\\\"\" );\nend );\n\n#############################################################################\n##\n#F ANUPQSPextractArgs( <args> ) . . . . . . . . . . . . parse argument list\n##\nInstallGlobalFunction( ANUPQSPextractArgs, function( args )\n local CR, i, act, G, match;\n\n # allow to give only a prefix\n match := function( g, w )\n \treturn 1 < Length(g) and \n Length(g) <= Length(w) and \n w{[1..Length(g)]} = g;\n end;\n\n # extract arguments\n G := args[2];\n CR := rec( group := G );\n i := 3;\n while i <= Length(args) do\n act := args[i];\n\n # \"ClassBound\", <class>\n if match( act, \"ClassBound\" ) then\n i := i + 1;\n CR.ClassBound := args[i];\n if CR.ClassBound <= PClassPGroup(G) then\n Error( \"\\\"ClassBound\\\" must be at least \", PClassPGroup(G)+1 );\n fi;\n\n # \"PcgsAutomorphisms\"\n elif match( act, \"PcgsAutomorphisms\" ) then\n CR.PcgsAutomorphisms := true;\n\n #this may be available later\n # \"SpaceEfficient\"\n #elif match( act, \"SpaceEfficient\" ) then\n # CR.SpaceEfficient := true;\n\n # \"Exponent\", <exp>\n elif match( act, \"Exponent\" ) then\n i := i + 1;\n CR.Exponent := args[i];\n\n # \"Metabelian\"\n elif match( act, \"Metabelian\" ) then\n CR.Metabelian := true;\n\n # \"Verbose\"\n elif match( act, \"Verbose\" ) then\n CR.Verbose := true;\n\n # \"SetupFile\", <file>\n elif match( act, \"SetupFile\" ) then\n i := i + 1;\n CR.SetupFile := args[i];\n\n \t# \"TmpDir\", <dir>\n \telif match( act, \"TmpDir\" ) then\n \t i := i + 1;\n \t CR.TmpDir := args[i];\n\n # \"Output\", <level>\n elif match( act, \"OutputLevel\" ) then\n i := i + 1;\n CR.OutputLevel := args[i];\n CR.Verbose := true;\n\n # signal an error\n else\n ANUPQSPerror(act);\n fi;\n i := i + 1;\n od;\n return CR;\n\nend );\n\n#############################################################################\n##\n#F PqFpGroupPcGroup( <G> ) . . . . . . corresponding fp group of a pc group\n##\nInstallGlobalFunction( PqFpGroupPcGroup, \n G -> Image( IsomorphismFpGroup( G ) )\n);\n\n#############################################################################\n##\n#M FpGroupPcGroup( <G> ) . . . . . . . corresponding fp group of a pc group\n##\nInstallMethod( FpGroupPcGroup, \"pc group\", [IsPcGroup], 0, PqFpGroupPcGroup );\n\n#############################################################################\n##\n#F PQ_EPIMORPHISM_STANDARD_PRESENTATION( <args> ) . (epi. onto) SP for group\n##\nInstallGlobalFunction( PQ_EPIMORPHISM_STANDARD_PRESENTATION, \nfunction( args )\n local datarec, rank, Q, Qclass, automorphisms, generators, x,\n images, i, r, j, aut, result, desc, k;\n\n datarec := ANUPQ_ARG_CHK(\"StandardPresentation\", args);\n\n if datarec.calltype = \"interactive\" and IsBound(datarec.SPepi) then\n # Note: the `pq' binary seg-faults if called twice to \n # calculate the standard presentation of a group\n return datarec.SPepi;\n fi;\n\n if VALUE_PQ_OPTION(\"pQuotient\") = fail and\n VALUE_PQ_OPTION(\"Prime\", datarec) <> fail then\n # Ensure a saved value of `Prime' has precedence\n # over a saved value of `pQuotient'.\n Unbind(datarec.pQuotient);\n fi;\n\n if VALUE_PQ_OPTION(\"pQuotient\", datarec) <> fail then\n PQ_AUT_GROUP( datarec.pQuotient );\n datarec.Prime := PrimePGroup( datarec.pQuotient );\n elif VALUE_PQ_OPTION(\"Prime\", datarec) <> fail then\n rank := Number( List( AbelianInvariants(datarec.group), \n x -> Gcd(x, datarec.Prime) ),\n y -> y = datarec.Prime );\n\n # construct free group with <rank> generators\n Q := FreeGroup( IsSyllableWordsFamily, rank, \"q\" );\n \n # construct power-relation\n Q := Q / List( GeneratorsOfGroup(Q), x -> x^datarec.Prime );\n \n # construct pc group\n Q := PcGroupFpGroup(Q);\n \n # construct automorphism\n automorphisms := [];\n generators := GeneratorsOfGroup(Q);\n for x in GeneratorsOfGroup( GL(rank, datarec.Prime) ) do\n images := [];\n for i in [ 1 .. rank ] do\n r := One(Q);\n for j in [ 1 .. rank ] do\n r := r * generators[j]^Int(x[i][j]);\n od;\n images[i] := r;\n od;\n aut := GroupHomomorphismByImages( Q, Q, generators, images );\n SetIsBijective( aut, true );\n Add( automorphisms, aut );\n od;\n SetAutomorphismGroup( Q, GroupByGenerators( automorphisms ) );\n datarec.pQuotient := Q;\n fi;\n \n #PushOptions(rec(nonuser := true));\n Qclass := PClassPGroup( datarec.pQuotient );\n if VALUE_PQ_OPTION(\"ClassBound\", 63) <= Qclass then\n Error( \"option `ClassBound' must be greater than `pQuotient' class (\",\n Qclass, \")\\n\" );\n fi;\n PQ_PC_PRESENTATION(datarec, \"SP\" : ClassBound := Qclass);\n\n PQ_SP_STANDARD_PRESENTATION(datarec);\n\n PQ_SP_ISOMORPHISM(datarec);\n\n if datarec.calltype = \"non-interactive\" then\n PQ_COMPLETE_NONINTERACTIVE_FUNC_CALL(datarec);\n if IsBound( datarec.setupfile ) then\n #PopOptions();\n return true;\n fi;\n fi;\n\n # try to read output\n result := ANUPQReadOutput( ANUPQData.SPimages );\n\n if not IsBound(result.ANUPQmagic) then\n Error(\"something wrong with `pq' binary. Please check installation\\n\");\n fi;\n\n desc := rec();\n result.ANUPQgroups[Length(result.ANUPQgroups)](desc);\n# if result.ANUPQautos <> fail and \n# Length( result.ANUPQautos ) = Length( result.ANUPQgroups ) then\n# \tresult.ANUPQautos[ Length(result.ANUPQgroups) ]( desc.group );\n# fi;\n\n # revise images to correspond to images of user-supplied generators \n datarec.SP := desc.group;\n x := Length( desc.map );\n k := Length( GeneratorsOfGroup( datarec.group ) );\n # images of user supplied generators are last k entries in .pqImages \n\n datarec.SPepi := GroupHomomorphismByImagesNC( \n datarec.group, \n datarec.SP, \n GeneratorsOfGroup(datarec.group),\n desc.map{[x - k + 1..x]} );\n #PopOptions();\n return datarec.SPepi;\nend );\n\n#############################################################################\n##\n#F EpimorphismPqStandardPresentation( <arg> ) . . . epi. onto SP for p-group\n##\nInstallGlobalFunction( EpimorphismPqStandardPresentation, function( arg )\n return PQ_EPIMORPHISM_STANDARD_PRESENTATION( arg );\nend );\n\n#############################################################################\n##\n#F PqStandardPresentation( <arg> : <options> ) . . . . . . . SP for p-group\n##\nInstallGlobalFunction( PqStandardPresentation, function( arg )\n local SPepi;\n\n SPepi := PQ_EPIMORPHISM_STANDARD_PRESENTATION( arg );\n if SPepi = true then\n return true; # the SetupFile case\n fi;\n return Range( SPepi );\nend );\n\n#############################################################################\n##\n#M EpimorphismStandardPresentation( <F> ) . . . . . epi. onto SP for p-group\n#M EpimorphismStandardPresentation( [<i>] )\n##\nInstallMethod( EpimorphismStandardPresentation, \n \"fp group\", [IsFpGroup], 0,\n EpimorphismPqStandardPresentation );\n\nInstallMethod( EpimorphismStandardPresentation, \n \"pc group\", [IsPcGroup], 0,\n EpimorphismPqStandardPresentation );\n\nInstallMethod( EpimorphismStandardPresentation, \n \"positive integer\", [IsPosInt], 0,\n EpimorphismPqStandardPresentation );\n\nInstallOtherMethod( EpimorphismStandardPresentation,\n \"\", [], 0,\n EpimorphismPqStandardPresentation );\n\n#############################################################################\n##\n#M StandardPresentation( <F> ) . . . . . . . . . . . . . . . SP for p-group\n#M StandardPresentation( [<i>] )\n##\nInstallMethod( StandardPresentation, \n \"fp group\", [IsFpGroup], 0,\n PqStandardPresentation );\n\nInstallMethod( StandardPresentation, \n \"pc group\", [IsPcGroup], 0,\n PqStandardPresentation );\n\nInstallMethod( StandardPresentation, \n \"positive integer\", [IsPosInt], 0,\n PqStandardPresentation );\n\nInstallOtherMethod( StandardPresentation,\n \"\", [], 0,\n PqStandardPresentation );\n\n#############################################################################\n##\n#F IsPqIsomorphicPGroup( <G>, <H> ) . . . . . . . . . . . isomorphism test\n##\nInstallGlobalFunction( IsPqIsomorphicPGroup, function( G, H )\n local p, class, SG, SH, Ggens, Hgens;\n \n # <G> and <H> must both be pc groups and p-groups\n if not IsPcGroup(G) then\n Error( \"<G> must be a pc group\" );\n fi;\n if not IsPcGroup(H) then\n Error( \"<H> must be a pc group\" );\n fi;\n if Size(G) <> Size(H) then\n return false;\n fi;\n p := SmallestRootInt(Size(G));\n if not IsPrimeInt(p) then\n Error( \"<G> must be a p-group\" );\n fi;\n \n # check the Frattini factor\n if RankPGroup(G) <> RankPGroup(H) then\n return false;\n fi;\n\n # check the exponent-p length and the sizes of the groups in the\n # p-central series of both groups \n if List(PCentralSeries(G,p), Size) <> List(PCentralSeries(H,p), Size) then\n return false;\n fi;\n\n # if the groups are elementary abelian they are isomorphic\n class := PClassPGroup(G);\n if class = 1 then\n return true;\n fi;\n \n # compute a standard presentation for both\n SG := PqStandardPresentation(PqFpGroupPcGroup(G)\n : Prime := p, ClassBound := class);\n SH := PqStandardPresentation(PqFpGroupPcGroup(H)\n : Prime := p, ClassBound := class);\n \n # the groups are equal if the presentation are equal\n Ggens := GeneratorsOfGroup( FreeGroupOfFpGroup( SG ) );\n Hgens := GeneratorsOfGroup( FreeGroupOfFpGroup( SH ) );\n return RelatorsOfFpGroup(SG)\n = List( RelatorsOfFpGroup(SH), \n x -> MappedWord( x, Hgens, Ggens ) );\n \nend );\n\n#############################################################################\n##\n#M IsIsomorphicPGroup( <F>, <G> )\n##\nInstallMethod( IsIsomorphicPGroup, \"pc group, pc group\",\n [IsPcGroup, IsPcGroup], 0,\n IsPqIsomorphicPGroup );\n\n#E anusp.gi . . . . . . . . . . . . . . . . . . . . . . . . . . . ends here\n", "meta": {"hexsha": "d05fc54d8a21ceed427978fd8a8b7887634e6090", "size": 11719, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "lib/anusp.gi", "max_stars_repo_name": "gap-system/anupq", "max_stars_repo_head_hexsha": "075d27ffe985d561f377a253563605ffea726448", "max_stars_repo_licenses": ["Artistic-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/anusp.gi", "max_issues_repo_name": "gap-system/anupq", "max_issues_repo_head_hexsha": "075d27ffe985d561f377a253563605ffea726448", "max_issues_repo_licenses": ["Artistic-2.0"], "max_issues_count": 8, "max_issues_repo_issues_event_min_datetime": "2015-03-04T12:41:28.000Z", "max_issues_repo_issues_event_max_datetime": "2015-09-27T22:17:27.000Z", "max_forks_repo_path": "lib/anusp.gi", "max_forks_repo_name": "gap-system/anupq", "max_forks_repo_head_hexsha": "075d27ffe985d561f377a253563605ffea726448", "max_forks_repo_licenses": ["Artistic-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.0112676056, "max_line_length": 79, "alphanum_fraction": 0.5184742725, "num_tokens": 3045, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.49218813572079556, "lm_q2_score": 0.0747700506393715, "lm_q1q2_score": 0.03680093183194174}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\n#\n# Typ ::\n#\n# Value ::\n# t = <type>\n# v = <.>\n#\n# Types:\n# TReal \n# TComplex\n# TInt\n# TArray(<type>, <size>)\n# TVect(<type>, <vlen>)\n#\n# Value(<type>, <.>)\n# V(<.>) infers type automatically\n#\n\nDeclare(Value, IsExp, IsValue, TArray, TVect, BitVector, T_UInt);\n\n_evInt := v -> Cond(IsInt(v), v, IsList(v), List(v, i->_evInt(i)), v.ev());\n\n#----------------------------------------------------------------------------------------------\n# Typ : data types\n#----------------------------------------------------------------------------------------------\nClass(TypOps, rec(\n Print := x-> When(IsBound(x.print), x.print(), Print(x.__name__)),\n \\= := RewritableObjectOps.\\=,\n \\< := RewritableObjectOps.\\<\n));\nClass(TypOpsNoPrint, ClassOps, rec(\n \\= := RewritableObjectOps.\\=,\n \\< := RewritableObjectOps.\\<\n));\n\n\nDeclare(RangeT);\n\nClass(RangeTOps, PrintOps, rec(\n \\= := (v1,v2) -> When( ObjId(v1)<>RangeT or ObjId(v2)<>RangeT, false,\n v1.max=v2.max and v1.min=v2.min and v1.eps=v2.eps),\n \\< := (v1,v2) -> Error(\"Operation '<' is undefined for RangeT.\"),\n \\+ := (v1,v2) -> When( ObjId(v1)<>RangeT or ObjId(v2)<>RangeT, Error(\"'+' is defined for RangeT only\"),\n RangeT(Min2(v1.min, v2.min), Max2(v1.max, v2.max), Max2(v1.eps, v2.eps))),\n \\* := (v1,v2) -> When( ObjId(v1)<>RangeT or ObjId(v2)<>RangeT, Error(\"'*' is defined for RangeT only\"),\n RangeT(Max2(v1.min, v2.min), Min2(v1.max, v2.max), Max2(v1.eps, v2.eps))),\n));\n\n#F RangeT(<min>, <max>, <eps>): data type range\n#F <min> smallest value, <max> largest value, <eps> unit roundoff\nClass(RangeT, rec(\n __call__ := (self, min, max, eps) >> \n WithBases(self, rec( min := min, max := max, eps := eps, operations := RangeTOps)),\n print := self >> Print(self.__name__, \"(\", self.min, \", \", self.max, \", \", self.eps, \")\"),\n));\n\nClass(Typ, rec(\n operations := TypOps,\n isType := true,\n isSigned := self >> true,\n doHashValues := false,\n check := v -> v,\n #normalize := (self, v) >> Value(self,v),\n eval := self >> self,\n\n vbase := rec(),\n\n value := meth(self, v)\n local ev;\n if IsExp(v) then\n ev := v.eval();\n if IsSymbolic(ev) and not IsValue(ev) then\n v.t := self;\n return v;\n fi;\n fi;\n\n if IsValue(v) then return Value.new(self, self.check(v.v));\n else return Value.new(self,self.check(v));\n fi;\n end,\n\n realType := self >> self,\n\n product := (v1, v2) -> v1 * v2,\n sum := (v1, v2) -> v1 + v2,\n base_t := self >> self, # composite types should return base data type (without recursion).\n saturate := abstract(), # (self, v) >> ...\n # range should return RangeT\n range := abstract(), # (self) >> ...\n));\n\nClass(CompositeTyp, Typ, rec(operations := TypOpsNoPrint));\n\nClass(AtomicTyp, Typ, rec(\n doHashValues := true,\n isAtomic := true,\n rChildren := self >> [],\n from_rChildren := (self, rch) >> Checked(rch=[], self),\n free := self >> Union(List(self.rChildren(), FreeVars)),\n vtype := (self,v) >> TVect(self, v),\n csize := self >> sizeof(self)\n));\n\nIsType := x -> IsRec(x) and IsBound(x.isType) and x.isType;\n\nClass(TFunc, RewritableObject, Typ, rec(\n check := v -> v, #Checked(IsFunction(v), v),\n product := (v1, v2) -> Error(\"Can not multiply functions\"),\n sum := (v1, v2) -> Error(\"Can not add functions\"),\n zero := (v1, v2) -> Error(\"TFunc.zero() is not supported\"),\n one := (v1, v2) -> Error(\"TFunc.one() is not supported\"),\n free := self >> Union(List(self.params, FreeVars)),\n updateParams := self >> Checked(ForAll(self.params, e->IsType(e) or IsValue(e) or IsInt(e) or IsSymbolic(e)), true),\n csize := self >> sizeof(self)\n));\n\nIsFuncT := x -> IsType(x) and ObjId(x)=TFunc;\n\nClass(ValueOps, PrintOps, rec(\n \\= := (v1,v2) -> Cond(\n not IsValue(v2), v1.v=v2,\n not IsValue(v1), v1=v2.v,\n IsBound(v1.t.vequals), v1.t.vequals(v1.v, v2.v),\n IsBound(v2.t.vequals), v2.t.vequals(v1.v, v2.v),\n v1.v = v2.v),\n \\< := (v1,v2) -> Cond(\n not IsValue(v2), When(IsRec(v2), ObjId(v1) < ObjId(v2), v1.v < v2),\n not IsValue(v1), When(IsRec(v1), ObjId(v1) < ObjId(v2), v1 < v2.v),\n v1.v < v2.v)\n ));\n\n#----------------------------------------------------------------------------------------------\n# Value : values or constants\n# NB: All values are automatically hashed in GlobalConstantHash\n# This can reduce memory footprint, since lots of values are repetitive,\n# like 1s and 0s, and also float values that are too close to each other will\n# hash to same value (by virtue of ValueOps.\\=), which will prevent compiler\n# from putting them in separate registers, and thus degrading performance.\n#\n# This has negligible effect on accuracy, as long as <type>.vequals is valid.\n# \n#----------------------------------------------------------------------------------------------\nClass(Value, rec(\n isValue := true,\n __call__ := (self, t, v) >> t.value(v),\n\n new := (self,t,v) >> # HashedValue(GlobalConstantHash, <-- this hashes the Value upon construction, disabled now\n # due to slowness with large data() blocks, which aren't hashed, unless this option is used\n\tCond(t.vbase=rec(),\n WithBases(self, rec(t:=t, v:=v, operations := ValueOps)),\n WithBases(self, Inherit(t.vbase, rec(t:=t, v:=v, operations:=ValueOps)))\n\t),\n #),\n\n ev := self >> self.v,\n eval := self >> self,\n free := self >> Set([]),\n\n from_rChildren := (self, rch) >> self,\n# print := self >> Print(self.__name__, \"(\", self.t, \",\", self.v, \")\"),\n# print := self >> Print(self.v),\n print := self >> Cond(IsString(self.v), Print(\"V(\\\"\",self.v, \"\\\")\"), Print(\"V(\", self.v, \")\")),\n\n dims := self >> Cond(\n\tIsArrayT(self.t), self.t.dims(),\n\tError(\"<self>.dims() is only valid when self.t is a TArray\"))\n));\n\nIsValue := x -> IsRec(x) and IsBound(x.isValue) and x.isValue; \n\n#----------------------------------------------------------------------------------------------\n#----------------------------------------------------------------------------------------------\n\nDeclare(TComplex);\n\nClass(TUnknown, AtomicTyp, rec( one := self >> 1, zero := self >> 0));\nClass(TVoid, AtomicTyp);\nClass(TDummy, AtomicTyp); # used in autolib for Lambda parameters that are ignored\n\nClass(TReal, AtomicTyp, rec(\n cutoff := 1e-15,\n hash := (val, size) -> 1 + (DoubleRep64(Double(val)) mod size), #(IntDouble(1.0*val*size) mod size),\n\n check := (self,v) >> Cond(\n IsExp(v), ReComplex(Complex(code.EvalScalar(v))),\n IsInt(v), Double(v),\n IsRat(v), v,\n IsDouble(v), When(AbsFloat(v) < self.cutoff, 0.0, v),\n IsCyc(v), ReComplex(Complex(v)),\n IsComplex(v), ReComplex(v),\n Error(\"<v> must be a double or an expression\")),\n\n vequals := (self, v1,v2) >> When(\n (IsDouble(v1) or IsInt(v1) or IsRat(v1)) and (IsDouble(v2) or IsInt(v2) or IsRat(v2)),\n AbsFloat(Double(v1)-Double(v2)) < self.cutoff,\n false),\n\n zero := self >> self.value(0.0),\n one := self >> self.value(1.0),\n strId := self >> \"f\",\n \n complexType := self >> TComplex,\n));\n\n\nTDouble:=TReal;\n\n#\n# format: | sign | integer bits | frac bits |\n# # make sure we have space at least for the sign bit\n#\n_fpdouble := (val,b,fb) -> let(res := IntDouble(val * 2.0^fb),\n Cond(\n\tval = 1 and (fb = b-1), # we can represent 1 as 0.999999, if we use frac bits only\n\t 2^fb - 1,\n\tval = -1 and (fb = b-1), # we can represent 1 as 0.999999, if we use frac bits only\n\t -(2^fb - 1),\n\tLog2Int(res)+2 > b, Error(\"Overflow, value=\", val, \", signed width=\",\n Log2Int(res)+2, \", max width=\", b),\n res));\n\n# format: | integer bits | frac bits |\n#\n_ufpdouble := (val,b,fb) -> let(res := IntDouble(val * 2.0^fb),\n When(Log2Int(res)+1 > b, Error(\"Overflow, value=\", val, \", unsigned width=\",\n Log2Int(res)+1, \", max width=\", b),\n res));\n\n#F TFixedPt(<bits>, <fracbits>) -- fixed point data type\n#F\n#F <bits> -- total # of bits (including sign bit)\n#F <fracbits> -- number of fractional bits\n#F\n#F Number of integer bits is assumed to be bits-1-fracbits (1 = sign bit)\n#F\nClass(TFixedPt, TReal, rec(\n operations := TypOpsNoPrint, # NOTE: do not inherit from TReal, and then this line won't be needed\n\n __call__ := (self, bits, fracbits) >> WithBases(self, rec(\n bits := bits,\n fracbits := fracbits,\n operations := TypOps)),\n\n rChildren := self >> [self.bits, self.fracbits],\n rSetChild := rSetChildFields(\"bits\", \"fracbits\"),\n from_rChildren := (self, rch) >> ApplyFunc(ObjId(self), rch),\n\n print := self >> Print(self.__name__, \"(\", self.bits, \", \", self.fracbits, \")\"),\n\n check := (self, v) >> _fpdouble(v, self.bits, self.fracbits)\n));\n\n# TUFixedPt(<bits>, <fracbit>) -- unsigned fixed point data type\n#\nClass(TUFixedPt, TFixedPt);\n\nClass(TComplex, AtomicTyp, rec(\n hash := (val, size) -> let(\n cplx := Complex(val), \n #h := IntDouble(size * (ReComplex(cplx)+ImComplex(cplx))),\n h := DoubleRep64(ReComplex(cplx)) + DoubleRep64(ImComplex(cplx)),\n 1 + (h mod size)),\n\n check := v -> Cond(\n BagType(v) in [T_CYC, T_RAT, T_INT], v, # exact representation\n IsDouble(v), When(AbsFloat(v) < TReal.cutoff, 0, v),\n IsComplex(v), Complex(TReal.check(ReComplex(v)), TReal.check(ImComplex(v))),\n IsExp(v), Complex(v.ev())),\n\n realType := self >> TReal,\n complexType := self >> self,\n\n zero := self >> self.value(0.0),\n one := self >> self.value(1.0),\n));\n\nClass(TBool, AtomicTyp, rec(\n hash := (val, size) -> 1 + (InternalHash(val) mod size),\n check := v -> Cond(IsBool(v), v, Error(\"<v> must be a boolean\")),\n one := self >> self.value(true),\n zero := self >> self.value(false),\n));\n\nClass(TInt_Base, AtomicTyp, rec(\n hash := (val, size) -> 1 + (10047871*val mod size),\n bits := 32,\n check := v -> Cond(IsExp(v), Int(v.ev()),\n IsInt(v), v,\n IsDouble(v) and IsInt(IntDouble(v)), IntDouble(v),\n Error(\"<v> must be an integer or an expression\")),\n one := self >> self.value(1),\n zero := self >> self.value(0),\n\n complexType := self >> TComplex,\n));\n\nClass(TInt, TInt_Base, rec(strId := self >> \"i\"));\nClass(TUInt, TInt_Base, rec(isSigned := False, strId := self >> \"ui\"));\nClass(TULongLong, TInt_Base);\n\nIsChar := (x)->When(BagType(x)=T_CHAR, true, false);\n\nClass(TChar, TInt_Base, rec(\n hash := (val, size) -> When(IsChar(val), 1 + (InternalHash(val) mod size), TInt_Base.hash(val, size)),\n bits := 8,\n check := v -> Cond(IsExp(v), Int(v.ev()),\n IsInt(v), v, \n IsChar(v), v, \n Error(\"<v> must be an integer or an expression\")),\n));\n\nClass(TUChar, TInt_Base, rec(\n bits := 8,\n isSigned := self >> false,\n check := v -> Cond(IsExp(v), Int(v.ev()),\n IsInt(v), v,\n Error(\"<v> must be an integer or an expression\")),\n));\n\nClass(TString, AtomicTyp, rec(\n doHashValues := true,\n hash := (val, size) -> 1 + (InternalHash(val) mod size),\n check := v -> Cond(IsString(v), v, Error(\"<v> must be a string\")),\n one := self >> Error(\"TString.one() is not allowed\"),\n zero := self >> Error(\"TString.zero() is not allowed\"),\n));\n\nClass(TList, CompositeTyp, rec(\n isListT := true,\n hash := (val, size) -> Error(\"Not implemented\"),\n __call__ := (self, t) >>\n WithBases(self, rec(\n t := Checked(IsType(t), t),\n operations := PrintOps)),\n print := self >> Print(self.__name__, \"(\", self.t, \")\"),\n check := v -> Cond(IsList(v), v, Error(\"<v> must be a list\")),\n\n one := self >> Error(\"TList.one() is not allowed\"),\n zero := self >> Error(\"TList.zero() is not allowed\"),\n\n rChildren := self >> [self.t],\n rSetChild := rSetChildFields(\"t\"),\n from_rChildren := (self, rch) >> ApplyFunc(ObjId(self), rch),\n\n));\n\nClass(TSym, CompositeTyp, rec(\n hash := (val, size) -> Error(\"Not implemented\"),\n check := v -> v,\n __call__ := (self, id) >>\n WithBases(self, rec(\n id := Checked(IsString(id), id),\n operations := TypOps)),\n\n rChildren := self >> [self.id],\n rSetChild := rSetChildFields(\"id\"),\n from_rChildren := (self, rch) >> ApplyFunc(ObjId(self), rch),\n\n print := self >> Print(self.__name__, \"(\\\"\", self.id, \"\\\")\"),\n csize := self >> sizeof(self)\n));\n\n#F TArrayBase -- base class for array-like element collection types\n#F\n#F Subclasses: TPtr, TArray, TVect, BitVector\n#F\n#F Default constructor:\n#F\n#F __call__(<element-type>, <size>) - array type of <size> elements of <element-type>\n#F\nClass(TArrayBase, CompositeTyp, rec(\n __call__ := (self, t, size) >>\n WithBases(self, rec(\n t := Checked(IsType(t), t),\n size := Checked(IsPosInt0Sym(size), size),\n operations := TypOps)),\n\n hash := (self, val, size) >> (Sum(val, x -> x.t.hash(x.v, size)) mod size) + 1,\n\n rChildren := self >> [self.t, self.size],\n rSetChild := rSetChildFields(\"t\", \"size\"),\n from_rChildren := (self, rch) >> ApplyFunc(ObjId(self), rch),\n\n isSigned := self >> self.t.isSigned(),\n\n print := self >> Print(self.__name__, \"(\", self.t, \", \", self.size, \")\"),\n\n check := (self, v) >> Checked(IsList(v), Length(v) = self.size,\n ForAll(v, el -> el.t = self.t), v),\n\n # these fields go into values\n vbase := rec(\n free := self >> Union(List(self.v, e -> e.free())),\n rChildren := self >> self.v,\n rSetChild := meth(self, n, newC) self.v[n] := newC; end\n ),\n\n zero := self >> self.value(Replicate(_unwrap(self.size), self.t.zero())),\n one := self >> self.value(Replicate(_unwrap(self.size), self.t.one())),\n\n value := (self, v) >> let(vv := When(IsValue(v), v.v, v),\n Cond(IsExp(vv), vv,\n Checked(IsList(vv),\n Value.new(self, List(vv, e->self.t.value(e)))))),\n\n # array type can have free variables in .size field\n free := self >> Union(FreeVars(self.size), FreeVars(self.t)),\n\n csize := self >> self.t.csize() * self.size,\n\n realType := self >> ObjId(self)(self.t.realType(), self.size),\n\n base_t := self >> self.t,\n range := self >> self.t.range(),\n));\n\nDeclare(TPtr, TArray);\n\n#F TArray(<element-type>, <size>) - array type of <size> elements of <element-type>\n#F\nClass(TArray, TArrayBase, rec(\n isArrayT := true,\n vtype := (self, v) >> TArray(self.t.vtype(v), self.size/v),\n toPtrType := self >> TPtr(self.t),\n doHashValues := true,\n\n dims := self >> Cond(\n ObjId(self.t)=TArray, [self.size] :: self.t.dims(),\n [self.size])\n));\n\n# [ptrAligned, ptrUnaligned] are TPtr.alignment values\nptrUnaligned := [1,0];\nptrAligned4 := [4,0];\nptrAligned8 := [8,0];\nptrAligned16 := [16,0];\nptrAligned := ptrAligned16;\n\n# NOTE: this is a hack, esp because 16 byte boundary is hardcoded in ptrAligned\n# It should be in SpiralDefaults somehow\nTArray.alignment := ptrAligned; \nTArray.qualifiers := [];\n\nTypeDomain := (dom, els) ->\n Cond(Same(dom, Rationals) or Same(dom, Scalars) or Same(dom, Doubles), TReal,\n Same(dom, Complexes), TComplex,\n Same(dom, Cyclotomics), When(ForAll(els, x->Im(x)=0), TReal, TComplex),\n Same(dom, Integers), TInt,\n Error(\"Unrecognized domain <dom>\"));\n\n# IsArrayT(<t>) - checks whether <t> is an array type object\nIsArrayT := x -> IsType(x) and IsBound(x.isArrayT) and x.isArrayT;\n\n# IsListT(<t>) - checks whether <t> is a list type object\nIsListT := x -> IsType(x) and IsBound(x.isListT) and x.isListT;\n\n# IsVecT(<t>) - checks whether <t> is an vector type object\nIsVecT := x -> IsType(x) and IsBound(x.isVecT) and x.isVecT;\n\n# IsPtrT(<t>) - checks whether <t> is a pointer type object\nIsPtrT := x-> IsType(x) and IsBound(x.isPtrT) and x.isPtrT;\n\n# IsUnalignedPtrT(<t>) - checks whether <t> is a unaligned pointer type object,\n# unaligned means aligned with smaller granularity than child type (t.t)\n# size.\nIsUnalignedPtrT := x -> IsPtrT(x) and x.alignment<>ptrAligned;\n\n\n# obsolete, use IsArrayT\nIsArray := IsArrayT;\n\nClass(TPtr, TArrayBase, rec(\n isPtrT := true,\n __call__ := arg >> let(self := arg[1],\n t := arg[2],\n qualifiers := When(IsBound(arg[3]), arg[3], []),\n alignment := When(IsBound(arg[4]), arg[4], ptrAligned16),\n WithBases(self, rec(\n t := Checked(IsType(t), t),\n size := 0,\n qualifiers := qualifiers,\n _restrict := false,\n alignment := alignment,\n operations := TypOps)).normalizeAlignment()),\n\n # value := (self, v) >> Error(\"Values of TPtr type are not allowed\"),\n value := Typ.value,\n\n check := (self, v) >> Cond(\n IsList(v), Checked(\n Length(v) = self.size,\n ForAll(v, el -> el.t = self.t), \n v\n ),\n IsInt(v), v,\n Error(\"TPtr needs to either point to an array or some value\")\n ),\n\n # this looks crazy, but sometimes this happens (in LRB backend actually) : X - X\n # where X is a pointer. Internally this can become X + (-X), and then becomes 0\n isSigned := self >> true,\n\n rChildren := self >> [self.t, self.qualifiers, self.alignment],\n rSetChild := rSetChildFields(\"t\", \"qualifiers\", \"alignment\"),\n\n zero := self >> TInt.zero(),\n one := self >> TInt.one(),\n\n print := self >> Print(self.__name__, \"(\", self.t,\n When(self.qualifiers<>[], Print(\", \", self.qualifiers)), \")\",\n When(self._restrict, \".restrict()\", \"\"),\n \".aligned(\", self.alignment, \")\"\n ),\n\n restrict := (self) >> CopyFields(self, rec(_restrict := true)),\n unRestricted := (self) >> CopyFields(self, rec(_restrict := false)),\n\n csize := self >> sizeof(self),\n\n realType := self >> Cond(self._restrict,\n ObjId(self)(self.t.realType(), self.qualifiers).restrict(),\n ObjId(self)(self.t.realType(), self.qualifiers)\n ),\n\n aligned := (self, a) >> CopyFields(self, rec( alignment := Checked(IsList(a) and Length(a)=2, a) )).normalizeAlignment(),\n unaligned := (self) >> CopyFields(self, rec( alignment := [1,0] )),\n\n normalizeAlignment := meth(self)\n if IsValue(self.alignment[2]) then self.alignment[2] := self.alignment[2].v;\n elif IsSymbolic(self.alignment[2]) then self.alignment := ptrUnaligned; # NOTE: Conservative assumption\n fi;\n Constraint(IsInt(self.alignment[2]));\n self.alignment[2] := self.alignment[2] mod self.alignment[1];\n return self;\n end,\n\n withAlignment := (self, value) >> CopyFields(self, rec( \n alignment := When(IsPtrT(value), value.alignment, value))),\n\n # things get a little strange here because we allow pointers\n # to be set to some int based offset \n # \n vbase := rec(\n free := self >> Cond(\n IsList(self.v), Union(List(self.v, e -> e.free())),\n IsInt(self.v), [],\n Error(\"hmm.\")\n ),\n rChildren := self >> Cond(\n IsList(self.v), self.v,\n IsInt(self.v), [], \n Error(\"hmm.\")\n ),\n\n rSetChild := meth(arg)\n local _self;\n _self := arg[1];\n\n if Length(arg) = 3 then\n _self.v[arg[2]] := arg[3];\n elif Length(arg) = 2 then\n _self.v := arg[2];\n else\n Error(\"choke\");\n fi; \n end,\n ),\n));\n\n\n# -- TVect ----------------------------------------------------------------------\n\nClass(TVect, TArrayBase, rec(\n isVecT := true,\n doHashValues := true,\n __call__ := (self, t, size) >> Cond(t=T_UInt(1), BitVector(size), Inherited(t, size)),\n\n product := (v1, v2) -> Checked(IsList(v1) or IsList(v2), let(\n vv1 := When(not IsList(v1), Replicate(Length(v2), v1), v1),\n vv2 := When(not IsList(v2), Replicate(Length(v1), v2), v2),\n l := Length(vv1),\n Checked(l = Length(vv2),\n List([1..l], i -> vv1[i]*vv2[i])))),\n\n sum := (v1, v2) -> Checked(IsList(v1) or IsList(v2), let(\n vv1 := When(not IsList(v1), Replicate(Length(v2), v1), v1),\n vv2 := When(not IsList(v2), Replicate(Length(v1), v2), v2),\n l := Length(vv1),\n Checked(l = Length(vv2),\n List([1..l], i -> vv1[i]+vv2[i])))),\n\n value := (self, v) >> Cond( IsValue(v) and self=v.t, v, let(\n vv := When(IsValue(v), v.v, v),\n Cond(IsExp(vv), vv,\n IsList(vv), Value.new(self, List(vv, e -> self.t.value(e))),\n <#else#> \n Value.new(self, List(Replicate(self.size, vv), e -> self.t.value(e)))))),\n\n saturate := (self, v) >> let( vv := _unwrap(v), Cond(not IsList(vv) or Length(vv)<>self.size, v,\n Value.new(self, List(vv, e -> self.t.saturate(e)))) ),\n \n toUnsigned := self >> TVect(self.t.toUnsigned(), self.size),\n toSigned := self >> TVect(self.t.toSigned(), self.size),\n double := self >> TVect(self.t.double(), self.size/2),\n\n));\n\nIsTVectDouble := x -> IsVecT(x) and x.t = TReal;\n\nTVectDouble := vlen -> TVect(TReal, vlen);\n\n#Class(T_Type, Typ, rec(\n# __call__ := (self, bits) >>\n# WithBases(self, rec(\n# bits := Checked(IsPosInt(bits), bits),\n# operations := TypOps)),\n#\n# hash := (self, val, size) >> 1 + (10047871*val mod size),\n#\n# rChildren := self >> [],\n# rSetChild := self >> Error(\"This function should not be called\"),\n# print := self >> Print(self.__name__, \"(\", self.bits, \")\"),\n# free := self >> Union(List(self.rChildren(), FreeVars)),\n# vtype := (self,v) >> TVect(self, v)\n#));\n\nClass(T_Type, RewritableObject, rec(\n isType := true,\n\n isSigned := self >> true,\n realType := self >> self,\n\n doHashValues := false, \n check := v -> v,\n vbase := rec(),\n\n value := meth(self, v)\n local ev;\n if IsExp(v) then\n ev := v.eval();\n if IsSymbolic(ev) and not IsValue(ev) then\n v.t := self;\n return v;\n fi;\n fi;\n if IsValue(v) then\n return Value.new(self, self.check(v.v));\n else\n return Value.new(self, self.check(v));\n fi;\n end,\n\n eval := self >> self,\n product := (v1, v2) -> v1 * v2,\n sum := (v1, v2) -> v1 + v2,\n zero := self >> self.value(0),\n one := self >> self.value(1),\n csize := self >> sizeof(self),\n base_t := self >> self, # composite types should return base type (without recursion).\n saturate := abstract(), # (self, v) >> ...\n range := abstract(), # (self) >> ...\n)); \n\nDeclare(T_Int, T_UInt, T_Complex);\n\nClass(T_Ord, T_Type, rec(\n hash := (val, size) -> 1 + (10047871*val mod size),\n saturate := (self, v) >> let( b := self.range(),\n Cond( IsExp(v), v, self.value(Max2(b.min, Min2(b.max, _unwrap(v)))))),\n));\n\nClass(T_Int, T_Ord, rec(\n check := (self, v) >> let(\n i := Cond(IsDouble(v), IntDouble(v),\n IsRat(v), Int(v),\n Error(\"Can't convert <v> to an integer\")),\n b := self.params[1],\n ((i + 2^(b-1)) mod 2^b) - 2^(b-1)),\n\n strId := self >> \"i\"::StringInt(self.params[1]),\n range := self >> RangeT(-2^(self.params[1]-1), 2^(self.params[1]-1)-1, 1),\n \n isSigned := True,\n toUnsigned := self >> T_UInt(self.params[1]),\n toSigned := self >> self,\n double := self >> T_Int(2*self.params[1]),\n));\n\nClass(T_UInt, T_Ord, rec(\n check := (self, v) >> let(\n i := Cond(IsDouble(v), IntDouble(v),\n IsRat(v), Int(v),\n Error(\"Can't convert <v> to an integer\")),\n b := self.params[1],\n i mod 2^b),\n\n strId := self >> \"ui\"::StringInt(self.params[1]),\n range := self >> RangeT(0, 2^self.params[1]-1, 1),\n\n isSigned := False,\n toUnsigned := self >> self,\n toSigned := self >> T_Int(self.params[1]),\n double := self >> T_UInt(2*self.params[1]),\n));\n\nClass(BitVector, TArrayBase, rec(\n isVecT := true,\n __call__ := (self, size) >> Inherited(T_UInt(1), size),\n\n print := self >> Print(self.__name__, \"(\", self.size, \")\"),\n vbase := rec(\n print := self >> let(n:=Length(self.v), Print(\"h'\", HexStringInt(Sum([1..n], i->self.v[i] * 2^(n-i))))), \n ),\n \n isSigned := self >> false,\n\n rChildren := self >> [self.size],\n rSetChild := rSetChildFields(\"size\"),\n\n one := self >> self.value(Replicate(self.size, 1)),\n zero := self >> self.value(Replicate(self.size, 0)),\n\n hash := (self, val, size) >> let(n:=Length(val),\n 1 + (Sum([1..n], i -> val[i] * 2^(n-i)) mod size)),\n \n product := TVect.product,\n sum := TVect.sum,\n\n _uint1 := T_UInt(1),\n\n value := (self, v) >> When( IsValue(v) and v.t = self, v,\n let(vv := When(IsValue(v), v.v, v),\n Cond(IsExp(vv), vv,\n Checked(IsList(vv),\n Value.new(self, List(vv, e->self._uint1.check(e))))))),\n));\n\nClass(T_Real, T_Type, rec(\n #correct cutoffs are floor(log10(2^(mantissa bits + 1)))\n cutoff := self>>Cond(\n self.params[1] = 128, 1e-34,\n self.params[1] = 80, 1e-19,\n self.params[1] = 64, 1e-15,\n self.params[1] = 32, 1e-7,\n Error(\"cutoff not supported\")\n ),\n\n hash := TReal.hash, \n \n check := (self,v) >> let( r := Cond(\n IsExp(v), ReComplex(Complex(code.EvalScalar(v))),\n IsInt(v), Double(v),\n IsRat(v), v,\n IsDouble(v), v,\n IsCyc(v), ReComplex(Complex(v)),\n IsComplex(v), ReComplex(v),\n # else\n Error(\"<v> must be a double or an expression\")),\n When(AbsFloat(r) < self.cutoff(), 0.0, r)),\n\n vequals := (self, v1,v2) >> When(\n (IsDouble(v1) or IsInt(v1)) and (IsDouble(v2) or IsInt(v2)),\n AbsFloat(Double(v1)-Double(v2)) < self.cutoff(),\n false),\n\n zero := self >> self.value(0.0),\n one := self >> self.value(1.0),\n isSigned := (self) >> true,\n strId := self >> \"f\"::StringInt(self.params[1]),\n range := self >> Cond( \n self.params[1] = 128, RangeT(\n -1.7976931348623157e+308 - 10e291, #INF\n 1.7976931348623157e+308 + 10e291, #INF\n 1e-34\n ),\n self.params[1] = 80, RangeT(\n -1.7976931348623157e+308 - 10e291, #INF\n 1.7976931348623157e+308 + 10e291, #INF\n 1e-19\n ),\n self.params[1] = 64, RangeT(\n -1.7976931348623157e+308,\n 1.7976931348623157e+308,\n 1.1102230246251565e-016\n ),\n self.params[1] = 32, RangeT(\n -3.4028234e+038,\n 3.4028234e+038,\n 5.96046448e-008\n )),\n \n complexType := self >> T_Complex(self),\n));\n\nClass(T_Complex, T_Type, rec(\n hash := TComplex.hash,\n realType := self >> self.params[1],\n complexType := self >> self,\n \n isSigned := self >> self.params[1].isSigned(),\n strId := self >> \"c\"::self.params[1].strId(),\n\n check := (self, v) >> let(\n\trealt := self.params[1],\n\tcpx := Complex(v),\n\tComplex(realt.check(ReComplex(cpx)),\n\t realt.check(ImComplex(cpx))))\n));\n\n# # complex type is made up of TWO T_Real, T_Uint, or T_Int types.\n\n# Class(T_Complex, TArrayBase, rec(\n# isComplex := true,\n# __call__ := (arg) >> let(\n# self := arg[1],\n# t := arg[2],\n# Checked(\n# ObjId(t) in [T_Real, T_UInt, T_Int],\n# WithBases(self, rec(\n# t := t,\n# qualifiers := When(Length(arg) > 2, arg[3], []),\n# operations := TypOps,\n# size := 0\n# ))\n# )\n# ),\n\n# rChildren := self >> [self.t, self.qualifiers],\n# rSetChild := rSetChildFields(\"t\", \"qualifiers\"),\n\n# print := self >> Print(self.__name__, \"(\", self.t,\n# When(self.qualifiers <> [],\n# Print(\", \", self.qualifiers)\n# ),\n# \")\"\n# )\n# ));\n\n_IsVar := (e) -> code.IsVar(e);\n\n#F T_Struct: structure type.\n#F\n#F T_Struct(\"structname\", [<var1>, <var2>, ... , <varN>])\n#F\nClass(T_Struct, T_Type, rec(\n updateParams := meth(self)\n Constraint(IsString(self.params[1]));\n Constraint(IsList(self.params[2]));\n Constraint(ForAll(self.params[2], e -> _IsVar(e)));\n end,\n\n getName := self >> self.params[1],\n getVars := self >> self.params[2]\n));\n\nIsIntT := (t) -> IsType(t) and t in [TChar, TInt] or ObjId(t) = T_Int;\nIsUIntT := (t) -> IsType(t) and t in [TUChar, TUInt] or ObjId(t) = T_UInt;\nIsOrdT := (t) -> IsIntT(t) or IsUIntT(t);\n\nIsFixedPtT := (t) -> IsType(t) and ObjId(t)=TFixedPt; \n\nIsRealT := (t) -> IsType(t) and t=TReal or ObjId(t)=T_Real;\n\nIsComplexT := (t) -> IsType(t) and t=TComplex or ObjId(t)=T_Complex;\n\nIsOddInt := n -> When(IsValue(n), n.v mod 2 = 1, IsInt(n) and n mod 2 = 1);\n\nIsEvenInt := n -> When(IsValue(n), n.v mod 2 =0, IsInt(n) and n mod 2 = 0);\n", "meta": {"hexsha": "7f3a901f62ec0be325228e49b99451725e4966a3", "size": 29402, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/code/types.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/code/types.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/code/types.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 33.6022857143, "max_line_length": 129, "alphanum_fraction": 0.5354737773, "num_tokens": 8602, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3998116407397951, "lm_q2_score": 0.06097518214476315, "lm_q1q2_score": 0.024378587617705613}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\nClass(SKLR_Vx1i, SIMD_ISA, rec(\n\n includes := () -> [\"<stdlib.h>\"] :: _MM_MALLOC(), \n active := true,\n ctype := \"char\",\n instr := [],\n bits := 1,\n isFloat := false,\n isFixedPoint := false,\n splopts := rec(),\n alignment := 8,\n \n autolib := rec(\n includes := () -> [\"<include/sp_bits.h>\"],\n includesTimer := () -> [],\n ),\n\n _op_load_u := abstract(),\n _op_bcast := abstract(),\n _op_store_u := abstract(),\n \n dupload := (self, y, x) >> Checked(ObjId(x)=nth, # NOTE: is there a better way?\n\tlet(base := x.loc,\n\t ofs := x.idx,\n\t v := self.v,\n\t xvec := Cond(IsUnalignedPtrT(base.t), self._op_load_u(base, idiv(ofs,v)*v, v),\n\t\t vtref(self.t, base, idiv(ofs, v))),\n\t assign(y, self._op_bcast(xvec, imod(ofs, v))))),\n\t \n svload := [ [ ], # load using subvecs of len 1\n [ ], # load using subvecs of len 2\n [ ], # load using subvecs of len 4\n ],\n\n svstore := [ [ ], # store using subvecs of len 1\n [ ], # store using subvecs of len 2\n [ ], # store using subvecs of len 4\n ],\n\n # keep the n lower scalars and zero the other ones\n mask_l := (self, c, n) >> Cond( n = self.v, c,\n bin_and(c, self.val(Replicate(n, 1) :: Replicate(self.v - n, 0)))),\n mask_h := (self, c, n) >> Cond( n = self.v, c,\n bin_and(c, self.val(Replicate(n, 0) :: Replicate(self.v - n, 1)))),\n\n\n loadCont := (self, n, y, yofs, x, xofs, xofs_align, opts) >> let(\n\ta := _unwrap(xofs_align),\n\tnn := _unwrap(n), \n\tyy := vtref(self.t, y, yofs),\n\tm := x -> self.mask_l(x, nn),\n\tCond(a = 0 and not IsUnalignedPtrT(x.t), \n\t assign(yy, m(vtref(self.t, x, xofs/self.v))),\n\n\t # known alignment, sv is small, so that we only need 1 aligned load + 1 shift + mask\n\t ((IsInt(a) and (nn <= self.v - a)) or nn=1) and not IsUnalignedPtrT(x.t), \n\t\t let(v1 := vtref(self.t, x, idiv(xofs, self.v)), \n\t\t assign(yy, m(bin_shr(v1, a)))),\n\n\t # known alignment, sv covers 2 vectors, 2 aligned loads + 2 shifts + mask\n\t # NB: no masking is needed because shifts will do the job\n\t IsInt(a) and not IsUnalignedPtrT(x.t),\n\t\t let(v1 := vtref(self.t, x, (xofs - a)/self.v), \n\t\t v2 := vtref(self.t, x, (xofs - a)/self.v + 1),\n\t\t assign(yy, m(bin_or(bin_shr(v1, a), bin_shl(v2, self.v - a))))),\n # else, unknown alignment, use unaligned load\n assign(yy, self._op_load_u(x, xofs, nn))\n )\n ),\n\n storeCont := (self, n, y, yofs, yofs_align, x, xofs, opts) >> let(\n\ta := _unwrap(yofs_align),\n\tnn := _unwrap(n), \n\txx := vtref(self.t, x, xofs),\n\tyy := vtref(self.t, y, yofs/self.v),\n\tCond(nn = self.v and a = 0 and not IsUnalignedPtrT(y.t), \n\t assign(yy, xx),\n\t #else \n\t self._op_store_u(y, yofs, xx, nn))),\n\n rotate_left := (self, shift) >> ((y, x) -> assign(vtref(self.t, y, 0), rCyclicShift(vtref(self.t, x, 0), shift, self.v))),\n \n kswap := (self, y, x, k, mask) >> let( u := var.fresh_t(\"U\", self.t),\n chain(assign( u, bin_and(bin_xor(x, bin_shr(x, 2^(k-1))), self.t.value(mask))),\n assign( y, bin_xor(bin_xor(x, u), bin_shl(u, 2^(k-1)))))),\n\n kexch := (self, y1, y2, x1, x2, mask) >> let( u := var.fresh_t(\"U\", self.t),\n chain(assign( u, bin_and(bin_xor(x1, x2), self.t.value(mask))),\n assign( y1, bin_xor(x1, u)),\n assign( y2, bin_xor(x2, u)))),\n));\n\nClass(SKLR_16x1i, SKLR_Vx1i, rec(\n # countrec below is invalid\n countrec := rec( \n ops := [\n [add, sub], \n\t [mul],\n [sklr_bcast_16x1i], # shuffles \n [sklr_loadu_16x1i, sklr_storeu_16x1i],\n [deref],\n Value # Value without [] is a keyword in countOps !!\n ],\n printstrings := [\"[adds]\", \"[mults]\", \"[vperms]\", \"[svldst]\", \"[vldst]\", \"[vval]\"],\n type := \"TVect\",\n arithcost := (self, opcount) >> opcount[1]+opcount[2]\n ),\n\n info := \"Scalar 16 x 1-bit\",\n v := 16,\n t := BitVector(16),\n\n v_ones := BitVector(16).one(), \n v_zeros := BitVector(16).zero(),\n val := bits -> BitVector(16).value(bits),\n\n _op_load_u := (self, ptr, offs, elts) >> sklr_loadu_16x1i(ptr, offs, elts),\n _op_bcast := (self, loc, elt_num) >> sklr_bcast_16x1i(loc, elt_num),\n _op_store_u := (self, ptr, offs, src, elts) >> sklr_storeu_16x1i(ptr, offs, src, elts),\n));\n\nClass(SKLR_32x1i, SKLR_Vx1i, rec(\n # countrec below is invalid\n countrec := rec( \n ops := [\n [add, sub], \n\t [mul],\n [sklr_bcast_32x1i], # shuffles \n [sklr_loadu_32x1i, sklr_storeu_32x1i],\n [deref],\n Value # Value without [] is a keyword in countOps !!\n ],\n printstrings := [\"[adds]\", \"[mults]\", \"[vperms]\", \"[svldst]\", \"[vldst]\", \"[vval]\"],\n type := \"TVect\",\n arithcost := (self, opcount) >> opcount[1]+opcount[2]\n ),\n\n info := \"Scalar 32 x 1-bit\",\n v := 32,\n t := BitVector(32),\n\n v_ones := BitVector(32).one(), \n v_zeros := BitVector(32).zero(),\n val := bits -> BitVector(32).value(bits),\n\n _op_load_u := (self, ptr, offs, elts) >> sklr_loadu_32x1i(ptr, offs, elts),\n _op_bcast := (self, loc, elt_num) >> sklr_bcast_32x1i(loc, elt_num),\n _op_store_u := (self, ptr, offs, src, elts) >> sklr_storeu_32x1i(ptr, offs, src, elts),\n \n));\n\n\nClass(SKLR_64x1i, SKLR_Vx1i, rec(\n # countrec below is invalid\n countrec := rec( \n ops := [\n [add, sub], \n\t [mul],\n [sklr_bcast_64x1i], # shuffles \n [sklr_loadu_64x1i, sklr_storeu_64x1i],\n [deref],\n Value # Value without [] is a keyword in countOps !!\n ],\n printstrings := [\"[adds]\", \"[mults]\", \"[vperms]\", \"[svldst]\", \"[vldst]\", \"[vval]\"],\n type := \"TVect\",\n arithcost := (self, opcount) >> opcount[1]+opcount[2]\n ),\n\n info := \"Scalar 64 x 1-bit\",\n v := 64,\n t := BitVector(64),\n\n v_ones := BitVector(64).one(), \n v_zeros := BitVector(64).zero(),\n val := bits -> BitVector(64).value(bits),\n\n _op_load_u := (self, ptr, offs, elts) >> sklr_loadu_64x1i(ptr, offs, elts),\n _op_bcast := (self, loc, elt_num) >> sklr_bcast_64x1i(loc, elt_num),\n _op_store_u := (self, ptr, offs, src, elts) >> sklr_storeu_64x1i(ptr, offs, src, elts),\n));\n\n\n\nRewriteRules(RulesStrengthReduce, rec(\n aligned_loadu_32x1 := Rule( @(1, sklr_loadu_32x1i, x -> IsInt(_unwrap(x.args[2] mod 32)) and not IsUnalignedPtrT(x.args[1])),\n e -> let(\n offs := imod(e.args[2], 32),\n xx0 := vtref(e.t, e.args[1], idiv(e.args[2], 32)),\n xx1 := vtref(e.t, e.args[1], idiv(e.args[2], 32)+1),\n nn := _unwrap(e.args[3]),\n bin_and( When(offs + nn <= 32,\n bin_shr(xx0, offs),\n bin_or(bin_shr(xx0, offs), bin_shl(xx1, 32 - offs))),\n e.t.value(Replicate(nn, 1) :: Replicate(32 - nn, 0)))\n )),\n aligned_loadu_64x1 := Rule( @(1, sklr_loadu_64x1i, x -> IsInt(_unwrap(x.args[2] mod 64)) and not IsUnalignedPtrT(x.args[1])),\n e -> let(\n offs := imod(e.args[2], 64),\n xx0 := vtref(e.t, e.args[1], idiv(e.args[2], 64)),\n xx1 := vtref(e.t, e.args[1], idiv(e.args[2], 64)+1),\n nn := _unwrap(e.args[3]),\n bin_and( When(offs + nn <= 64,\n bin_shr(xx0, offs),\n bin_or(bin_shr(xx0, offs), bin_shl(xx1, 64 - offs))),\n e.t.value(Replicate(nn, 1) :: Replicate(64 - nn, 0)))\n )),\n\n));\n\nClass(SKLR_32x1i_to_SSE_16x8i, ISA_Bridge, rec(\n isa_from := SKLR_32x1i,\n isa_to := SSE_16x8i(T_Int(8)),\n\n code := (self, y, x, opts) >> let(\n xx := (offs) -> vtref(self.isa_from.t, x, offs),\n yy := (offs) -> vtref(self.isa_to.t, y, offs),\n a := var.fresh_t(\"U\", T_UInt(32)),\n b0 := var.fresh_t(\"U\", T_UInt(32)),\n b1 := var.fresh_t(\"U\", T_UInt(32)),\n b2 := var.fresh_t(\"U\", T_UInt(32)),\n b3 := var.fresh_t(\"U\", T_UInt(32)),\n mask := T_UInt(32).value(1 + 256 + 65536 + 16777216),\n decl([a,b0,b1,b2,b3], chain(\n assign( a, tcast(a.t, xx(0)) ),\n assign( b0, bin_and( a, mask)),\n assign( b1, bin_and(bin_shr(a, 1), mask)),\n assign( b2, bin_and(bin_shr(a, 2), mask)),\n assign( b3, bin_and(bin_shr(a, 3), mask)),\n assign( yy(0), tcast(self.isa_to.t, vpack(b0, b1, b2, b3))),\n assign( b0, bin_and(bin_shr(a, 4), mask)),\n assign( b1, bin_and(bin_shr(a, 5), mask)),\n assign( b2, bin_and(bin_shr(a, 6), mask)),\n assign( b3, bin_and(bin_shr(a, 7), mask)),\n assign( yy(1), tcast(self.isa_to.t, vpack(b0, b1, b2, b3)))\n ))),\n\n toAMat := self >> L(self.isa_from.v, 8).toAMat(),\n toSpl := self >> Cvt(self)*TL(self.isa_from.v, div(self.isa_from.v, 8)).withTags([AVecReg(self.isa_from)])\n));\n\nClass(SKLR_64x1i_to_SSE_16x8i, SKLR_32x1i_to_SSE_16x8i, rec(\n isa_from := SKLR_64x1i,\n isa_to := SSE_16x8i(T_Int(8)),\n\n code := (self, y, x, opts) >> let(\n xx := (offs) -> vtref(self.isa_from.t, x, offs),\n yy := (offs) -> vtref(self.isa_to.t, y, offs),\n a := var.fresh_t(\"U\", T_UInt(64)),\n b0 := var.fresh_t(\"U\", T_UInt(64)),\n b1 := var.fresh_t(\"U\", T_UInt(64)),\n mask := T_UInt(64).value(1 + 2^8 + 2^16 + 2^24 + 2^32 + 2^40 + 2^48 + 2^56),\n decl([a,b0,b1], chain(\n assign( a, tcast(a.t, xx(0)) ),\n assign( b0, bin_and( a, mask)),\n assign( b1, bin_and(bin_shr(a, 1), mask)),\n assign( yy(0), tcast(self.isa_to.t, vpack(b0, b1))),\n assign( b0, bin_and(bin_shr(a, 2), mask)),\n assign( b1, bin_and(bin_shr(a, 3), mask)),\n assign( yy(1), tcast(self.isa_to.t, vpack(b0, b1))),\n assign( b0, bin_and(bin_shr(a, 4), mask)),\n assign( b1, bin_and(bin_shr(a, 5), mask)),\n assign( yy(2), tcast(self.isa_to.t, vpack(b0, b1))),\n assign( b0, bin_and(bin_shr(a, 6), mask)),\n assign( b1, bin_and(bin_shr(a, 7), mask)),\n assign( yy(3), tcast(self.isa_to.t, vpack(b0, b1)))\n )))\n));\n\nClass(SKLR_32x1i_to_SSE_4x32f_f32, SKLR_32x1i_to_SSE_16x8i, rec(\n isa_from := SKLR_32x1i,\n isa_to := SSE_4x32f(T_Real(32)),\n\n code := (self, y, x, opts) >> let(\n xx := (offs) -> vtref(self.isa_from.t, x, offs),\n yy := (offs) -> vtref(self.isa_to.t, y, offs),\n ti := TVect(T_Int(32), 4),\n tf := TVect(T_Real(32), 4),\n a := var.fresh_t(\"U\", T_UInt(32)),\n b := var.fresh_t(\"U\", ti),\n decl( [a, b], chain( \n assign( a, tcast(a.t, xx(0)) ),\n assign( b, vpack(a, bin_shr(a, 8), bin_shr(a, 16), bin_shr(a, 24)) ),\n assign(yy(0), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b, 31), 31) ))),\n assign(yy(1), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b, 30), 31) ))),\n assign(yy(2), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b, 29), 31) ))),\n assign(yy(3), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b, 28), 31) ))),\n assign(yy(4), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b, 27), 31) ))),\n assign(yy(5), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b, 26), 31) ))),\n assign(yy(6), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b, 25), 31) ))),\n assign(yy(7), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b, 24), 31) )))\n ))\n )\n));\n\nClass(SKLR_64x1i_to_SSE_4x32f_f32, SKLR_32x1i_to_SSE_16x8i, rec(\n isa_from := SKLR_64x1i,\n isa_to := SSE_4x32f(T_Real(32)),\n\n code := (self, y, x, opts) >> let(\n xx := (offs) -> vtref(self.isa_from.t, x, offs),\n yy := (offs) -> vtref(self.isa_to.t, y, offs),\n ti := TVect(T_Int(32), 4),\n tf := TVect(T_Real(32), 4),\n a := var.fresh_t(\"U\", T_UInt(64)),\n b0 := var.fresh_t(\"U\", ti),\n b1 := var.fresh_t(\"U\", ti),\n shift := (t, n) -> tcast(T_Int(32), bin_shr(t, n)),\n decl( [a, b0, b1], chain( \n assign( a, tcast(a.t, xx(0)) ),\n assign( b0, vpack(shift(a, 0), shift(a, 8), shift(a, 16), shift(a, 24)) ),\n assign( b1, vpack(shift(a, 32), shift(a, 40), shift(a, 48), shift(a, 56)) ),\n assign(yy( 0), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b0, 31), 31) ))),\n assign(yy( 1), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b1, 31), 31) ))),\n assign(yy( 2), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b0, 30), 31) ))),\n assign(yy( 3), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b1, 30), 31) ))),\n assign(yy( 4), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b0, 29), 31) ))),\n assign(yy( 5), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b1, 29), 31) ))),\n assign(yy( 6), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b0, 28), 31) ))),\n assign(yy( 7), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b1, 28), 31) ))),\n assign(yy( 8), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b0, 27), 31) ))),\n assign(yy( 9), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b1, 27), 31) ))),\n assign(yy(10), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b0, 26), 31) ))),\n assign(yy(11), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b1, 26), 31) ))),\n assign(yy(12), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b0, 25), 31) ))),\n assign(yy(13), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b1, 25), 31) ))),\n assign(yy(14), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b0, 24), 31) ))),\n assign(yy(15), tcast(tf, bin_and( tf.one(), arith_shr(bin_shl(b1, 24), 31) )))\n ))\n )\n));\n\n# NOTE: assumption that most significant bit is set for non zero numbers:\n#\n# SSE_16x8i_i8_to_SKLR_32x1i can be implemented as \n# neg(vmovemask_16x8i(eq(self.isa_from.t.zero(), xx(2*i))))\n# and later simplified if xx(2*i) comes from comparision, yet we cannot match this situation\n# because it's unlikely that we will have comparision propagated into this expression.\n# Another way is to make T_Bool and simplify expression above by looking at data type.\n\nISA_Bridge.add(Class(CVT_SKLR_16x1i_SSE_16x8i, ISA_Bridge_I, rec(\n isa_from := SSE_16x8i(T_Int(8)),\n isa_to := SKLR_16x1i,\n props := [\"saturation\"],\n code := (self, y, x, opts) >> assign(self._y(y,0), vmovemask_16x8i(self._x(x,0))),\n)));\n\nISA_Bridge.add(Class(CVT_SKLR_16x1i_SSE_16x8ui, CVT_SKLR_16x1i_SSE_16x8i, rec(\n isa_from := SSE_16x8i(T_UInt(8)),\n)));\n\nClass(SKLR_32f_to_SKLR_32x1i, ISA_Bridge_I, rec(\n isa_from := SKLR(T_Real(32)),\n isa_to := SKLR_32x1i,\n granularity := self >> self.isa_to.v,\n\n code := (self, y, x, opts) >> let(\n j := Ind(self.isa_to.v),\n xt := self.isa_from.t,\n yt := T_UInt(self.isa_to.v),\n yy := (offs) -> vtref(self.isa_to.t, y, offs),\n a := var.fresh_t(\"U\", yt),\n decl([a], chain(\n assign(a, a.t.zero()),\n loop(j, j.range, \n assign(a, bin_or(a, cond(eq(nth(x, j), xt.zero()), yt.zero(), bin_shl(yt.one(), j))))),\n assign(yy(0), a)\n ))\n ),\n));\n\nClass(SKLR_32f_to_SKLR_64x1i, SKLR_32f_to_SKLR_32x1i, rec(\n isa_from := SKLR(T_Real(32)),\n isa_to := SKLR_64x1i\n));\n\n\nClass(SKLR_64x1i_to_SKLR_32f, ISA_Bridge_I, rec(\n isa_from := SKLR_64x1i,\n isa_to := SKLR(T_Real(32)),\n granularity := self >> self.isa_from.v,\n\n code := (self, y, x, opts) >> let(\n j := Ind(self.isa_from.v),\n xx := (offs) -> vtref(self.isa_from.t, x, offs),\n ti := T_UInt(self.isa_from.v),\n tf := self.isa_to.t,\n a := var.fresh_t(\"U\", ti),\n decl( [a], chain( \n assign( a, tcast(a.t, xx(0)) ),\n loop(j, j.range, \n assign( nth(y, j), tcvt( tf, bin_and(bin_shr(a, j), a.t.one())))\n ).unroll()\n ))\n ),\n));\n\n\nClass(SKLR_32x1i_to_SKLR_32f, SKLR_64x1i_to_SKLR_32f, rec(\n isa_from := SKLR_32x1i,\n isa_to := SKLR(T_Real(32))\n));\n\nClass(SKLR_64x1i_to_SKLR_8i, SKLR_64x1i_to_SKLR_32f, rec(\n isa_from := SKLR_64x1i,\n isa_to := SKLR(T_Int(8))\n));\n\nClass(SKLR_32x1i_to_SKLR_8i, SKLR_64x1i_to_SKLR_32f, rec(\n isa_from := SKLR_32x1i,\n isa_to := SKLR(T_Int(8))\n));\n\n\n\n\nISA_Bridge.add(Class(CVT_SKLR_32x1i_SKLR_16x1i, ISA_Bridge_I, rec(\n isa_from := SKLR_16x1i,\n isa_to := SKLR_32x1i,\n code := (self, y, x, opts) >> \n assign(self._y(y,0), bin_or(tcvt(T_UInt(32), self._x(x,0)), bin_shl(tcvt(T_UInt(32), self._x(x,1)), 16)) ),\n)));\n\nISA_Bridge.add(Class(CVT_SKLR_64x1i_SKLR_16x1i, ISA_Bridge_I, rec(\n isa_from := SKLR_16x1i,\n isa_to := SKLR_64x1i,\n code := (self, y, x, opts) >> \n assign(self._y(y,0), bin_or(\n tcvt(T_UInt(64), self._x(x,0)),\n bin_shl(tcvt(T_UInt(64), self._x(x,1)), 16),\n bin_shl(tcvt(T_UInt(64), self._x(x,2)), 32),\n bin_shl(tcvt(T_UInt(64), self._x(x,3)), 48)\n )),\n)));\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n", "meta": {"hexsha": "846821ee7c6c00646b3b3c49e996c9214008078d", "size": 19483, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/platforms/scalar/bitisa/isa.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/platforms/scalar/bitisa/isa.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/platforms/scalar/bitisa/isa.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 42.262472885, "max_line_length": 129, "alphanum_fraction": 0.4771852384, "num_tokens": 6188, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3849121585956185, "lm_q2_score": 0.05921024866613546, "lm_q1q2_score": 0.02279074462506554}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\nClass(ScratchpadGlobals, rec(\n getOpts := meth(arg)\n local lssize, opts, swp, brules, nrules, br, nrsgmts, vlen, globalUnrolling,size, ttype;\n\n\tlssize := When (Length(arg) >= 2, arg[2], 2);\n\tnrsgmts := When (Length(arg) >= 3, arg[3], 1);\n\tvlen := When (Length(arg) >= 4, arg[4], 1);\n\tsize := When (Length(arg) >= 5, arg[5], 2);\n ttype := When (Length(arg) >= 6, arg[6], 'R');\n\tswp := When (Length(arg) >= 7, arg[7], false);\n\tglobalUnrolling := When(Length(arg) >=8, arg[8], 1);\n\n brules := When(IsRec(SpiralDefaults.breakdownRules),\n UserRecFields(SpiralDefaults.breakdownRules),\n Filtered(Dir(SpiralDefaults.breakdownRules), i->not i in SystemRecFields));\n nrules := rec();\n for br in brules do\n nrules.(br) := List(SpiralDefaults.breakdownRules.(br), i->CopyFields(i));\n od;\n opts := CopyFields(SpiralDefaults);\n opts.breakdownRules := nrules;\n\n opts.breakdownRules.TCompose := [ TCompose_tag];\n opts.breakdownRules.DFT := [DFT_Base, DFT_CT, DFT_tSPL_CT, DFT_PD, DFT_Rader];\n opts.breakdownRules.TTwiddle := [ TTwiddle_Tw1];\n \n\topts.breakdownRules.WHT := [WHT_tSPL_BinSplit, WHT_Base, WHT_BinSplit];\n \n\topts.breakdownRules.TTensor := [AxI_IxB,IxB_AxI];\n\topts.breakdownRules.TTensorI := Concat([IxA_scratch_push, IxA_base, AxI_base, IxA_L_base, L_IxA_base], [IxA_scratch, AxI_scratch, IxAL_scratch]);\n\t\n\topts.tags := [Cond( ttype = 'R', ALStore(lssize,nrsgmts,vlen), ALStoreCx(lssize,nrsgmts,vlen)) ];\n\n\topts.formulaStrategies.sigmaSpl := [ MergedRuleSet(RulesSumsScratch, RulesFuncSimpScratch, RulesDiag, RulesDiagStandalone, RulesStrengthReduce, RulesRCScratch,RulesII,OLRules) ];\n opts.formulaStrategies.preRC := [ MergedRuleSet(RulesSumsScratch, RulesFuncSimpScratch, RulesDiag, RulesDiagStandalone, RulesStrengthReduce, RulesRCScratch, RulesII, OLRules), (s,o) -> ScratchModel.updateInfo(s) ];\n\topts.formulaStrategies.rc := [ MergedRuleSet(RulesSums, RulesFuncSimp, RulesDiag, RulesDiagStandalone, RulesStrengthReduce, RulesRCScratch, RulesII, OLRules) ];\n #opts.formulaStrategies.postProcess := [(s, opts) -> compiler.BlockSums(opts.globalUnrolling, s)];\n opts.size := size;\n\topts.swp := swp;\n opts.globalUnrolling := globalUnrolling;\n\n opts.sumsgen := ScratchSumsGen;\n\topts.codegen := ScratchCodegen;\n opts.unparser := CScratchUnparserProg;\n\n opts.memModifier := \"__memory\";\n opts.scratchModifier := \"__scratch\";\n opts.arrayDataModifier := \"__rom\";\n opts.romModifier := \"__rom\";\n\t\n\topts.includes := [];\n Add(opts.includes, \"\\\"scratch.h\\\"\");\n\n opts.dmaSignal := (self, opts) >> \"DMA_signal\";\n opts.dmaWait := (self, opts) >> \"DMA_wait\";\n opts.cpuSignal := (self, opts) >> \"CPU_signal\";\n opts.cpuWait := (self, opts) >> \"CPU_wait\";\n opts.dmaFence := (self, opts) >> \"DMA_fence\";\n opts.dmaLoad := (self, opts) >> \"DMA_load\";\n opts.dmaStore := (self, opts) >> \"DMA_store\";\n opts.model := ScratchModel;\n\n return opts;\n end\n));\n\n", "meta": {"hexsha": "3fbbed013009328b15e017e6060620316ae78a87", "size": 3040, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/paradigms/scratchpad/opts.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/paradigms/scratchpad/opts.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/paradigms/scratchpad/opts.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 42.2222222222, "max_line_length": 218, "alphanum_fraction": 0.6861842105, "num_tokens": 938, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47268347662043286, "lm_q2_score": 0.03732688439914231, "lm_q1q2_score": 0.017643801489195584}}
{"text": "#############################################################################\n##\n#W selfsimgroup.gi automgrp package Yevgen Muntyan\n#W Dmytro Savchuk\n##\n#Y Copyright (C) 2003 - 2018 Yevgen Muntyan, Dmytro Savchuk\n##\n\n\n###############################################################################\n##\n#M SelfSimilarGroup(<list>)\n##\nInstallMethod(SelfSimilarGroup, \"for [IsList]\", [IsList],\nfunction(list)\n return SelfSimilarGroup(list, false);\nend);\n\n\n###############################################################################\n##\n#M SelfSimilarGroup(<list>, <bind_vars>)\n##\nInstallMethod(SelfSimilarGroup, \"for [IsList, IsBool]\", [IsList, IsBool],\nfunction(list, bind_vars)\n if not AG_IsCorrectRecurList(list, true) then\n Error(\"in SelfSimilarGroup(IsList, IsBool):\\n\",\n \" given list is not a correct list representing self-similar group\\n\");\n fi;\n\n return GroupOfSelfSimFamily(SelfSimFamily(list, bind_vars));\nend);\n\n\n###############################################################################\n##\n#M SelfSimilarGroup(<list>, <names>)\n##\nInstallMethod(SelfSimilarGroup, \"for [IsList, IsList]\", [IsList, IsList],\nfunction(list, names)\n return SelfSimilarGroup(list, names, AG_Globals.bind_vars_autom_family);\nend);\n\n\n###############################################################################\n##\n#M SelfSimilarGroup(<list>, <names>, <bind_vars>)\n##\nInstallMethod(SelfSimilarGroup,\n \"for [IsList, IsList, IsBool]\", [IsList, IsList, IsBool],\nfunction(list, names, bind_vars)\n if not AG_IsCorrectRecurList(list, true) then\n Error(\"error in SelfSimilarGroup(IsList, IsList, IsBool):\\n\",\n \" given list is not a correct list representing self-similar group\\n\");\n fi;\n\n return GroupOfSelfSimFamily(SelfSimFamily(list, names, bind_vars));\nend);\n\n\n###############################################################################\n##\n#M SelfSimilarGroup(<string>)\n#M SelfSimilarGroup(<string>, <bind_vars>)\n##\nInstallMethod(SelfSimilarGroup, \"for [IsString]\", [IsString],\nfunction(string)\n return SelfSimilarGroup(string, AG_Globals.bind_vars_autom_family);\nend);\n\nInstallMethod(SelfSimilarGroup, \"for [IsString, IsBool]\", [IsString, IsBool],\nfunction(string, bind_vars)\n local s;\n s := AG_ParseAutomatonStringFR(string);\n return SelfSimilarGroup(s[2], s[1], bind_vars);\nend);\n\n\n###############################################################################\n##\n#M SelfSimilarGroup(<A>)\n#M SelfSimilarGroup(<A>, <bind_vars>)\n##\nInstallMethod(SelfSimilarGroup, \"for [IsMealyAutomaton]\", [IsMealyAutomaton],\nfunction(A)\n if not IsInvertible(A) then\n Error(\"Automaton <A> is not invertible\");\n fi;\n return SelfSimilarGroup(AutomatonList(A), A!.states);\nend);\n\nInstallMethod(SelfSimilarGroup, \"for [IsMealyAutomaton, IsBool]\", [IsMealyAutomaton, IsBool],\nfunction(A, bind_vars)\n if not IsInvertible(A) then\n Error(\"Automaton <A> is not invertible\");\n fi;\n return SelfSimilarGroup(AutomatonList(A), A!.states, bind_vars);\nend);\n\n\n\n###############################################################################\n##\n#M GroupOfSelfSimFamily(<G>)\n##\nInstallMethod(GroupOfSelfSimFamily, \"for [IsSelfSimGroup]\",\n [IsSelfSimGroup],\nfunction(G)\n return GroupOfSelfSimFamily(UnderlyingSelfSimFamily(G));\nend);\n\n\n###############################################################################\n##\n#M IsGroupOfSelfSimFamily(<G>)\n##\nInstallMethod(IsGroupOfSelfSimFamily, \"for [IsSelfSimGroup]\",\n [IsSelfSimGroup],\nfunction(G)\n return G = GroupOfSelfSimFamily(G);\nend);\n\n\n###############################################################################\n##\n#M UseSubsetRelation(<G>)\n##\nInstallMethod(UseSubsetRelation,\n \"for [IsSelfSimGroup, IsSelfSimGroup]\",\n [IsSelfSimGroup, IsSelfSimGroup],\nfunction(super, sub)\n ## the full group is self similar, so if <super> is smaller than the full\n ## group then sub is smaller either\n if HasIsGroupOfSelfSimFamily(super) then\n if not IsGroupOfSelfSimFamily(super) then\n SetIsGroupOfSelfSimFamily(sub, false); fi; fi;\n TryNextMethod();\nend);\n\n\n###############################################################################\n##\n#M __AG_SubgroupOnLevel(<G>, <gens>, <level>)\n##\nInstallMethod(__AG_SubgroupOnLevel, [IsSelfSimGroup,\n IsList and IsTreeAutomorphismCollection,\n IsPosInt],\nfunction(G, gens, level)\n local overgroup;\n\n if IsEmpty(gens) or (Length(gens) = 1 and IsOne(gens[1])) then\n return TrivialSubgroup(G);\n fi;\n\n if HasIsGroupOfSelfSimFamily(G) and IsGroupOfSelfSimFamily(G) then\n overgroup := G;\n else\n overgroup := GroupOfSelfSimFamily(UnderlyingSelfSimFamily(G));\n fi;\n\n return SubgroupNC(overgroup, gens);\nend);\n\nInstallOtherMethod(__AG_SubgroupOnLevel, [IsSelfSimGroup, IsList and IsEmpty, IsPosInt],\nfunction(G, gens, level)\n return TrivialSubgroup(G);\nend);\n\nInstallMethod(__AG_SubgroupOnLevel, [IsTreeAutomorphismGroup,\n IsList and IsSelfSimCollection,\n IsPosInt],\nfunction(G, gens, level)\n local overgroup;\n\n overgroup := GroupOfSelfSimFamily(FamilyObj(gens[1]));\n\n if Length(gens) = 1 and IsOne(gens[1]) then\n return TrivialSubgroup(overgroup);\n fi;\n\n return SubgroupNC(overgroup, gens);\nend);\n\nInstallMethod(__AG_SimplifyGroupGenerators, \"for [IsList and IsInvertibleSelfSimCollection]\",\n [IsList and IsInvertibleSelfSimCollection],\nfunction(gens)\n local words, fam;\n\n if IsEmpty(gens) then\n return [];\n fi;\n\n fam := FamilyObj(gens[1]);\n words := FreeGeneratorsOfGroup(Group(List(gens, a -> a!.word)));\n\n if fam!.use_rws and not IsEmpty(words) then\n words := AG_ReducedForm(fam!.rws, words);\n if IsEmpty(words) then\n return [];\n fi;\n words := FreeGeneratorsOfGroup(Group(words));\n fi;\n\n return List(words, w -> SelfSim(w, fam));\nend);\n\n###############################################################################\n##\n#M PrintObj(<G>)\n##\nInstallMethod(PrintObj, \"for [IsSelfSimilarGroup]\",\n [IsSelfSimilarGroup],\nfunction(G)\n Print(\"SelfSimilarGroup(\\\"\", String(G), \"\\\")\");\nend);\n\n\n###############################################################################\n##\n#M Display(<G>)\n##\nInstallMethod(Display, \"for [IsSelfSimGroup]\",\n [IsSelfSimGroup],\nfunction(G)\n local i, gens, printone;\n\n printone := function(a)\n Print(a, \" = \", Decompose(a));\n end;\n\n gens := GeneratorsOfGroup(G);\n if gens = [] then Print(\"< >\"); fi;\n if Length(gens) = 1 then\n Print(\"< \"); printone(gens[1]); Print(\" >\");\n else\n Print(\"< \"); printone(gens[1]); Print(\", \\n\");\n for i in [2..Length(gens)-1] do\n Print(\" \"); printone(gens[i]); Print(\", \\n\");\n od;\n Print(\" \"); printone(gens[Length(gens)]); Print(\" >\");\n fi;\nend);\n\n\n#############################################################################\n##\n#M String(<G>)\n##\nInstallMethod(String, \"for [IsSelfSimGroup]\", [IsSelfSimGroup],\nfunction(G)\n local i, gens, formatone, s;\n\n formatone := function(a)\n return Concatenation(String(a), \" = \", String(Decompose(a)));\n end;\n\n gens := GeneratorsOfGroup(G);\n\n s := \"\";\n for i in [1..Length(gens)] do\n Append(s, formatone(gens[i]));\n if i <> Length(gens) then\n Append(s, \", \");\n fi;\n od;\n\n return s;\nend);\n\n\n###############################################################################\n##\n#M ViewObj(<G>)\n##\nInstallMethod(ViewObj, \"for [IsSelfSimGroup]\",\n [IsSelfSimGroup],\nfunction(G)\n local i, gens;\n gens := List(GeneratorsOfGroup(G), g -> Word(g));\n if gens = [] then Print(\"< >\"); fi;\n Print(\"< \");\n for i in [1..Length(gens)-1] do\n if IsOne(gens[i]) then\n Print(AG_Globals.identity_symbol, \", \");\n else\n Print(gens[i], \", \");\n fi;\n od;\n if IsOne(gens[Length(gens)]) then\n Print(AG_Globals.identity_symbol, \" >\");\n else\n Print(gens[Length(gens)], \" >\");\n fi;\nend);\n\n\n\n###############################################################################\n##\n#M IsFractalByWords(G)\n##\nInstallMethod(IsFractalByWords, \"for [IsSelfSimGroup]\",\n [IsSelfSimGroup],\nfunction (G)\n local freegens, stab, i, sym, f;\n\n sym := GroupWithGenerators(List(GeneratorsOfGroup(G), g -> Perm(g)));\n if not IsTransitive(sym, [1..DegreeOfTree(G)]) then\n Info(InfoAutomGrp, 1, \"group is not transitive on first level\");\n return false;\n fi;\n\n f := GroupWithGenerators(List(GeneratorsOfGroup(G), g -> Word(g)));\n stab := StabilizerOfFirstLevel(G);\n stab := List(GeneratorsOfGroup(stab), a -> StatesWords(a));\n\n for i in [1..DegreeOfTree(G)] do\n if f <> GroupWithGenerators(List(stab, s -> s[i])) then\n return false;\n fi;\n od;\n return true;\nend);\n\n\n###############################################################################\n##\n#M Size(G)\n##\nInstallMethod(Size, \"for [IsSelfSimGroup]\", [IsSelfSimGroup],\nfunction (G)\n local f;\n if IsTrivial(G) then\n Info(InfoAutomGrp, 3, \"Size(G): 1, G is trivial\");\n return 1;\n fi;\n\n if CanEasilyTestSphericalTransitivity(G) and IsSphericallyTransitive(G) then\n Info(InfoAutomGrp, 3, \"Size(G): infinity, G is spherically transitive\");\n return infinity;\n fi;\n\n if IsFractalByWords(G) then\n Info(InfoAutomGrp, 3, \"Size(G): infinity, G is fractal by words\");\n return infinity;\n fi;\n\n if HasIsFractal(G) and IsFractal(G) then\n Info(InfoAutomGrp, 3, \"Size(G): infinity, G is fractal\");\n return infinity;\n fi;\n\n if IsSelfSimilarGroup(G) and LevelOfFaithfulAction(G, 8)<>fail then\n return Size(G);\n fi;\n\n f := FindElementOfInfiniteOrder(G, 10, 10);\n\n if HasSize(G) or f <> fail then\n return Size(G);\n fi;\n\n Info(InfoAutomGrp, 1, \"You can try to use IsomorphismPermGroup(<G>) or\\n\",\n \" FindElementOfInfiniteOrder( <G>, <length>, <depth> ) with bigger bounds\");\n TryNextMethod();\nend);\n\n\nInstallOtherMethod(LevelOfFaithfulAction, \"for [IsSelfSimGroup and IsSelfSimilar, IsCyclotomic]\",\n [IsSelfSimGroup and IsSelfSimilar, IsCyclotomic],\nfunction(G, max_lev)\n local s, s_next, lev;\n if HasIsFinite(G) and not IsFinite(G) then return fail; fi;\n if HasLevelOfFaithfulAction(G) then return LevelOfFaithfulAction(G); fi;\n lev := 0; s := 1; s_next := Size(PermGroupOnLevel(G, 1));\n while s<s_next and lev<max_lev do\n lev := lev+1;\n s := s_next;\n s_next := Size(PermGroupOnLevel(G, lev+1));\n od;\n if s=s_next then\n SetSize(G, s);\n SetLevelOfFaithfulAction(G, lev);\n return lev;\n else\n return fail;\n fi;\nend);\n\n\nInstallMethod(LevelOfFaithfulAction, \"for [IsSelfSimGroup and IsSelfSimilar]\",\n [IsSelfSimGroup and IsSelfSimilar],\nfunction(G)\n return LevelOfFaithfulAction(G, infinity);\nend);\n\n\n################################################################################\n##\n#O IsomorphismPermGroup (<G>)\n#O IsomorphismPermGroup (<G>, <max_lev>)\n##\n## For a given finite group <G> generated by initial automata or by elements defined by\n## wreath recursion\n## computes an isomorphism from <G> into a finite permutational group.\n## If <G> is not known to be self-similar (see \"IsSelfSimilar\") the isomorphism is based on the\n## regular representation, which works generally much slower. If <G> is self-similar\n## there is a level of the tree (see \"LevelOfFaithfulAction\"), where <G> acts faithfully.\n## The corresponding representation is returned in this case. If <max_lev> is given\n## it finds only the first <max_lev> quotients by stabilizers and if all of them have\n## different size it returns `fail'.\n## If <G> is infinite and <max_lev> is not specified it will loop forever.\n##\n## For example, consider a subgroup $\\langle a, b\\rangle$ of Grigorchuk group.\n## \\beginexample\n## gap> Grigorchuk_Group := AutomatonGroup(\"a=(1,1)(1,2),b=(a,c),c=(a,d),d=(1,b)\");\n## < a, b, c, d >\n## gap> f := IsomorphismPermGroup(Group(a, b));\n## MappingByFunction( < a, b >, Group(\n## [ (1,2)(3,5)(4,6)(7,9)(8,10)(11,13)(12,14)(15,17)(16,18)(19,21)(20,22)(23,\n## 25)(24,26)(27,29)(28,30)(31,32), (1,3)(2,4)(5,7)(6,8)(9,11)(10,12)(13,\n## 15)(14,16)(17,19)(18,20)(21,23)(22,24)(25,27)(26,28)(29,31)(30,32)\n## ]), function( g ) ... end, function( b ) ... end )\n## gap> Size(Image(f));\n## 32\n## gap> H := SelfSimilarGroup(\"a=(a*b,1)(1,2), b=(1,b*a^-1)(1,2), c=(b, a*b)\");\n## < a, b, c >\n## gap> f1 := IsomorphismPermGroup(H);\n## MappingByFunction( < a, b, c >, Group([ (1,3)(2,4), (1,3)(2,4), (1,2)\n## ]), function( g ) ... end, function( b ) ... end )\n## gap> Size(Image(f1));\n## 8\n## gap> PreImagesRepresentative(f1, (1,3,2,4));\n## a*c\n## gap> (a*c)^f1;\n## (1,3,2,4)\n## \\endexample\n##\nInstallOtherMethod(IsomorphismPermGroup, \"for [IsSelfSimilarGroup, IsCyclotomic]\",\n [IsSelfSimGroup and IsSelfSimilar, IsCyclotomic],\nfunction (G, n)\n local H, lev;\n lev := LevelOfFaithfulAction(G, n);\n if lev <> fail then\n H := PermGroupOnLevel(G, LevelOfFaithfulAction(G));\n return AG_GroupHomomorphismByImagesNC(G, H, GeneratorsOfGroup(G), GeneratorsOfGroup(H));\n fi;\n return fail;\nend);\n\n\n###############################################################################\n##\n#M IsSphericallyTransitive(G)\n##\nInstallMethod(IsSphericallyTransitive, \"for [IsSelfSimGroup]\",\n [IsSelfSimGroup],\nfunction (G)\n local x, rat_gens, abel_hom, lev;\n\n if IsFractalByWords(G) then\n Info(InfoAutomGrp, 3, \"IsSphericallyTransitive(G): true\");\n Info(InfoAutomGrp, 3, \" G is fractal\");\n return true;\n fi;\n\n if IsTrivial(G) then\n Info(InfoAutomGrp, 3, \"IsSphericallyTransitive(G): false\");\n Info(InfoAutomGrp, 3, \" G is trivial: G = \", G);\n return false;\n fi;\n\n if HasIsFinite(G) and IsFinite(G) then\n Info(InfoAutomGrp, 3, \"IsSphericallyTransitive(G): false\");\n Info(InfoAutomGrp, 3, \" IsFinite(G): G = \", G);\n return false;\n fi;\n\n if DegreeOfTree(G) = 2 and TestSelfSimilarity(G) and IsSelfSimilar(G) then\n if HasIsFinite(G) and IsFinite(G)=false then\n Info(InfoAutomGrp, 3, \"IsSphericallyTransitive(G): true\");\n Info(InfoAutomGrp, 3, \" <G> is infinite self-similar acting on binary tree\");\n return true;\n fi;\n if PermGroupOnLevel(G, 2)=Group((1, 4, 2, 3)) then\n Info(InfoAutomGrp, 3, \"IsSphericallyTransitive(G): true\");\n Info(InfoAutomGrp, 3, \" any element which acts transitively on the first level acts spherically transitively\");\n return true;\n fi;\n fi;\n\n for lev in [1..8] do\n if not IsTransitiveOnLevel(G,lev) then\n Info(InfoAutomGrp, 3, \"IsSphericallyTransitive(G): false\");\n Info(InfoAutomGrp, 3, \" the group does not act transitively on level \", lev);\n return false;\n fi;\n od;\n\n TryNextMethod();\nend);\n\n\n###############################################################################\n##\n#M DiagonalPower(<G>, <n>)\n##\nInstallOtherMethod( DiagonalPower,\n \"for [IsSelfSimGroup and IsGroupOfSelfSimFamily, IsPosInt]\",\n [IsSelfSimGroup and IsGroupOfSelfSimFamily, IsPosInt],\nfunction(G, n)\n return DiagonalPower(UnderlyingSelfSimFamily(G), n);\nend);\n\n\n###############################################################################\n##\n#M MultAutomAlphabet(<G>, <n>)\n##\nInstallOtherMethod( MultAutomAlphabet,\n \"for [IsSelfSimGroup and IsGroupOfSelfSimFamily, IsPosInt]\",\n [IsSelfSimGroup and IsGroupOfSelfSimFamily, IsPosInt],\nfunction(G, n)\n return MultAutomAlphabet(UnderlyingSelfSimFamily(G), n);\nend);\n\n\n###############################################################################\n##\n#M \\= (<G>, <H>)\n##\nInstallMethod(\\=, \"for [IsSelfSimGroup, IsSelfSimGroup]\",\n IsIdenticalObj, [IsSelfSimGroup, IsSelfSimGroup],\nfunction(G, H)\n local fgens1, fgens2, fam;\n\n if HasIsGroupOfSelfSimFamily(G) and HasIsGroupOfSelfSimFamily(H) then\n if IsGroupOfSelfSimFamily(G) <> IsGroupOfSelfSimFamily(H) then\n Info(InfoAutomGrp, 3, \"G = H: false, exactly one is GroupOfSelfSimFamily\");\n return false;\n fi;\n if IsGroupOfSelfSimFamily(G) then\n Info(InfoAutomGrp, 3, \"G = H: true, both are GroupOfSelfSimFamily\");\n return true;\n fi;\n fi;\n\n fgens1 := List(GeneratorsOfGroup(G), g -> Word(g));\n fgens2 := List(GeneratorsOfGroup(H), g -> Word(g));\n fam := UnderlyingSelfSimFamily(G);\n\n if fam!.rws <> fail then\n fgens1 := AG_ReducedForm(fam!.rws, fgens1);\n fgens2 := AG_ReducedForm(fam!.rws, fgens2);\n fi;\n\n if GroupWithGenerators(fgens1) = GroupWithGenerators(fgens2) then\n Info(InfoAutomGrp, 3, \"G = H: true, by subgroups of free group\");\n return true;\n fi;\n\n TryNextMethod();\nend);\n\n\n###############################################################################\n##\n#M IsSubset (<G>, <H>)\n##\nInstallMethod(IsSubset, \"for [IsSelfSimGroup, IsSelfSimGroup]\",\n IsIdenticalObj, [IsSelfSimGroup, IsSelfSimGroup],\nfunction(G, H)\n local h, fam, fgens1, fgens2;\n\n if HasIsGroupOfSelfSimFamily(G) and IsGroupOfSelfSimFamily(G) then\n Info(InfoAutomGrp, 3, \"IsSubgroup(G, H): true\");\n Info(InfoAutomGrp, 3, \" G is GroupOfSelfSimFamily\");\n return true;\n fi;\n\n fgens1 := List(GeneratorsOfGroup(G), g -> Word(g));\n fgens2 := List(GeneratorsOfGroup(H), g -> Word(g));\n fam := UnderlyingSelfSimFamily(G);\n\n if fam!.rws <> fail then\n fgens1 := AG_ReducedForm(fam!.rws, fgens1);\n fgens2 := AG_ReducedForm(fam!.rws, fgens2);\n fi;\n\n if IsSubgroup(GroupWithGenerators(fgens1), GroupWithGenerators(fgens2)) then\n Info(InfoAutomGrp, 3, \"IsSubgroup(G, H): true\");\n Info(InfoAutomGrp, 3, \" by subgroups of free group\");\n return true;\n fi;\n\n TryNextMethod();\nend);\n\n\n###############################################################################\n##\n#M <g> in <G>\n##\nInstallMethod(\\in, \"for [IsSelfSim, IsSelfSimGroup]\",\n [IsSelfSim, IsSelfSimGroup],\nfunction(g, G)\n local fam, fgens, w;\n\n if HasIsGroupOfSelfSimFamily(G) and IsGroupOfSelfSimFamily(G) then\n return true;\n fi;\n\n fgens := List(GeneratorsOfGroup(G), g -> Word(g));\n w := Word(g);\n\n fam := UnderlyingSelfSimFamily(G);\n\n if fam!.rws <> fail then\n fgens := AG_ReducedForm(fam!.rws, fgens);\n w := AG_ReducedForm(fam!.rws, w);\n fi;\n\n if w in GroupWithGenerators(fgens) then\n Info(InfoAutomGrp, 3, \"g in G: true\");\n Info(InfoAutomGrp, 3, \" by elements of free group\");\n Info(InfoAutomGrp, 3, \" g = \", g, \"; G = \", G);\n return true;\n fi;\n\n TryNextMethod();\nend);\n\n\n###############################################################################\n##\n#O Random(<G>)\n##\n## Returns a random element of a group (semigroup) <G>. The operation is based\n## on the generator of random elements in free groups and semigroups.\n##\n## \\beginexample\n## gap> Basilica := AutomatonGroup( \"u=(v,1)(1,2), v=(u,1)\" );\n## < u, v >\n## gap> Random( Basilica );\n## v*u^-3\n## \\endexample\n##\nInstallMethodWithRandomSource(Random, \"for a random source and [IsSelfSimGroup]\",\n [IsRandomSource, IsSelfSimGroup],\nfunction(rs, G)\n local F, gens, pi;\n\n if IsTrivial(G) then\n return One(G);\n elif IsSelfSimilarGroup(G) then\n return SelfSim(Random(rs, UnderlyingFreeGroup(G)), UnderlyingSelfSimFamily(G));\n else\n gens := GeneratorsOfGroup(G);\n F := FreeGroup(Length(gens));\n pi := GroupHomomorphismByImagesNC(F, G, GeneratorsOfGroup(F), gens);\n return Random(rs, F)^pi;\n fi;\nend);\n\n\n###############################################################################\n##\n#M UnderlyingFreeSubgroup(<G>)\n##\nInstallMethod(UnderlyingFreeSubgroup, \"for [IsSelfSimGroup]\",\n [IsSelfSimGroup],\nfunction(G)\n local f;\n if HasIsGroupOfSelfSimFamily(G) and IsGroupOfSelfSimFamily(G) then\n return UnderlyingFreeGroup(G);\n fi;\n f := Subgroup(UnderlyingFreeGroup(G), UnderlyingFreeGenerators(G));\n if f = UnderlyingFreeGroup(G) then\n SetIsGroupOfSelfSimFamily(G, true);\n fi;\n return f;\nend);\n\n\n###############################################################################\n##\n#M UnderlyingFreeGenerators(<G>)\n##\nInstallMethod(UnderlyingFreeGenerators, \"for [IsSelfSimGroup]\",\n [IsSelfSimGroup],\nfunction(G)\n return List(GeneratorsOfGroup(G), g -> Word(g));\nend);\n\n\n###############################################################################\n##\n#M TrivialSubmagmaWithOne(<G>)\n##\nInstallMethod(TrivialSubmagmaWithOne, \"for [IsSelfSimGroup]\",\n [IsSelfSimGroup],\nfunction(G)\n return Subgroup(G, [One(G)]);\nend);\n\n\n###############################################################################\n##\n#M IsSelfSimilarGroup(<G>)\n##\n## Returns `true' if generators of <G> coincide with generators of the family\nInstallImmediateMethod(IsSelfSimilarGroup, IsSelfSimGroup, 0,\nfunction(G)\n local fam;\n fam := UnderlyingSelfSimFamily(G);\n return fam!.numstates = 0 or\n GeneratorsOfGroup(G) = fam!.recurgens{[1..fam!.numstates]};\nend);\n\n\n###############################################################################\n##\n#M RecurList(<G>)\n##\nInstallMethod(RecurList, \"for [IsSelfSimGroup]\",\n [IsSelfSimGroup],\nfunction(G)\n if IsSelfSimilarGroup(G) then\n return RecurList(GroupOfSelfSimFamily(UnderlyingSelfSimFamily(G)));\n else\n Error(\"Group <G> is not necessarily self-similar\");\n fi;\nend);\n\n\n###############################################################################\n##\n#M IsSelfSimilar(<G>)\n##\nInstallMethod(IsSelfSimilar, \"for [IsSelfSimGroup]\",\n [IsSelfSimGroup],\nfunction(G)\n local g, i, res;\n res := true;\n for g in GeneratorsOfGroup(G) do\n for i in [1..UnderlyingSelfSimFamily(G)!.deg] do\n res := Section(g, i) in G;\n if res = fail then\n TryNextMethod();\n elif not res then\n return false;\n fi;\n od;\n od;\n return true;\nend);\n\n\n###############################################################################\n##\n#M UnderlyingSelfSimFamily(<G>)\n##\nInstallMethod(UnderlyingSelfSimFamily, \"for [IsSelfSimGroup]\",\n [IsSelfSimGroup],\nfunction(G)\n return FamilyObj(GeneratorsOfGroup(G)[1]);\nend);\n\n\n###############################################################################\n##\n#M IsFiniteState(<G>)\n##\nInstallMethod(IsFiniteState, \"for [IsSelfSimGroup]\",\n [IsSelfSimGroup],\nfunction(G)\n local states, MealyAutomatonLocal, aut_list, gens, images, H, g, hom_function, \\\n inv_hom_function, hom, free_groups_hom, inv_free_groups_hom, inv_hom, \\\n gens_in_freegrp, images_in_freegrp, preimages_in_freegrp, F, pi, pi_bar, \\\n preimage_in_freegrp, MealyAutomatonLocalFinite;\n\n# if we do not know much, we compare just words in free group\n MealyAutomatonLocal := function(g)\n local cur_state;\n if g!.word in states then return Position(states, g!.word); fi;\n Add(states, g!.word);\n cur_state := Length(states);\n aut_list[cur_state] := List([1..g!.deg], x -> MealyAutomatonLocal(Section(g, x)));\n Add(aut_list[cur_state], g!.perm);\n return cur_state;\n end;\n\n# if we do know that the groups is finite, we compare actual elements of the group\n MealyAutomatonLocalFinite := function(g)\n local cur_state;\n if g in states then return Position(states, g); fi;\n Add(states, g);\n cur_state := Length(states);\n aut_list[cur_state] := List([1..g!.deg], x -> MealyAutomatonLocalFinite(Section(g, x)));\n Add(aut_list[cur_state], g!.perm);\n return cur_state;\n end;\n\n\n if IsTrivial(G) then return true; fi;\n\n states := [];\n aut_list := [];\n gens := GeneratorsOfGroup(G);\n images := [];\n\n\n if HasIsFinite(G) and IsFinite(G) then\n for g in gens do\n Add(images, MealyAutomatonLocalFinite(g));\n od;\n states := List(states, Word);\n else\n for g in gens do\n Add(images, MealyAutomatonLocal(g));\n od;\n fi;\n\n H := AutomatonGroup(aut_list);\n\n if IsTrivial(H) then\n SetIsTrivial( G, true);\n return true;\n fi;\n\n images := UnderlyingAutomFamily(H)!.oldstates{images};\n\n SetIsomorphicAutomGroup(G, GroupWithGenerators(UnderlyingAutomFamily(H)!.automgens{images}));\n SetUnderlyingAutomatonGroup(G, H);\n\n# preimages of generators of G in UnderlyingFreeGroup(G)\n gens_in_freegrp := List(GeneratorsOfGroup(G), Word);\n\n# preimages of generators of a subgroup of H isomorphic to G in UnderlyingFreeGroup(H)\n images_in_freegrp := List(UnderlyingAutomFamily(H)!.automgens{images}, Word);\n\n\n preimage_in_freegrp := function(x)\n local w;\n w := LetterRepAssocWord(x!.word)[1];\n if w > 0 then\n return states[ Position( UnderlyingAutomFamily(H)!.oldstates, w)];\n else\n return states[ Position( UnderlyingAutomFamily(H)!.oldstates, -w+UnderlyingAutomFamily(H)!.numstates)];\n fi;\n end;\n\n# preimages of generators of H in UnderlyingFreeGroup(G)\n# preimages_in_freegrp := List([1..Length(GeneratorsOfGroup(H))], x->states[Position(UnderlyingAutomFamily(H)!.oldstates, x)]);\n preimages_in_freegrp := List(GeneratorsOfGroup(H), x -> preimage_in_freegrp(x));\n\n\n if IsSelfSimilarGroup(G) then\n free_groups_hom :=\n GroupHomomorphismByImagesNC( Group(gens_in_freegrp), UnderlyingFreeGroup(H),\n gens_in_freegrp, images_in_freegrp );\n\n inv_free_groups_hom :=\n GroupHomomorphismByImagesNC( UnderlyingFreeGroup(H), UnderlyingFreeGroup(G),\n UnderlyingFreeGenerators(H), preimages_in_freegrp );\n\n hom_function := function(a)\n return Autom(Image(free_groups_hom, a!.word), UnderlyingAutomFamily(H));\n end;\n\n inv_hom_function := function(b)\n return SelfSim(Image(inv_free_groups_hom, b!.word), UnderlyingSelfSimFamily(G));\n end;\n\n hom := GroupHomomorphismByFunction(G, GroupWithGenerators(UnderlyingAutomFamily(H)!.automgens{images}), hom_function, inv_hom_function);\n\n SetMonomorphismToAutomatonGroup(G, hom);\n else\n F := FreeGroup(Length(GeneratorsOfGroup(G)));\n\n# pi\n# F ------> G ----> UnderlyingFreeGroup(H)\n# -------------->\n# pi_bar\n\n pi := GroupHomomorphismByImages(F, Group(gens_in_freegrp),\n GeneratorsOfGroup(F), gens_in_freegrp);\n\n pi_bar := GroupHomomorphismByImages(F, UnderlyingFreeGroup(H),\n GeneratorsOfGroup(F), images_in_freegrp);\n\n hom_function := function(g)\n return Autom(Image(pi_bar, PreImagesRepresentative(pi, g!.word)), UnderlyingAutomFamily(H));\n end;\n\n\n inv_hom_function := function(b)\n return SelfSim(Image(pi, PreImagesRepresentative(pi_bar, b!.word)), UnderlyingSelfSimFamily(G));\n end;\n\n hom := GroupHomomorphismByFunction(G, GroupWithGenerators(UnderlyingAutomFamily(H)!.automgens{images}), hom_function, inv_hom_function);\n\n SetMonomorphismToAutomatonGroup(G, hom);\n fi;\n\n\n return true;\nend);\n\n\n###############################################################################\n##\n#M IsomorphicAutomGroup( <G> )\n##\nInstallMethod(IsomorphicAutomGroup, \"for [IsSelfSimGroup]\",\n [IsSelfSimGroup],\nfunction(G)\n if IsFiniteState(G) then return IsomorphicAutomGroup(G); fi;\nend);\n\n\n###############################################################################\n##\n#M UnderlyingAutomatonGroup( <G> )\n##\nInstallMethod(UnderlyingAutomatonGroup, \"for [IsSelfSimGroup]\",\n [IsSelfSimGroup],\nfunction(G)\n if IsFiniteState(G) then return UnderlyingAutomatonGroup(G); fi;\nend);\n\n###############################################################################\n##\n#M MonomorphismToAutomatonGroup( <G> )\n##\nInstallMethod(MonomorphismToAutomatonGroup, \"for [IsSelfSimGroup]\",\n [IsSelfSimGroup],\nfunction(G)\n if IsFiniteState(G) then return MonomorphismToAutomatonGroup(G); fi;\nend);\n\n\n\n###############################################################################\n##\n#M IsContracting( <G> )\n##\nInstallMethod(IsContracting, \"for [IsSelfSimilarGroup]\",\n [IsSelfSimilarGroup],\nfunction(G)\n local res;\n if not IsFiniteState(G) then\n# every contracting self-similar group is finite-state\n return false;\n fi;\n\n res := IsContracting(GroupOfAutomFamily(UnderlyingAutomFamily(UnderlyingAutomatonGroup(G))));\n\n UnderlyingSelfSimFamily(G)!.use_contraction := true;\n UnderlyingAutomFamily(UnderlyingAutomatonGroup(G))!.use_contraction := true;\n\n return res;\nend);\n\n\n\n###############################################################################\n##\n#M GroupNucleus( <G> )\n##\nInstallMethod(GroupNucleus, \"for [IsSelfSimilarGroup]\",\n [IsSelfSimilarGroup],\nfunction(G)\n local H;\n if not IsFiniteState(G) then\n# every contracting self-similar group is finite-state\n Error(\"Group <G> is not finite-state\");\n fi;\n\n if not IsContracting(G) then\n Error(\"Group <G> is not contracting\");\n fi;\n\n H := GroupOfAutomFamily( UnderlyingAutomFamily( UnderlyingAutomatonGroup(G)));\n\n return List( GroupNucleus(H), x -> PreImagesRepresentative( MonomorphismToAutomatonGroup(G), x));\nend);\n\n\n\n###############################################################################\n##\n#M UseContraction( <G> )\n##\nInstallMethod(UseContraction, \"for [IsSelfSimGroup]\", true,\n [IsSelfSimGroup],\nfunction(G)\n if not IsSelfSimilarGroup(G) then\n Print(\"Error in UseContraction(<G>): The method is implemented only for IsSelfSimilarGroup\\n\");\n return fail;\n fi;\n\n if not HasIsContracting(G) then\n Print(\"Error in UseContraction(<G>): It is not known whether the group <G> is contracting\\n\");\n return fail;\n elif not IsContracting(G) then\n Print(\"Error in UseContraction(<G>): The group <G> is not contracting\");\n return fail;\n fi;\n # IsContracting returns either true or false or an error (it can not return fail)\n\n UnderlyingSelfSimFamily(G)!.use_contraction := true;\n UnderlyingAutomFamily( UnderlyingAutomatonGroup(G))!.use_contraction := true;\n\n return true;\nend);\n\n\n\n###############################################################################\n##\n#M DoNotUseContraction( <G> )\n##\nInstallMethod(DoNotUseContraction, \"for [IsSelfSimGroup]\", true,\n [IsSelfSimGroup],\nfunction(G)\n UnderlyingAutomFamily(G)!.use_contraction := false;\n\n if HasUnderlyingAutomatonGroup(G) then\n UnderlyingAutomFamily( UnderlyingAutomatonGroup(G))!.use_contraction := false;\n fi;\n return true;\nend);\n\n\n\n\n###############################################################################\n##\n#M FindNucleus( <G> )\n##\nInstallMethod(FindNucleus, \"for [IsSelfSimilarGroup, IsCyclotomic]\",\n [IsSelfSimilarGroup, IsCyclotomic],\nfunction(G, max_nucl)\n local H, nuclH, nuclG;\n if not IsFiniteState(G) then\n# every contracting self-similar group is finite-state\n Error(\"Group <G> is not finite-state\");\n fi;\n\n if HasIsContracting(G) and not IsContracting(G) then\n Error(\"Group <G> is not contracting\");\n fi;\n\n H := GroupOfAutomFamily( UnderlyingAutomFamily( UnderlyingAutomatonGroup( G )));\n\n if HasIsContracting(H) and not IsContracting(H) then\n Error(\"Group <G> is not contracting\");\n fi;\n\n nuclH := FindNucleus(H, max_nucl);\n\n if nuclH=fail then return fail; fi;\n\n nuclG := [];\n Add(nuclG, List( GeneratingSetWithNucleus(H), x -> PreImagesRepresentative( MonomorphismToAutomatonGroup( G ), x )));\n Add(nuclG, List( GroupNucleus(H), x -> PreImagesRepresentative( MonomorphismToAutomatonGroup( G ), x )));\n Add(nuclG, GeneratingSetWithNucleusAutom(H));\n\n SetGroupNucleus(G, nuclG[1]);\n SetGeneratingSetWithNucleus(G, nuclG[2]);\n SetGeneratingSetWithNucleusAutom(G, nuclG[3]);\n SetContractingLevel(G, ContractingLevel(H));\n\n return nuclG;\nend);\n\n\nInstallMethod(FindNucleus, \"for [IsSelfSimilarGroup]\", true,\n [IsSelfSimilarGroup],\nfunction(G)\n return FindNucleus(G, infinity);\nend);\n\n\nInstallMethod(GeneratingSetWithNucleus, \"for [IsSelfSimilarGroup]\", true,\n [IsSelfSimilarGroup],\nfunction(G)\n if IsContracting(G) then return GeneratingSetWithNucleus(G); fi;\nend);\n\n\nInstallMethod(GeneratingSetWithNucleusAutom, \"for [IsSelfSimilarGroup]\", true,\n [IsSelfSimilarGroup],\nfunction(G)\n if IsContracting(G) then return GeneratingSetWithNucleusAutom(G); fi;\nend);\n\n#E\n", "meta": {"hexsha": "3527d6cdc3929ed45fffe0041b1b44190fc6c0b4", "size": 32198, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "gap/selfsimgroup.gi", "max_stars_repo_name": "gap-packages/automgrp", "max_stars_repo_head_hexsha": "1beb0cbc96c9748cf912433c27c661e1f87ef5dc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-10-02T15:00:11.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-02T15:00:11.000Z", "max_issues_repo_path": "gap/selfsimgroup.gi", "max_issues_repo_name": "gap-packages/automgrp", "max_issues_repo_head_hexsha": "1beb0cbc96c9748cf912433c27c661e1f87ef5dc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 9, "max_issues_repo_issues_event_min_datetime": "2019-09-21T22:10:40.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-26T23:51:41.000Z", "max_forks_repo_path": "gap/selfsimgroup.gi", "max_forks_repo_name": "gap-packages/automgrp", "max_forks_repo_head_hexsha": "1beb0cbc96c9748cf912433c27c661e1f87ef5dc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.2709090909, "max_line_length": 140, "alphanum_fraction": 0.599571402, "num_tokens": 8618, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4882833952958347, "lm_q2_score": 0.03567855215943872, "lm_q1q2_score": 0.017421244587650275}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\nClass(Codegen, HierarchicalVisitor, rec(\n initXY := function(x, y, opts)\n if IsBound(opts.XType) and not IsList(x) then\n if not IsArrayT(opts.XType) and not IsPtrT(opts.XType) \n then Error(\"opts.XType must be a pointer or array type. This has recently changed.\",\n \"If you used TReal before, use TPtr(TReal) now\"); fi;\n x.t := opts.XType;\n x.t := When(IsBound(opts.useRestrict) and opts.useRestrict, x.t.restrict(), x.t);\n fi;\n if IsBound(opts.YType) and not IsList(y) then\n if not IsArrayT(opts.YType) and not IsPtrT(opts.YType) \n then Error(\"opts.YType must be a pointer or array type. This has recently changed.\",\n \"If you used TReal before, use TPtr(TReal) now\"); fi;\n y.t := opts.YType;\n y.t := When(IsBound(opts.useRestrict) and opts.useRestrict, y.t.restrict(), y.t);\n fi;\n return [x, y];\n end,\n\n # NOTE: get rid of _acc_\n\n # This function substitutes assign by assign_acc (eliminated in a subsequent pass)\n # This is done to achieve accumulation, and assign_acc is used to\n # prevent double accumulation.. Used in Codegen.ISumAcc and Codegen.SUMAcc.\n # Must be handled better somehow.\n #\n _acc := (icode, y) ->\n SubstTopDownNR(icode, [assign, [@(0,nth), @(1), @(2)], @(3)],\n e -> assign_acc(@(0).val, @(3).val)),\n\n \n _interleave := function(codes)\n local decls, c, i, j, cmds;\n decls := Set([]);\n for i in [1..Length(codes)] do\n c := codes[i];\n while ObjId(c)=decl do UniteSet(decls, c.vars); c := c.cmd; od;\n if ObjId(c)<>chain then\n codes[i] := [c];\n else\n codes[i] := c.cmds;\n fi;\n od;\n\n cmds := [];\n for i in [1..Maximum(List(codes, Length))] do\n for j in [1..Length(codes)] do\n if IsBound(codes[j][i]) then Add(cmds, codes[j][i]); fi;\n od;\n od;\n return decl(decls, chain(cmds));\n end\n));\n\n#fAdd.rlambda := self >> let(i:=Ind(), Lambda(i,i+1));\n#H.rlambda := self >> let(i:=Ind(), Lambda(i,i+self.params[4]));\n\n\n# a version of the Dat1d call that also sets the 'no scalarize' flag on the variable 't'.\n_dat1d_donotscalarize := function(a,b)\n local t;\n\n t := Dat1d(a,b);\n t.doNotScalarize := true;\n\n return t;\nend;\n\n\nClass(DefaultCodegen, Codegen, rec(\n Formula := meth(self, o, y, x, opts)\n local icode, datas, prog, params, sub, initsub, destroysub, io, t, initcode, initparams;\n \n o := SumsUnification(o.child(1), opts);\n\n [x, y] := self.initXY(x, y, opts);\n\n #o := Process_fPrecompute(o, opts);\n \n params := Set(Concatenation(Collect(o, param), Filtered(Collect(o, var), IsParallelLoopIndex)));\n\n datas := Collect(o, FDataOfs);\n [o,t] := UTimedAction(BlockSumsOpts(o, opts)); #PrintLine(\"BlockSums \", t);\n [icode,t] := UTimedAction(self(o, y, x, opts)); #PrintLine(\"codegen \", t);\n #[icode,t] := UTimedAction(ESReduce(icode, opts)); #PrintLine(\"ESReduce \", t);\n icode := RemoveAssignAcc(icode);\n Unbind(Compile.times);\n [icode,t] := UTimedAction(BlockUnroll(icode, opts)); #PrintLine(\"BlockUnroll \", t);\n #PrintLine(\"---compile--\");\n #DoForAll([1..Length(Compile.times)], i -> PrintLine(i, \" \", Compile.times[i], \" \",\n # let(f:=opts.compileStrategy[i], When(IsFunc(f) or IsMeth(f), \"---\", f))));\n\n # icode := PowerOpt(icode);\n icode := DeclareHidden(icode);\n if IsBound(opts.isFixedPoint) and opts.isFixedPoint then\n icode := FixedPointCode(icode, opts.bits, opts.fracbits);\n fi;\n\n initparams := Copy(params);\n if IsBound(opts.symbol) then\n params := Concatenation(params, opts.symbol);\n fi;\n\n if IsBound(opts.accStrategy) then\n icode.iy := y;\n icode.iy.n := o.dims()[1];\n icode.ix := x;\n icode.ix.n := o.dims()[2];\n icode.ivars := Concatenation(params, List(datas, x->x.var));\n icode := opts.accStrategy(icode);\n fi;\n\n io := When(x=y, [x], [y, x]);\n sub := Cond(IsBound(opts.subName), opts.subName, \"transform\");\n initsub := Cond(IsBound(opts.subName), Concat(\"init_\", opts.subName), \"init\");\n destroysub := Cond(IsBound(opts.subName), Concat(\"destroy_\", opts.subName), \"destroy\");\n icode := func(TVoid, sub, Concatenation(io, params), icode);\n\n if IsBound(opts.generateInitFunc) and opts.generateInitFunc then\n\t initcode := chain(List(Filtered(datas, e -> IsBound(e.var.init)), x -> SReduce(x.var.init, opts)));\n prog := program(\n decl(List(datas, x->x.var),\n chain(\n func(TVoid, initsub, initparams :: Set(Collect(initcode, param)), initcode), \n icode,\n func(TVoid, destroysub, [], skip()) \n )));\n else\n prog := program( func(TVoid, initsub, params, chain()), icode);\n fi;\n prog.dimensions := o.dims();\n return prog;\n end,\n\n Cross := meth(self, o, y, x, opts)\n local i, mychain, xdims, ydims, myYdims, myXdims;\n mychain:=[];xdims:=1;ydims:=1;\n for i in [1..Length(o._children)] do\n myYdims:=DimLength(o._children[i].dims()[1]);\n myXdims:=DimLength(o._children[i].dims()[2]);\n Add(mychain,self(o._children[i],\n StripList(y{[ydims..ydims+myYdims-1]}),\n StripList(x{[xdims..xdims+myXdims-1]}),opts));\n ydims:=ydims+myYdims;\n xdims:=xdims+myXdims;\n od;\n return chain(mychain);\n end,\n\n Glue:= meth(self,o,y,x,opts)\n local size, als,iterator,n;\n size := o.element[2];\n n := EvalScalar(o.element[1]);\n iterator :=Ind(size);\n als := List([0..n-1],t -> assign(nth(StripList(y),add(iterator,t*size)),nth(x[t+1],iterator)));\n return loop(iterator, size, chain(als));\n end,\n\n Split:= meth(self,o,y,x,opts)\n local size, als,iterator,n;\n n := EvalScalar(o.element[2]);\n size := o.element[1];\n iterator :=Ind(idiv(size, n));\n als := List([0..(n-1)],t -> assign(nth(y[t+1],iterator),nth(StripList(x),add(iterator,t*size/n))));\n return loop(iterator, idiv(size, n), chain(als));\n end,\n\n\n BB := (self,o,y,x,opts) >> MarkForUnrolling(\n When(IsBound(o.bbnum),\n o.bbnum,\n 0\n ), \n self(o.child(1), y, x, opts),\n opts\n ),\n IDirSum := (self,o,y,x,opts) >> self(o.sums(), y, x, opts),\n TTag := (self,o,y,x,opts) >> self(o.params[1], y, x, opts),\n DPWrapper := (self,o,y,x,opts) >> self(o.child(1), y, x, opts),\n\n Buf := (self,o,y,x,opts) >> self(o.child(1), y, x, opts),\n NoPull := (self,o,y,x,opts) >> self(o.child(1), y, x, opts),\n PushL := (self,o,y,x,opts) >> self(o.child(1), y, x, opts),\n PushR := (self,o,y,x,opts) >> self(o.child(1), y, x, opts),\n PushLR := (self,o,y,x,opts) >> self(o.child(1), y, x, opts),\n Grp := (self,o,y,x,opts) >> self(o.child(1), y, x, opts),\n NoDiagPullin := (self,o,y,x,opts) >> self(o.child(1), y, x, opts),\n NoDiagPullinLeft := (self,o,y,x,opts) >> self(o.child(1), y, x, opts),\n NoDiagPullinRight := (self,o,y,x,opts) >> self(o.child(1), y, x, opts),\n\n COND := (self,o,y,x,opts) >> IF(\n When(IsFunction(o.cond), o.cond.at(0), o.cond),\n self(o.child(1), y, x, opts), self(o.child(2), y, x, opts)),\n\n Diag := (self, o, y, x, opts) >> let(i := Ind(), elt := o.element.lambda(),\n loop(i, elt.domain(), assign(nth(y,i), elt.at(i) * nth(x,i)))),\n \n DiagCpxSplit := (self, o, y, x, opts) >> let(i := Ind(), elt := o.element.lambda(),\n re := elt.at(2*i), im := elt.at(2*i+1),\n loop(i, elt.domain()/2, \n assign(nth(y,i), re * nth(x,i) + E(4) * im * nth(x,i)))),\n\n TCast := (self, o, y, x, opts) >> let(i := Ind(), \n loop(i, o.params[1], assign(nth(y,i), tcast(o.params[2], nth(x,i))))),\n\n RCDiag := (self, o, y, x, opts) >> let(i := Ind(), elt := o.element.lambda(),\n re := elt.at(2*i), im := elt.at(2*i+1),\n loop(i, elt.domain()/2, chain(\n assign(nth(y,2*i), re * nth(x,2*i) - im * nth(x,2*i+1)),\n assign(nth(y,2*i+1), im * nth(x,2*i) + re * nth(x,2*i+1))))),\n\n ColVec := (self, o, y, x, opts) >> let(i := Ind(), func := o.element.lambda(),\n loop(i, func.domain(), assign(nth(y,i), mul(func.at(i), nth(x,0))))),\n\n RowVec := (self, o, y, x, opts) >> let(i := Ind(), func := o.element.lambda(),\n t := TempVar(x.t.t),\n chain(assign(t,0),\n loop(i, func.domain(), assign(t, add(t, mul(func.at(i), nth(x,i))))),\n assign(nth(y,0), t))),\n\n Scale := (self, o, y, x, opts) >> let(i := Ind(),\n chain(self(o.child(1), y, x, opts),\n loop(i, Rows(o), assign(nth(y,i), mul(o.scalar, nth(y,i)))))),\n\n I := (self, o, y, x, opts) >> Cond(x<>y,let(i := Ind(Rows(o)),\n loop(i, i.range, assign(nth(y,i), nth(x,i)))),skip()),\n\n 2DI := (self, o, y, x, opts) >> Cond(x<>y, Error(\"Should not happen\"), skip()),\n\n # this one will always unroll Blk's\n Blk := (self, o, y, x, opts) >> let(\n\t# this is a hack, and it is needed, because without it we will be assigning to a \n\t# variable of type TArray (after binsplit), and some compilers (=icc) don't like that \n\t# (not an l-value)\n\t# NOTE: suggestion -- move this somewhere, as a compatibility patch (maybe postprocess?)\n\ttcst := Cond(IsSymbolic(o.element), x->tcast(TPtr(o.element.t.t.t), x), x->x),\n\tCond(\n not IsSymbolic(o.element) and Rows(o)=2 and Cols(o)=2, Blk2code(o, y, x),\n not IsSymbolic(o.element) and Rows(o)=4 and Cols(o)=4, Blk4code(o, y, x),\n chain(\n\t\tList([0..Rows(o)-1], j -> let(\n\t\t row := tcst(nth(o.element, j)),\n assign(nth(y,j), ApplyFunc(add, List([0..Cols(o)-1], i -> nth(row, i) * nth(x,i))))\n\t\t))\n\t )\n\t)\n ),\n\n# This one can loop Blk's if needed, but is much slower for large matrices, and eventually blows up in storage requirements\n# Blk := (self, o, y, x, opts) >> Cond(\n# Rows(o)=2 and Cols(o)=2, Blk2code(o, y, x),\n# Rows(o)=4 and Cols(o)=4, Blk4code(o, y, x),\n# let(j:=Ind(), i:=Ind(), t:=TempVar(x.t.t), mat:=V(o.element), d:=Dat(mat.t),\n# data(d, mat,\n# loop(j, Rows(o), decl(t, chain(\n# assign(t, 0),\n# loop(i, Cols(o), assign(t, t + nth(nth(d,j),i) * nth(x,i))),\n# assign(nth(y,j), t))))))),\n\n toeplitz := (self, o, y, x, opts) >> self.Blk(o.obj, y, x, opts),\n\n Blk1 := (self, o, y, x, opts) >> assign(nth(y,0), mul(toExpArg(o.element), nth(x,0))),\n\n BlkConj := (self, o, y, x, opts) >> assign(nth(y,0), conj(nth(x,0))),\n\n Prm := (self, o, y, x, opts) >> Cond(\n x = y,\n When(ObjId(o.func) = fId, skip(), Error(\"Inplace Permutation is not dealt with...\")),\n\n let(i:=Ind(), func:=o.func.lambda(),\n loop(i, Rows(o), assign(nth(y, i), nth(x, func.at(i)))))\n ),\n\n O := (self, o, y, x, opts) >> let(i:=Ind(),\n loop(i, o.params[1], assign(nth(y, i), V(0)))),\n\n\n Gath := meth(self, o, y, x, opts)\n local i, func, rfunc, ix;\n i := Ind(); func := o.func.lambda();\n\n if IsBound(o.func.rlambda) then\n rfunc := o.func.rlambda();\n ix := var.fresh_t(\"ix\", TInt);\n return decl(ix, chain(\n assign(ix, func.at(0)),\n assign(nth(y, 0), nth(x, ix)),\n loop(i, o.func.domain()-1,\n chain(assign(ix, rfunc.at(ix)),\n assign(nth(y, i+1), nth(x, ix))))));\n else\n return loop(i, o.func.domain(), assign(nth(y,i), nth(x, func.at(i))));\n fi;\n end,\n\n Scat := meth(self, o, y, x, opts)\n local i, func, rfunc, ix;\n i := Ind(); func := o.func.lambda();\n if IsBound(o.func.rlambda) then\n rfunc := o.func.rlambda();\n ix := var.fresh_t(\"ix\", TInt);\n return decl(ix, chain(\n assign(ix, func.at(0)),\n assign(nth(y, ix), nth(x, 0)),\n loop(i, o.func.domain()-1,\n chain(assign(ix, rfunc.at(ix)),\n assign(nth(y, ix), nth(x, i+1))))));\n else\n return loop(i, o.func.domain(), assign(nth(y,func.at(i)), nth(x, i)));\n fi;\n end,\n\n ScatGath := meth(self, o, y, x, opts)\n local i, sfunc, gfunc, decls;\n\n i := Ind();\n sfunc := o.sfunc.lambda();\n gfunc := o.gfunc.lambda();\n decls := Set(Concat(sfunc.free(),gfunc.free()));\n return loopn(i, o.sfunc.domain(), assign(nth(y,sfunc.at(i)), nth(x, gfunc.at(i))));\n end,\n\n SUM := (self, o, y, x, opts) >> chain(List(o.children(), c -> self(c, y, x, opts))),\n\n ISum := (self, o, y, x, opts) >> let(\n myloop := When(IsSymbolic(o.domain), loopn, loop),\n myloop(o.var, o.domain,\n self(o.child(1), y, x, opts))),\n\n JamISum := (self, o, y, x, opts) >> let(its := EvalScalar(o.domain),\n Cond(IsSymbolic(its), \n self.ISum(o, y, x, opts), \n its > 32, Error(\"<o.domain> is too big (> 32), probably something went wrong. \",\n \"If you know what you are doing, then change DefaultCodegen.JamISum\"),\n let(s := o.child(1),\n bodies := List([0..its-1], j ->\n Compile(self(SubstVars(Copy(s), rec((o.var.id):= V(j))), y, x, opts), opts)),\n self._interleave(bodies)))),\n\n # NOTE: get rid of _acc\n SUMAcc := (self, o, y, x, opts) >> let(ii := Ind(),\n When(not Same(ObjId(o.child(1)), Gath), # NOTE: come up with a general condition\n chain(\n loop(ii, Rows(o), assign(nth(y, ii), V(0))),\n List(o.children(), c -> self._acc(self(c, y, x, opts), y))),\n chain(\n self(o.child(1), y, x, opts),\n List(Drop(o.children(), 1), c -> self._acc(self(c, y, x, opts), y))))),\n\n ISumAcc := (self, o, y, x, opts) >> let(ii := Ind(), chain(\n loop(ii, Rows(o), assign(nth(y, ii), V(0))),\n loop(o.var, o.domain, self._acc(self(o.child(1), y, x, opts), y)))),\n\n ScatAcc := (self, o, y, x, opts) >> self._acc(self(Scat(o.func),y,x,opts),y),\n\n # _composePropagate(<ch>, <y>, <x>, <mfunc>) - <x> and <y> and temp arrays propagation through \n # identity/inplace operators and creating intermediate arrays using <mfunc> which\n # has (c) -> ... signature (<c> is child operator). There is no assumption made on what is <x>, \n # <y> and <mfunc> return so this function can be used to propagate other information same way \n # as arrays in composition.\n\n _composePropagate := function(ch, y, x, mfunc)\n local numch, vecs, i, j, cmd, code, isI, crossCh, apos;\n numch := Length(ch);\n vecs := [y];\n\n isI := (x) -> IsIdentitySPL(x) or x.isInplace();\n\n # we like to evaluate right (last) to left (first), where the values\n # in parens refer to the position of the elements in the array.\n #\n # So here, we start at the output (first entry in array) and\n # walk towards the input, creating temporary arrays as necessary\n \n for i in [1..numch-1] do\n vecs[i+1] := When(isI(ch[i]),\n vecs[i],\n mfunc(ch[i])\n );\n if ObjId(ch[i]) = Cross then\n apos := [ 1, 1 ]; # apos holds starting input/output indexes \n # as children's arity on input may be different from output arity.\n crossCh := ch[i].rChildren();\n for j in [1 .. Length(crossCh)] do\n if isI(crossCh[j]) then\n vecs[i+1][apos[2]] := vecs[i][apos[1]];\n fi;\n apos := apos + crossCh[j].arity();\n od;\n fi;\n od;\n\n # the last entry must be the input.\n vecs[numch+1] := x;\n\n # now we walk in the opposite direction, copying through\n # input as far as we can.\n # if there is a cross and one of the inputs is an identity,\n # there's no point actually doing it\n for i in Reversed([1..numch]) do\n if isI(ch[i]) then\n vecs[i] := vecs[i+1];\n elif ObjId(ch[i]) = Cross then\n apos := [ 1, 1 ]; # apos holds starting input/output indexes \n # as children's arity on input may be different from output arity.\n crossCh := ch[i].rChildren();\n for j in [1 .. Length(crossCh)] do\n if isI(crossCh[j]) then\n vecs[i][apos[1]] := vecs[i+1][apos[2]];\n fi;\n apos := apos + crossCh[j].arity();\n od;\n fi;\n od;\n\n # If all children were evaluated inplace, the output will be in x\n # Make it go from x -> y as expected\n if vecs[1] = vecs[numch+1] then vecs[1] := y; fi;\n if vecs[1] = vecs[numch+1] then vecs[numch+1] := x; fi;\n\n return vecs;\n end,\n\n Compose := meth(self, o,y,x,opts)\n local ch, numch, vecs;\n ch := o.children();\n numch := Length(ch);\n\n # propagate x and y arrays and create temporary arrays\n vecs := self._composePropagate(ch, y, x, c -> TempArray(y,x,c));\n\n # order them so that first to be evaluated is first in array.\n vecs := Reversed(vecs);\n ch := Reversed(ch);\n\n # Wrap code in variable declaration. Each entry in vecs will contain multiple\n # arrays in the case of multi-input/output (i.e. OL)\n return decl(\n Difference(Flat(vecs{[2..Length(vecs)-1]}), Flat([x,y])),\n chain(\n List([1..numch], i ->\n self(ch[i], vecs[i+1], vecs[i], opts)))\n );\n end,\n\n # ComposeDists is meant to be like a Compose, but for parallel ISums. We\n # need it for 2 reasons: a) The arrays declared are distributed among the\n # nodes, so we need them to be of size N/p, and not N. b) We can ping-pong\n # between 2 parallel buffers instead of declaring a ton of temp arrays, as\n # long as a barrier-sync exists between the stages. NOTE: This won't work\n # if we do full overlapping with micro-barriers. NOTE: This also might not\n # work too well for partial/dirty-overlap.\n\n ComposeDists := meth(self, o,y,x,opts)\n local ch, numch, vecs, i, cmd, code, pt1, pt2;\n ch := o.children();\n numch := Length(ch);\n\n # order them so that first to be evaluated is first in array.\n ch := Reversed(ch);\n\n # NOTE: We assume that the # of procs doesn't change across the ComposeDists!\n pt1 := TempArraySeq(y,x,ch[1]);\n pt2 := TempArraySeq(y,x,ch[1]);\n\n return(\n decl([pt1, pt2], chain( \n List([1..numch], i -> \n let(ppx := When(i mod 2 = 0, pt1, pt2),\n ppy := When(i mod 2 = 0, pt2, pt1),\n px := When(i=1, x, ppx),\n py := When(i=numch, y, ppy),\n self(ch[i], py, px, opts))\n )\n ))\n );\n end,\n\n ComposeStreams:= meth(self, o,y,x,opts)\n\n # This is a compose of 2 or more multibuffered streams. The streams can\n # ping-pong data between X and Y. This is okay only if we're allowed to\n # clobber the input (reasonable to assume only when Inplace is\n # requested). Also, whether the last stage is a ping or a pong will\n # determine where the output is written to (which is not great).\n # Currently, just a hack.\n\n local ch, numch;\n ch := o.children();\n numch := Length(ch);\n\n # order them so that first to be evaluated is first in array.\n ch := Reversed(ch);\n\n return chain( List([1..numch], i -> \n let(ppy := When(i mod 2 = 0, x, y),\n ppx := When(i mod 2 = 0, y, x),\n self(ch[i], ppy, ppx, opts))\n )\n );\n end,\n\n\n Inplace := (self, o, y, x, opts) >>\n self(o.child(1), y, x, opts), # Compose will handle these somehow\n#MRT: it really should do this... but it doesn't\n# self(o.child(1), x, x, opts),\n\n Data := meth(self, o, y, x, opts)\n local val;\n o.var.isData := true;\n val := When(IsFunction(o.value), o.value.tolist(), o.value);\n val := When(IsValue(val), val, o.var.t.value(val));\n return data(o.var, val, self(o.child(1), y, x, opts));\n end,\n\n # NOTE: use pointers to do pingpong?\n ICompose := (self, o, y, x, opts) >> let(\n t := Dat1d(x.t.t, Rows(o)),\n its := o.domain,\n newind := Ind( Int((its-1)/2) ),\n # if orig loops has even # iterations, we peel 2 iterations, otherwise peel 1\n peel_its := Cond(IsEvenInt(o.domain), 2, 1),\n\n decl([t], chain(\n Cond(IsOddInt(o.domain),\n SubstVars(Copy(self(o.child(1), y, x, opts)), tab((o.var.id) := (V(its-1)))),\n\n chain(\n SubstVars(Copy(self(o.child(1), t, x, opts)), tab((o.var.id) := (V(its-1)))),\n SubstVars(Copy(self(o.child(1), y, t, opts)), tab((o.var.id) := (V(its-2)))))),\n\n When(o.domain <= 2, [],\n loop(newind, newind.range,\n chain(\n SubstVars(Copy(self(o.child(1), t, y, opts)), tab((o.var.id) := (its-1-peel_its)-2*newind)),\n SubstVars(Copy(self(o.child(1), y, t, opts)), tab((o.var.id) := (its-2-peel_its)-2*newind)))))\n ))),\n\n Multiplication:= meth(self, o, y, x, opts)\n local iterator;\n\n iterator:=Ind();\n return loop(iterator, [ 0 .. o.element[2]-1 ],\n assign(nth(StripList(y), iterator), mul(nth(x[1], iterator),nth(x[2], iterator))));\n end,\n\n OLMultiplication := meth(self, o, y, x, opts)\n local iterator;\n iterator:=Ind();\n return loop(iterator, [ 0 .. o.rChildren()[2]-1 ],\n assign(nth(StripList(y), iterator),\n ApplyFunc(mul, List([1..o.rChildren()[1]], i -> nth(x[i], iterator)))));\n end,\n\n OLConjMultiplication := meth(self, o, y, x, opts)\n local iterator;\n iterator:=Ind();\n return loop(iterator, [ 0 .. o.rChildren()[2]-1 ],\n assign(nth(StripList(y), iterator),\n ApplyFunc(mul, [nth(x[1], iterator)] :: List([2..o.rChildren()[1]], i -> conj(nth(x[i], iterator))))));\n end,\n\n __RCOLMultiplication := (self, o, y, x, conj) >> let(\n i := Ind(),\n n := o.rChildren()[2], \n m := o.rChildren()[1],\n yy := StripList(y),\n re := List([1..m], e -> var.fresh_t(\"re\", yy.t.t)),\n im := List([1..m], e -> var.fresh_t(\"re\", yy.t.t)),\n loop(i, n, decl( re :: im, chain(\n assign( re[1], nth(x[1], 2*i) ),\n assign( im[1], nth(x[1], 2*i+1) ),\n chain( List( [2..m], j -> \n chain(\n assign(re[j], re[j-1] * nth(x[j],2*i) - conj * im[j-1] * nth(x[j],2*i+1)),\n assign(im[j], im[j-1] * nth(x[j],2*i) + conj * re[j-1] * nth(x[j],2*i+1))\n ))),\n assign(nth(yy,2*i), re[m]),\n assign(nth(yy,2*i+1), im[m]))))),\n\n RCOLMultiplication := (self, o, y, x, conj) >> self.__RCOLMultiplication(o, y, x, 1),\n RCOLConjMultiplication := (self, o, y, x, conj) >> self.__RCOLMultiplication(o, y, x, -1),\n\n\n OLDup := (self, o, y, x, opts) >> let(\n i := Ind(o.params[2]),\n loop(i, i.range, chain( \n List( Flat([y]), yy -> assign(nth(yy, i), nth(x, i)))\n ))\n ),\n\n SMAP := (self, o, y, x, opts) >> assign(nth(y, 0), o.at(List([1..Cols(o)], i -> nth(x, i-1)))),\n\n ParSeqWrap := (self, o, y, x, opts) >> let( yy := Flat([y]), xx := Flat([x]),\n self( o.p.child(o.ci),\n StripList(yy :: o.p.filtSUMR(o.y)),\n StripList(xx :: o.p.filtSUMR(o.x)),\n opts)),\n\n ParSeq := (self, o, y, x, opts) >> let( ch := o.children(), yy := Flat([y]), xx := Flat([x]),\n self( Compose(List([1..Length(ch)], i -> ParSeqWrap(o, i, yy, xx))),\n StripList(o.filtCompR(yy)), StripList(o.filtCompL(xx)), opts)),\n\n IParSeq := (self, o, y, x, opts) >> let(\n its := Ind(o.domain),\n xs := o.filtSUML(Flat([x])),\n ys := o.filtSUMR(Flat([y])),\n xc := o.filtCompL(Flat([x])),\n yc := o.filtCompR(Flat([y])),\n\n rc := o.filtCompR(Flat([Rows(o)])),\n tc := List(Zip2(yc, rc), a -> Dat1d(a[1].t.t, a[2])),\n\n src := List( xc, e -> var.fresh_t(\"pX\", TPtr(e.t.t))),\n dst := List( yc, e -> var.fresh_t(\"pY\", TPtr(e.t.t))),\n\n ptr := (p) -> When(IsPtrT(p.t), p, nth(p, 0).toPtr(p.t.t)),\n\n decl(src :: dst :: tc, chain(chain(\n List( TransposedMat([src, xc]),\n e -> assign(e[1], ptr(e[2])) ) ::\n List( TransposedMat([dst, tc, yc]),\n e -> assign(e[1], cond( eq(imod(o.domain, 2), 0), ptr(e[2]), ptr(e[3]))) )),\n loopn( its, its.range, chain(\n self( SubstVars(Copy(o.child(1)), tab((o.var.id) := its)), StripList(dst :: ys), StripList(src :: xs), opts ),\n chain(\n List( TransposedMat([src, dst]),\n e -> assign(e[1], e[2])) :: \n List( TransposedMat([dst, yc, tc]),\n e -> assign(e[1], cond( eq(imod(add(o.domain, its), 2), 0), ptr(e[2]), ptr(e[3]) )))\n )))\n ))\n ),\n\n Cvt := (self, o, y, x, opts) >> o.params[1].code(y, x, opts),\n));\n\nStackAllocsToPtrs := function(icode, x, size, vars)\n local arrayvars, replvars, offset, i;\n\n # extract all temp array definitions\n arrayvars := Flat(List(\n Collect(icode, @(1, decl, e -> ForAny(e.vars, i -> ObjId(i.t) = TArray))),\n f -> Filtered(f.vars, g -> ObjId(g.t) = TArray)\n ));\n\n # build a set of replacement pointers for these variables\n replvars := List(arrayvars, e -> var.fresh_t(\"T\", TPtr(e.t.t)));\n\n offset := 2*size;\n\n for i in [1..Length(arrayvars)] do\n\n # remove declaration of array\n icode := SubstTopDown(icode, @(1, decl, e -> arrayvars[i] in e.vars), ee -> ee.cmd);\n\n # change variables from TArray -> TPtr\n icode := SubstTopDown(icode, arrayvars[i], e -> replvars[i]);\n\n # prepend declaration and setup of ptr\n icode := decl(replvars[i], chain(\n assign(replvars[i], add(x, offset)),\n icode\n ));\n\n offset := offset + size;\n od;\n\n Append(vars, arrayvars);\n\n return icode;\nend;\n\nClass(SingleAllocCodegen, DefaultCodegen, rec(\n Formula := meth(self, o, y, x, opts)\n local icode, datas, prog, params, sub, initsub, io, vars, size;\n \n o := SumsUnification(o.child(1), opts);\n\n [x, y] := self.initXY(x, y, opts);\n\n size := Maximum(o.dimensions);\n params := Set(Collect(o, param));\n\n datas := Collect(o, FDataOfs);\n o := BlockSums(opts.globalUnrolling, o);\n icode := self(o, y, x, opts);\n icode := RemoveAssignAcc(icode);\n icode := BlockUnroll(icode, opts);\n\n # replace all stack allocated arrays with offsets into input array\n vars := [];\n icode := StackAllocsToPtrs(icode, x, size, vars);\n\n # icode := PowerOpt(icode);\n icode := DeclareHidden(icode);\n if IsBound(opts.isFixedPoint) and opts.isFixedPoint then\n icode := FixedPointCode(icode, opts.bits, opts.fracbits);\n fi;\n\n io := When(x=y, [x], [y, x]);\n sub := Cond(IsBound(opts.subName), opts.subName, \"transform\");\n initsub := Cond(IsBound(opts.subName), Concat(\"init_\", opts.subName), \"init\");\n icode := func(TVoid, sub, Concatenation(io, params), icode);\n\n if IsBound(opts.generateInitFunc) and opts.generateInitFunc then\n prog := program(\n decl(List(datas, x->x.var),\n chain(\n func(TVoid, initsub, params, chain(List(datas, x -> SReduce(x.var.init)))),\n icode\n )));\n else\n prog := program( func(TVoid, initsub, params, chain()), icode);\n fi;\n prog.dimensions := o.dimensions;\n return prog;\n end,\n));\n\nClass(RecCodegenMixin, rec(\n RecursStep := (self, o, y, x, opts) >> let(\n name := spiral.libgen.CodeletName(spiral.libgen.CodeletShape(o.child(1))),\n ApplyFunc(call, Concatenation(\n [ var(name), y + o.yofs, x + o.xofs ],\n spiral.libgen.CodeletParams(o.child(1))))),\n\n RecursStepCall := (self, o, y, x, opts) >>\n ApplyFunc(call, Concatenation(Flat([var(o.func), y, x,]), List(o.bindings, x->x[2]))),\n\n Codelet := meth(self, o, y, x, opts)\n local code;\n [x, y] := self.initXY(x, y, opts);\n o := o.child(1);\n ## Generating code : main body\n o := BlockSums(opts.libgen.basesUnrolling, o);\n code := SReduce(self(o, y, x, opts), opts);\n code := BlockUnroll(RemoveAssignAcc(code), opts);\n code := DeclareHidden(code);\n return code;\n end,\n));\n\n\n", "meta": {"hexsha": "235f4ac49242fe370a279cc7006e1c19f85b18e7", "size": 29875, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/compiler/codegen.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/compiler/codegen.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/compiler/codegen.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 39.7802929427, "max_line_length": 130, "alphanum_fraction": 0.5093891213, "num_tokens": 8661, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.476579651063676, "lm_q2_score": 0.03622005508471649, "lm_q1q2_score": 0.01726174121378131}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\nDeclare(ICompose, ISum, fTensor, fBase, fId, fCompose);\nDeclare(RC);\n\n# ===========================================================================\n# SPL Sums Notation\n# ===========================================================================\n# Blk - block\n# Blk1 - 1x1 block\n# Data(var, value, expr) - data\n# ISum - iterative sum\n# SUM - sum\n#\n# Gath(N,n,func) - gather matrix\n# Scat(N,n,func) - scatter matrix\n# Prm(N, read_func, write_func) - read: output->input, write: input->output\n# Conj, ConjL, ConjR, ConjLR - generalized conjugation (arbitrary/no matrix to left and right)\n# ConjDiag to conjugate block diagonals\n# ===========================================================================\n\nClass(SumsBase, rec(\n isSums := true,\n area := self >> Sum(self.children(), x->x.area()),\n sums := meth(self)\n local children, i, res;\n res := Copy(self);\n children := Map(res.rChildren(), c -> Cond(IsSPL(c), c.sums(), c));\n for i in [1..Length(children)] do\n res.rSetChild(i, children[i]);\n od;\n return res;\n end\n));\n\nCompose.area := self >> Sum(self.children(), x->x.area());\nDiag.area := self >> Rows(self);\nScale.area := self >> 0;\nIsSumsSPL := o -> IsRec(o) and\n ((IsBound(o.isSums) and o.isSums) or\n (Same(ObjId(o), Compose) and ForAll(o.children(), IsSumsSPL)));\n\n# ==========================================================================\n# TCast(<n>, <to_type>, <from_type>) - type conversion on <n> elements\n# ==========================================================================\nClass(TCast, SumsBase, Sym, rec(\n abbrevs := [\n (n, to_type) -> Checked(IsPosInt0Sym(n), IsType(to_type), [n, to_type, TUnknown]),\n (n, to_type, from_type) -> Checked(IsPosInt0Sym(n), IsType(to_type), [n, to_type, from_type])\n ],\n def := (n, to_type, from_type) -> Perm((), n),\n dmn := self >> [ TArray(self.params[3], self.params[1]) ],\n rng := self >> [ TArray(self.params[2], self.params[1]) ],\n\n transpose := self >> self,\n conjTranspose := self >> self,\n inverse := self >> self,\n isSymmetric := True,\n isPermutation := False,\n));\n\n# ==========================================================================\n# BB(<spl>) - basic block container, serves as barrier for rule application\n# ==========================================================================\nClass(BB, SumsBase, BaseContainer, rec(isBlock:=true,\n rng := meth(self) return self._children[1].rng(); end,\n dmn := meth(self) return self._children[1].dmn(); end,\n));\n\nClass(Buf, SumsBase, BaseContainer, rec(\n rng := meth(self) return self._children[1].rng(); end,\n dmn := meth(self) return self._children[1].dmn(); end\n));\n\nDeclare(PushL, PushR, PushLR, NoPullLeft, NoPullRight);\n\n# Forces propagation into *left* construct (e.g. ISum, RecursStep, BB, etc)\n# Also .sums() conversion always returns same object, ie conversion of\n# child is not forced. This is done to avoid Sigma-SPLizing constructs\n# that we want to pull in .\nClass(PushL, Buf, rec(\n sums := self >> self,\n transpose := self >> PushR(self.child(1).transpose()),\n normalizedArithCost := self >> self.child(1).normalizedArithCost(),\n));\n\n# Forces propagation into *right* construct (e.g. ISum, RecursStep, BB, etc)\n# Also .sums() conversion always returns same object, ie conversion of\n# child is not forced. This is done to avoid Sigma-SPLizing constructs\n# that we want to pull in .\nClass(PushR, Buf, rec(\n sums := self >> self,\n transpose := self >> PushL(self.child(1).transpose()),\n normalizedArithCost := self >> self.child(1).normalizedArithCost(),\n));\n\n# Allows propagation into either right or left construct (e.g. ISum, RecursStep, BB, etc)\n# Also .sums() conversion always returns same object, ie conversion of\n# child is not forced. This is done to avoid Sigma-SPLizing constructs\n# that we want to pull in .\nClass(PushLR, Buf, rec(sums := self >> self));\n\n# Prevents propagation into constructs on both sides (e.g. ISum, RecursStep, BB, etc)\nClass(NoPull, Buf);\n\n# Prevents pull-in. Used for distributed stuff.\nClass(NoPull_Dist, Buf);\n\n# Prevents propagation pulling in of diags\nDeclare(NoDiagPullinRight);\nClass(NoDiagPullin, Buf);\nClass(NoDiagPullinLeft, Buf, rec(\n transpose := self >> NoDiagPullinRight(self.child(1).transpose())\n));\nClass(NoDiagPullinRight, Buf, rec(\n transpose := self >> NoDiagPullinLeft(self.child(1).transpose())\n));\n\n# Prevents propagation into left construct (e.g. ISum, RecursStep, BB, etc)\nClass(NoPullLeft, Buf, rec(transpose := self >> NoPullRight(self.child(1).transpose())));\n\n# Prevents propagation into right construct (e.g. ISum, RecursStep, BB, etc)\nClass(NoPullRight, Buf, rec(transpose := self >> NoPullLeft(self.child(1).transpose())));\n\n# Top level wrapper for Sigma-SPL formulas\nClass(Formula, BaseContainer, SumsBase);\n\n#F RecursStep(<expr>)\n#F RecursStep(<yofs>, <xofs>, <expr>) - with implicit\n#F fAdd on Gath (xofs) and Scat (yofs) side\n#F\nClass(RecursStep, SumsBase, BaseContainer, rec(\n abbrevs := [ ch -> [0,0,ch],\n (yofs,xofs,ch) -> [yofs, xofs, ch] ],\n new := (self, yofs, xofs, ch) >> SPL(WithBases(self,\n rec(yofs:=yofs, xofs:=xofs, _children := [ch], dimensions := ch.dims()))),\n rChildren := self >> [self.yofs, self.xofs, self._children[1]],\n rSetChild := meth(self, n, what)\n if n=1 then self.yofs := what;\n elif n=2 then self.xofs := what;\n elif n=3 then self._children[1] := what;\n else Error(\"<n> must be in [1..3]\");\n fi;\n end,\n));\n\nClass(Inplace, SumsBase, BaseContainer, rec(\n rng:=self>>self._children[1].rng(),\n dmn:=self>>self._children[1].dmn(),\n numops:=self >>0, # YSV: what is this? pls remove or document\n toNonInplace := self >> self._children[1],\n isInplace := self >> true,\n normalizedArithCost := self >> self._children[1].normalizedArithCost(),\n));\n\nClass(LStep, SumsBase, BaseContainer, rec(\n toAMat := self >> AMatMat(Sum([I(Rows(self)), self.child(1)], MatSPL))\n));\n\nDeclare(RTWrap); # to avoid complaints in .transpose\n\nClass(RTWrap, SumsBase, BaseContainer, rec(\n new := (self, rt) >> Checked(Global.formgen.IsRuleTree(rt),\n SPL(WithBases(self, rec(\n rt := rt,\n root := rt.node))).setDims()),\n\n area := self >> Rows(self) * Cols(self),\n children := self >> [self.rt],\n child := (self, n) >> When(n=1, self.rt, Error(\"<n> must be 1\")),\n setChild := rSetChildFields(\"rt\"),\n rSetChild := ~.setChild,\n rChildren := ~.children,\n\n dims := self >> self.rt.dims(),\n isPermutation := self >> self.rt.node.isPermutation(),\n isReal := self >> self.rt.node.isReal(),\n toAMat := self >> self.rt.node.toAMat(),\n\n transpose := self >> RTWrap(self.rt.transpose()),\n conjTranspose := self >> InertConjTranspose(self),\n isInertConjTranspose := True,\n));\n\n# ==========================================================================\n# COND(<spl>) - This is a 'switch' statement for SPLs \n# ==========================================================================\nClass(COND, SumsBase, BaseContainer, rec(\n abbrevs := [ arg -> let(f:=Flat(arg), [f[1], Drop(f, 1)]) ],\n new := (self, cond, spls) >> SPL(WithBases(self, rec(\n _children := spls,\n dimensions := spls[1].dimensions,\n cond := cond))),\n\n toAMat := self >> When(self.cond.ev()=V(true) or self.cond.ev()=1,\n self.child(1).toAMat(),\n self.child(2).toAMat()),\n\n rChildren := self >> Concatenation([self.cond], self._children),\n rSetChild := meth(self, n, newC)\n if n = 1 then self.cond := newC;\n else self.setChild(n-1, newC);\n fi;\n end,\n\n area := self >> Maximum(List(self.children(), x->x.area())),\n\n sums := self >> CopyFields(self, rec(_children := List(self._children, x->x.sums()))),\n transpose := self >> CopyFields(self, rec(_children := List(self._children, x->x.transpose()))),\n));\n\nClass(RC, SumsBase, BaseContainer, rec(\n dims := self >> let(d:=self.child(1).dims(), [2*d[1], 2*d[2]]),\n isReal := self >> true,\n\n # when RC(M) is transposed with M - complex, not only M is transposed, but also\n # each complex element of M as a 2x2 matrix is transposed == complex conjugation\n transpose := self >> CopyFields(self, rec(_children := [self.child(1).conjTranspose()],\n dimensions := [self.dimensions[2], self.dimensions[1]])),\n\n # RC(.) is real, conjTranspose is just a regular transpose\n conjTranspose := self >> self.transpose(),\n inverse := self >> CopyFields(self, rec(_children := [self.child(1).inverse()],\n dimensions := [self.dimensions[2], self.dimensions[1]])),\n\n sums := self >> CopyFields(self, rec(_children := [self.child(1).sums()])),\n area := self >> 2*self.child(1).area(),\n toAMat := self >> AMatMat(RealMatComplexMat(MatSPL(self.child(1)))),\n createCode := self >> Cond(IsBound(self.child(1).createCode), RC(self.child(1).createCode()), self),\n\n # assume that normalizedArithCost() always returns cost in real ops\n normalizedArithCost := self >> self.child(1).normalizedArithCost(),\n\n));\n\n# This takes a real matrix that can be seen as RC(A) and returns A as complex matrix\nClass(CR, SumsBase, BaseContainer, rec(\n dims := self >> List(self.child(1).dimensions, e -> _unwrap(div(e,2))),\n\n # the derived matrix is real, but over the complex field\n isReal := self >> false,\n\n transpose := self >> CopyFields(self, rec(\n\t_children := [self.child(1).transpose()],\n dimensions := [self.dimensions[2], self.dimensions[1]])),\n\n # CR(.) is complex, but all entries are real, conjTranspose is just a regular transpose\n conjTranspose := self >> self.transpose(),\n\n inverse := self >> CopyFields(self, rec(_children := [self.child(1).inverse()],\n dimensions := [self.dimensions[2], self.dimensions[1]])),\n\n sums := self >> CopyFields(self, rec(_children := [self.child(1).sums()])),\n\n area := self >> 1/2*self.child(1).area(),\n\n toAMat := self >> let(mat := MatSPL(self.child(1)),\n rmat := List(mat{2*[1..Length(mat)/2]}, m -> m{2*[1..Length(m)/2]}),\n AMatMat(rmat)\n ),\n\n # assume that normalizedArithCost() always returns cost in real ops\n normalizedArithCost := self >> self.child(1).normalizedArithCost(),\n vcost := self >> self.child(1).vcost()\n\n));\n\n# ==========================================================================\n# Blk(<mat>) - matrix block\n# ==========================================================================\n# Note: Blk should not check for M being a matrix, \n# otherwise cant reuse Blk for vector code\nClass(Blk, SumsBase, Mat, rec(\n new := (self, M) >> SPL(WithBases(self, rec(\n element := M,\n TType := Cond( # NOTE: add checks to M\n IsList(M), UnifyTypes(List(Flat(M), InferType)),\n IsValue(M), M.t.t,\n\t\t\t IsSymbolic(M), M.t.t),\n\t\t\t))).setDims(),\n area := self >> Length(Filtered(Flat(self.element), k -> k<>0)),\n new := (self, M) >> SPL(WithBases(self, rec(element := M))).setDims(),\n dims := self >> Dimensions(self.element)\n));\n\n# ==========================================================================\n# Blk1(<val>) - 1x1 block\n# ==========================================================================\nClass(Blk1, SumsBase, BaseMat, rec(\n # Compare mathematically Blks disregarding differences in way to express code-level elements.\n# new := (self, val) >> SPL(WithBases(self, rec(dimensions:=[1,1], element:=val))),\n# toAMat := self >> AMatMat([[EvalScalar(Eval(self.element))]]),\n new := (self, val) >> SPL(WithBases(self, rec(dimensions:=[1,1], element:=EvalScalar(Eval(val))))),\n toAMat := self >> AMatMat([[self.element]]),\n transpose := self >> self,\n conjTranspose := self >> CopyFields(self, rec(element := Global.Conjugate(self.element))),\n inverse := self >> CopyFields(self, rec(element := 1 / self.element)),\n area := self >> 1,\n dims := self >> [1,1],\n));\n\n\n# ==========================================================================\n# BlkConj() - pseudo 1x1 matrix when multiplied w/ complex number conjugates it\n# ==========================================================================\nClass(BlkConj, SumsBase, BaseMat, rec(\n rChildren := self >> [],\n rSetChild := (self, n, what) >> Error(\"no children\"),\n new := (self) >> SPL(WithBases(self, rec(dimensions:=[1,1]))),\n toAMat := self >> AMatMat([[1]]),\n transpose := self >> self,\n conjTranspose := self >> self,\n inverse := self >> self,\n area := self >> 1\n));\n\n# ==========================================================================\n# Data(<var>, <value>, <spl>) - introduces a data constant bound in <spl>\n# ==========================================================================\nClass(Data, SumsBase, BaseContainer, rec(\n new := (self, var, value, spl) >> Checked(IsVar(var), IsSPL(spl),\n\tSPL(WithBases(self, rec(\n\t var := var, value := value, _children := [spl],\n dimensions := spl.dims())))),\n #-----------------------------------------------------------------------\n area := self >> self.child(1).area(),\n #-----------------------------------------------------------------------\n eval := meth(self)\n local d, c;\n if IsBound(self._evaluated) then return self._evaluated;\n else\n d := Cond(\n IsValue(self.value) or IsSymbolic(self.value), self.value,\n IsBound(self.value.tolist), V(self.value.tolist()),\n IsSPL(self.value), V(MatSPL(self.value)),\n self.value);\n c := Copy(self._children[1]);\n self._evaluated := SubstBottomUp(c, @(1, var, e->Same(e,self.var)), e -> d);\n return self._evaluated;\n fi;\n end,\n\n rChildren := self >> [self.var, self.value, self.child(1)],\n rSetChild := meth(self, n, newC)\n if n=1 then self.var := newC;\n elif n=2 then self.value := newC;\n elif n=3 then self._children[1] := newC;\n else Error(\"<n> must be between [1..3]\");\n fi;\n end,\n from_rChildren := (self, rch) >> CopyFields(self, rec(\n var := rch[1], value := rch[2], _children := [rch[3]])),\n #-----------------------------------------------------------------------\n uneval := meth(self) Unbind(self._evaluated); return self; end,\n #-----------------------------------------------------------------------\n transpose := self >> CopyFields(self, rec(\n _children := [self.child(1).transpose()])).uneval(),\n #-----------------------------------------------------------------------\n toAMat := self >> self.eval().toAMat(),\n #-----------------------------------------------------------------------\n sums := self >> CopyFields(self, rec(_children := [self.child(1).sums()])),\n));\n\nDeclare(Scat);\n\n#F ==========================================================================\n#F Gath(<func>) - gather (read) matrix\n#F NOTE: implements affine transformations via funcExp hack.\n\n#F as of Dec '2010, <func> can contain fInsert/fPad, which will create\n#F funcExp(..) in the code. This is used for simulating affine (rather\n#F than linear) transformation.\n#F\n#F Affine transformations can only be experessed using matrices, if we\n#F use homogeneous coordinates, i.e., instead of [x_1, ..., x_n] use\n#F always [x_1, ..., x_n, 1], for input/output vectors\n#F\n#F Gath.toAMat and everything else does NOT use homogeneous\n#F coordinates, and thus we can't represent affine \"gathers\" with a\n#F proper matrix, the only special case is when funcExp(0) is used to\n#F insert 0s (this preserves linearity).\n#F\n#F Currently, we use the following semantics (to implement affine transf. using a hack)\n#F\n#F nth(X, i) == X[i]\n#F nth(X, funcExp(i)) == i\n#F\n#F The proper way of doing this would be instead (using h. coords, X[len(x)] = 1)\n#F nth(X, funcExp(i)) -> i * nth(X, len(X)) = i * X[len(X)] = i \n#F\n#F See http://en.wikipedia.org/wiki/Transformation_matrix#Affine_transformations\n# ==========================================================================\nClass(Gath, SumsBase, BaseMat, rec(\n #-----------------------------------------------------------------------\n rChildren := self >> [self.func],\n rSetChild := rSetChildFields(\"func\"),\n #-----------------------------------------------------------------------\n new := (self, func) >> SPL(WithBases(self, rec(\n \tfunc := Checked(IsFunction(func) or IsFuncExp(func), func)))).setDims(),\n #-----------------------------------------------------------------------\n dims := self >> [self.func.domain(), self.func.range()],\n sums := self >> self,\n area := self >> Sum(Flat([self.func.domain()])),\n isReal := self >> true,\n transpose := self >> Scat(self.func),\n conjTranspose := self >> self.transpose(),\n inverse := self >> self.transpose(),\n #-----------------------------------------------------------------------\n toAMat := self >> let(\n\tn := EvalScalar(self.func.domain()),\n N := EvalScalar(self.func.range()),\n func := self.func.lambda(),\n AMatMat(List([0..n-1], row -> let(\n idx := EvalScalar(func.at(row)),\n\t Cond(idx _is funcExp,\n\t\t When(idx.args[1]=0, Replicate(N, 0), \n\t\t\t Error(\"<self> is an affine (non-linear) transformation \",\n\t\t\t \"and can't be represented as a matrix\")),\n\t\t BasisVec(N, idx)))))\n ),\n #-----------------------------------------------------------------------\n toloop := (self, bksize) >> let(\n\ti := Ind(self.func.domain()),\n\tISum(i, \n Scat(fTensor(fBase(i), fId(1))) *\n Gath(fCompose(self.func, fTensor(fBase(i), fId(1))))\n\t).split(bksize)\n ),\n #-----------------------------------------------------------------------\n normalizedArithCost := self >> 0,\n #-----------------------------------------------------------------------\n isIdentity := self >> IsIdentity(func),\n));\n\n#F ==========================================================================\n#F Prm(<func>) - permutation, semantically same as Gath(<func>), but square\n#F\n#F NB: Prm should not be used with fPad/fInsert, which lead to affine \n#F transformations when used with Gath.\n#F\n#F Prm(f).transpose() = Prm(f.transpose())\n#F\n#F ==========================================================================\nClass(Prm, Gath, rec(\n transpose := self >> CopyFields(self, rec(func:=self.func.transpose())),\n toAMat := self >> Perm(PermList(List(self.func.lambda().tolist(), e->e.v)+1),\n self.func.domain()).toAMat(),\n #-----------------------------------------------------------------------\n normalizedArithCost := self >> 0\n));\n\n# special perm to be gotten rid of in rewriting\nClass(DelayedPrm, Prm);\nClass(FormatPrm, Prm);\n\n#F ==========================================================================\n#F Scat(<func>) - scatter (write) matrix, Scat(f) = Gath(f).transpose()\n#F\n#F NOTE: implements affine transformations via funcExp workaround. \n#F See Doc(Gath) for explanation\n#F ==========================================================================\nClass(Scat, SumsBase, BaseMat, rec(\n #-----------------------------------------------------------------------\n rChildren := self >> [self.func],\n rSetChild := rSetChildFields(\"func\"),\n #-----------------------------------------------------------------------\n new := (self, func) >> SPL(WithBases(self, rec(\n\tfunc := Checked(IsFunction(func) or IsFuncExp(func), func)))).setDims(),\n #-----------------------------------------------------------------------\n dims := self >> [self.func.range(), self.func.domain()],\n sums := self >> self,\n area := self >> Sum(Flat([self.func.domain()])),\n isReal := self >> true,\n transpose := self >> Gath(self.func),\n conjTranspose := self >> self.transpose(),\n inverse := self >> self.transpose(),\n #-----------------------------------------------------------------------\n toAMat := self >> TransposedAMat(Gath(self.func).toAMat()),\n #-----------------------------------------------------------------------\n toloop := (self, bksize) >> Gath(self.func).toloop(bksize).transpose(),\n #-----------------------------------------------------------------------\n normalizedArithCost := self >> 0,\n #-----------------------------------------------------------------------\n isIdentity := self >> IsIdentity(self.func),\n));\n\nClass(ScatAcc, Scat, rec(\n codeletName:=\"SA\", \n toloop := (self, bksize) >> Error(\"Not implemented\")\n));\n\nDeclare(ScatGath);\n\n# ==========================================================================\n# ScatGath(<sfunc>, <gfunc>)\n# ==========================================================================\nClass(ScatGath, SumsBase, BaseMat, rec(\n rChildren := self >> [self.sfunc, self.gfunc],\n rSetChild := rSetChildFields(\"sfunc\", \"gfunc\"),\n #-----------------------------------------------------------------------\n new := (self, sfunc, gfunc) >> SPL(WithBases(self,\n rec(dimensions := [sfunc.range(), gfunc.range()], \n\t sfunc := Checked(IsFunction(sfunc) or IsFuncExp(sfunc), sfunc),\n\t gfunc := Checked(IsFunction(gfunc) or IsFuncExp(gfunc), gfunc)))),\n #-----------------------------------------------------------------------\n dims := self >> [self.sfunc.range(), self.gfunc.range()],\n area := self >> self.sfunc.domain(),\n isReal := self >> true,\n transpose := self >> ScatGath(self.gfunc, self.sfunc),\n conjTranspose := self >> self.transpose(),\n inverse := self >> self.transpose(),\n #-----------------------------------------------------------------------\n toAMat := meth(self)\n local s, gfunc, g, sdomain, gdomain, idx;\n # NOTE: FF: this is a temporary solution to work around Lamda \n\t# problems with symbolic domains and variable substitution\n s := Scat(self.sfunc);\n sdomain := EvalScalar(self.sfunc.domain());\n gdomain := spiral.code.RulesStrengthReduce(self.gfunc.domain());\n if ObjId(self.gfunc) = Lambda and IsExp(gdomain) then\n idx := Ind(sdomain);\n gfunc := Lambda(idx, self.gfunc.at(idx)).setRange(self.gfunc.range());\n else\n gfunc := self.gfunc;\n fi;\n g :=Gath (gfunc);\n return s.toAMat() * g.toAMat();\n end,\n # Correct semantics: Scat(self.sfunc).toAMat() * Gath(self.gfunc).toAMat(),\n #-----------------------------------------------------------------------\n sums := self >> self, #self.toloop(self.maxBkSize()),\n #-----------------------------------------------------------------------\n maxBkSize := meth(self)\n local exp, l, d;\n exp := self.gfunc.domain();\n\n if IsValue(exp) or IsInt(exp) then return exp; fi;\n\n if IsExp(exp) and ObjId(exp)=mul and IsValue(exp.args[1]) then\n return exp.args[1];\n fi;\n\n if IsInt(exp.eval()) or IsValue(exp.eval()) then return EvalScalar(exp); fi;\n l := Lambda(Filtered(exp.free(), IsLoopIndex), exp);\n if Length(l.vars) > 1 then return 1; fi;\n d := List(spiral.sigma.GenerateData(l).tolist(), EvalScalar);\n return Gcd(d);\n end,\n #-----------------------------------------------------------------------\n toloop := (self, bksize) >> let(\n\ti := Ind(self.gfunc.domain()),\n ISum(i, \n Scat(fCompose(self.sfunc, fTensor(fBase(i), fId(1)))) *\n Gath(fCompose(self.gfunc, fTensor(fBase(i), fId(1))))\n ).split(bksize)\n )\n));\n\n\n# ==========================================================================\n# SUM(<spl1>, <spl2>, ...) - non-overlapping matrix sum\n# ==========================================================================\nDeclare(SUM, SUMAcc);\nClass(SUM, SumsBase, BaseOperation, rec(\n area := self >> Sum(self.children(), x->x.area()),\n abbrevs := [ arg ->\n [ Flat(List(Flat(arg),\n s -> When(IsSPL(s) and Same(ObjId(s), SUM), s.children(), s))) ] ],\n #-----------------------------------------------------------------------\n new := meth(self, L)\n local dims;\n Constraint(Length(L) >= 1); Constraint(ForAll(L, IsSPL));\n if Length(L) = 1 then return L[1]; fi;\n dims := L[1].dims();\n if not (IsSymbolic(dims[1]) or IsSymbolic(dims[2])) and\n not ForAll(Drop(L, 1), x -> let(d:=x.dims(),\n IsSymbolic(d[1]) or IsSymbolic(d[2]) or d = dims))\n then Error(\"Dimensions of summands do not match\"); fi;\n return SPL(WithBases(self, rec( _children := L, dimensions := dims)));\n end,\n #-----------------------------------------------------------------------\n rng := self >> self.child(1).rng(),\n #-----------------------------------------------------------------------\n dmn := self >> self.child(1).dmn(),\n\n advdims := self >> self._children[1].advdims(),\n #-----------------------------------------------------------------------\n# dims := self >> self.child(1).dimensions,\n #-----------------------------------------------------------------------\n toAMat := self >> AMatMat(Sum(self._children, MatSPL)),\n #-----------------------------------------------------------------------\n isPermutation := self >> false,\n #-----------------------------------------------------------------------\n transpose := self >> # we use CopyFields to copy all fields of self\n CopyFields(self, rec(\n _children := List(self._children, x->x.transpose()),\n dimensions := Reversed(self.dimensions))),\n inverse := self >> # we use CopyFields to copy all fields of self\n CopyFields(self, rec(\n _children := List(self._children, x->x.inverse()),\n dimensions := Reversed(self.dimensions))),\n conjTranspose := self >> # we use CopyFields to copy all fields of self\n CopyFields(self, rec(\n _children := List(self._children, x->x.conjTranspose()),\n dimensions := Reversed(self.dimensions)))\n));\n\n# ==========================================================================\n# SUMAcc(<spl1>, <spl2>, ...) - overlapping matrix sum\n# ==========================================================================\nClass(SUMAcc, SUM, rec(\n abbrevs := [ arg ->\n [ Flat(List(Flat(arg),\n s -> When(IsSPL(s) and Same(ObjId(s), SUMAcc), s.children(), s))) ] ]\n ));\n\n# ==========================================================================\n# ISum(<var>, <domain>, <spl>) - non-overlapping iterative matrix sum\n# ==========================================================================\nClass(ISum, SumsBase, BaseIterative, rec(\n needInterleavedLeft := self >> self.child(1).needInterleavedLeft(),\n needInterleavedRight := self >> self.child(1).needInterleavedRight(),\n cannotChangeDataFormat := self >> self.child(1).cannotChangeDataFormat(),\n totallyCannotChangeDataFormat := self >> self.child(1).totallyCannotChangeDataFormat(),\n\n directOper := SUM,\n area := self >> let(ac:=self._children[1].area(), ac * self.domain),\n #-----------------------------------------------------------------------\n rng := self >> self._children[1].rng(),\n dmn := self >> self._children[1].dmn(),\n dims := self >> [StripList(List(self.rng(),l->l.size)),StripList(List(self.dmn(),l->l.size))],\n\n advdims := self >> self._children[1].advdims(),\n\n #-----------------------------------------------------------------------\n transpose := self >> CopyFields(self, rec(\n _children := [self._children[1].transpose()],\n dimensions := Reversed(self.dimensions))),\n conjTranspose := self >> CopyFields(self, rec(\n _children := [self._children[1].conjTranspose()],\n dimensions := Reversed(self.dimensions))),\n inverse := self >> CopyFields(self, rec(\n _children := [self._children[1].inverse()],\n dimensions := Reversed(self.dimensions))),\n #-----------------------------------------------------------------------\n unroll := self >> SUM(self.unrolledChildren()),\n #-----------------------------------------------------------------------\n sums := self >> CopyFields(self, rec(\n _children := [self._children[1].sums()]))\n));\n\nClass(ISumLS, ISum);\nClass(JamISum, ISum, rec(isBlockTransitive := true));\nClass(Grp, Buf);\n\n# ==========================================================================\n# ICompose(<var>, <domain>, <spl>) - iterative matrix product\n# ==========================================================================\nClass(ICompose, SumsBase, BaseIterative, rec(\n area := self >> self._children[1].area() * self.domain,\n #-----------------------------------------------------------------------\n dims := self >> self._children[1].dimensions,\n #-----------------------------------------------------------------------\n unroll := self >> Compose(self.unrolledChildren()),\n #-----------------------------------------------------------------------\n transpose := self >> ICompose(self.var, self.domain,\n SubstVars(Copy(self._children[1].transpose()), \n\t tab((self.var.id) := self.domain-1-self.var))),\n\n createCode := self >> Cond(IsBound(self._children[1].createCode),\n ICompose(self.var, self.domain, self._children[1].createCode()), self),\n\n prods := self >> let(base := self.__bases__[1],\n base(self.var, self.domain, self._children[1].prods())),\n\n# rChildren := self >> [self.var, self.domain, self._children[1]],\n#\n# from_rChildren := (self, rch) >> ApplyFunc(ObjId(self), rch),\n#\n# rSetChild := meth(self, n, newChild)\n# if n=1 then self.var := newChild;\n# elif n=2 then self.domain := newChild;\n# elif n=3 then self._children := [newChild];\n# else Error(\"<n> must be in [1..3]\");\n# fi;\n# end\n));\n\n\n# ==========================================================================\n# ISumAcc(<var>, <domain>, <spl>) - overlapping iterative matrix sum\n# ==========================================================================\nClass(ISumAcc, ISum);\n\n# ==========================================================================\n# IParSeq(<var>, <domain>, <fb>, <spl>) \n# ==========================================================================\nDeclare(ParSeq);\nClass(IParSeq, SumsBase, BaseIterative, rec(\n abbrevs := [ (v, fb_cnt, expr) -> [v, v.range, fb_cnt, expr] ],\n new := meth(self, v, domain, fb_cnt, expr)\n local obj;\n #NOTE: check dimensions\n obj := Inherited(v, domain, expr);\n obj.fb_cnt := fb_cnt;\n return obj;\n end,\n\n dims := self >> self._children[1].dims(),\n unroll := self >> ParSeq( self.fb_cnt, Reversed(self.unrolledChildren())),\n\n filtCompL := (self, lst) >> lst{[1..self.fb_cnt]},\n filtCompR := (self, lst) >> lst{[1..self.fb_cnt]},\n filtSUML := (self, lst) >> lst{[self.fb_cnt+1..Length(lst)]},\n filtSUMR := (self, lst) >> lst{[self.fb_cnt+1..Length(lst)]},\n\n # area doesn take into account that we have composition and sum\n area := self >> self._children[1].area() * self.domain,\n\n print := (self, i, is) >> Print(\n self.name, \"(\", self.var, \", \", self.domain, \", \", self.fb_cnt, \",\\n\",\n Blanks(i+is), self._children[1].print(i+is, is), \"\\n\",\n Blanks(i), \")\", self.printA(),\n When(IsBound(self._setDims), Print(\".overrideDims(\", self._setDims, \")\"), Print(\"\"))\n ),\n));\n\n##############################################################################\nDeclare(Conj, ConjL, ConjR, ConjLR, ConjDiag);\n\nClass(Conj, SumsBase, BaseOperation, rec(\n new := (self, spl) >> SPL(WithBases(self, rec(_children:=[spl], dimensions := spl.dimensions))),\n dims := self >> self._children[1].dims(),\n toAMat := self >> self.child(1).toAMat(),\n sums := self >> self,\n transpose := self >> Conj(self.child(1).transpose())\n));\n\nClass(ConjL, Conj, rec(\n new := (self, spl, lprm) >> SPL(WithBases(self, rec(_children:=[spl, lprm]))).setDims(),\n dims := self >> [self.child(2).dims()[1], self.child(1).dims()[2]],\n toAMat := self >> self.child(2).toAMat() * self.child(1).toAMat(),\n sums := self >> ConjL(self.child(1).sums(), self.child(2)),\n transpose := self >> ConjR(self.child(1).transpose(), self.child(2).transpose()),\n));\n\nClass(ConjR, Conj, rec(\n new := (self, spl, rprm) >> SPL(WithBases(self, rec(_children:=[spl, rprm]))).setDims(),\n dims := self >> [self._children[1].dims()[1], self._children[2].dims()[2]],\n toAMat := self >> self.child(1).toAMat() * self.child(2).toAMat(),\n sums := self >> ConjR(self.child(1).sums(), self.child(2)),\n transpose := self >> ConjL(self.child(1).transpose(), self.child(2).transpose()),\n));\n\nClass(ConjLR, Conj, rec(\n new := (self, spl, lprm, rprm) >> SPL(WithBases(self, rec(_children:=[spl, lprm, rprm]))).setDims(),\n dims := self >> [ self.child(2).dims()[1], self.child(3).dims()[2] ],\n toAMat := self >> self.child(2).toAMat() * self.child(1).toAMat() * self.child(3).toAMat(),\n sums := self >> ConjLR(self.child(1).sums(), self.child(2), self.child(3)),\n transpose := self >> ConjLR(self.child(1).transpose(), self.child(3).transpose(), self.child(2).transpose()),\n));\n\nClass(ConjDiag, Conj, rec(\n new := (self, spl, lprm, rprm) >> SPL(WithBases(self, rec(_children:=[spl, lprm, rprm]))).setDims(),\n dims := self >> [Rows(self.child(2)), Cols(self.child(3))],\n toAMat := self >> self.child(2).toAMat() * self.child(1).toAMat() * self.child(3).toAMat(),\n sums := self >> ConjDiag(self.child(1).sums(), self.child(2), self.child(3)),\n transpose := self >> ConjDiag(self.child(1).transpose(), self.child(3).transpose(), self.child(2).transpose()),\n));\n\nClass(NeedInterleavedComplex, BaseContainer, rec(\n needInterleavedLeft := True,\n needInterleavedRight := True,\n sums := self >> self,\n area:= self >> self.child(1).area()\n));\n", "meta": {"hexsha": "31f5b4e4d00cf65e51dbc67a9461516f7e5d38a0", "size": 34134, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/spl/sums.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/spl/sums.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/spl/sums.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 43.7615384615, "max_line_length": 115, "alphanum_fraction": 0.5026952599, "num_tokens": 8318, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4687906266262437, "lm_q2_score": 0.035678549339680746, "lm_q1q2_score": 0.01672576950206429}}
{"text": "#############################################################################\n####\n##\n#W anupqopt.gi ANUPQ package Werner Nickel\n#W Greg Gamble\n##\n## Install file for functions to do with option manipulation.\n## \n#Y Copyright (C) 2001 Lehrstuhl D fuer Mathematik, RWTH Aachen, Germany\n##\n\n#############################################################################\n##\n#V PQ_FUNCTION . . . . . . . . . internal functions called by user functions \n##\n## A record whose fields are (function) names and whose values are the\n## internal functions called by the functions with those names.\n##\nInstallValue( PQ_FUNCTION, \n rec( Pq := PQ_EPI_OR_PCOVER,\n PqDescendants := PQ_DESCENDANTS,\n StandardPresentation := PQ_EPIMORPHISM_STANDARD_PRESENTATION,\n PqDescendantsTreeCoclassOne := PqDescendantsTreeCoclassOne\n )\n );\n\n#############################################################################\n##\n#V ANUPQoptions . . . . . . . . . . . . . . . . . . . . admissible options\n##\n## is a record of lists of names of admissible {\\ANUPQ} options, such that\n## each field is either the name of a (``key'') {\\ANUPQ} function and the\n## corresponding value is the list of option names that are admissible for\n## the function.\n##\nInstallValue( ANUPQoptions, \n rec( # options for `Pq' and `PqEpimorphism'\n Pq := [ \"Prime\", \n \"ClassBound\", \n \"Exponent\", \n \"Metabelian\", \n \"OutputLevel\", \n \"Relators\", \n \"Identities\",\n \"GroupName\", \n \"SetupFile\",\n \"PqWorkspace\",\n \"RedoPcp\" ],\n\n # options for `PqDescendants'\n PqDescendants\n := [ \"ClassBound\", \n \"OrderBound\", \n \"Relators\", \n \"GroupName\", \n \"StepSize\", \n \"PcgsAutomorphisms\", \n \"RankInitialSegmentSubgroups\", \n \"SpaceEfficient\", \n \"CapableDescendants\", \n \"AllDescendants\", \n \"Exponent\", \n \"Metabelian\", \n \"SubList\", \n \"BasicAlgorithm\",\n \"CustomiseOutput\",\n \"SetupFile\",\n \"PqWorkspace\" ],\n\n # options for `[Epimorphism][Pq]StandardPresentation'\n StandardPresentation\n := [ \"Prime\", \n \"pQuotient\",\n \"ClassBound\", \n \"Relators\", \n \"GroupName\", \n \"PcgsAutomorphisms\", \n \"Exponent\", \n \"Metabelian\", \n \"OutputLevel\", \n \"StandardPresentationFile\", \n \"SetupFile\",\n \"PqWorkspace\" ],\n\n # options for `PqDescendantsTreeCoclassOne'\n PqDescendantsTreeCoclassOne\n := [ \"ClassBound\", \n \"OrderBound\", \n \"Relators\", \n \"GroupName\", \n \"StepSize\", \n \"PcgsAutomorphisms\", \n \"RankInitialSegmentSubgroups\", \n \"SpaceEfficient\", \n \"CapableDescendants\", \n \"AllDescendants\", \n \"Exponent\", \n \"Metabelian\", \n \"SubList\", \n \"BasicAlgorithm\",\n \"CustomiseOutput\",\n \"TreeDepth\",\n \"SetupFile\",\n \"PqWorkspace\" ],\n\n PqList \n := [ \"SubList\" ],\n PqPcPresentation\n := [ \"Prime\", \n \"ClassBound\", \n \"Exponent\", \n \"Metabelian\", \n \"OutputLevel\", \n \"Relators\", \n \"Identities\",\n \"GroupName\" ],\n PqNextClass\n := [ \"QueueFactor\" ],\n PqEvaluateIdentities\n := [ \"Identities\" ],\n PqDoExponentChecks\n := [ \"Bounds\" ],\n PqDisplayStructure\n := [ \"Bounds\" ],\n PqDisplayAutomorphisms\n := [ \"Bounds\" ],\n PqSPComputePcpAndPCover\n := [ \"Prime\", \n \"ClassBound\", \n \"Exponent\", \n \"Metabelian\", \n \"OutputLevel\", \n \"Relators\", \n \"GroupName\" ],\n PqSPSavePresentation\n := [ \"ClassBound\", \n \"PcgsAutomorphisms\", \n \"StandardPresentationFile\" ],\n PqPGSetDescendantToPcp\n := [ \"Filename\" ], \n PqPGSupplyAutomorphisms\n := [ \"NumberOfSolubleAutomorphisms\",\n \"RelativeOrders\" ],\n PqPGConstructDescendants\n := [ \"ClassBound\", \n \"OrderBound\", \n \"StepSize\", \n \"PcgsAutomorphisms\", \n \"RankInitialSegmentSubgroups\", \n \"SpaceEfficient\", \n \"CapableDescendants\", \n \"AllDescendants\", \n \"Exponent\", \n \"Metabelian\", \n \"BasicAlgorithm\",\n \"CustomiseOutput\" ],\n PqAPGDegree\n := [ \"Exponent\" ],\n PqAPGPermutations\n := [ \"PcgsAutomorphisms\",\n \"SpaceEfficient\",\n \"PrintAutomorphisms\",\n \"PrintPermutations\" ],\n PqAPGOrbits\n := [ \"PcgsAutomorphisms\",\n \"SpaceEfficient\",\n \"CustomiseOutput\" ],\n PqAPGOrbitRepresentatives\n := [ \"PcgsAutomorphisms\", \n \"SpaceEfficient\", \n \"CapableDescendants\", \n \"AllDescendants\", \n \"Exponent\", \n \"Metabelian\", \n \"CustomiseOutput\",\n \"Filename\" ], \n PqAPGSingleStage\n := [ \"StepSize\", \n \"PcgsAutomorphisms\", \n \"RankInitialSegmentSubgroups\", \n \"SpaceEfficient\", \n \"CapableDescendants\", \n \"AllDescendants\", \n \"Exponent\", \n \"Metabelian\", \n \"BasicAlgorithm\",\n \"CustomiseOutput\" ]\n )\n );\n\n#############################################################################\n##\n#F AllANUPQoptions() . . . . . . . . lists all options of the ANUPQ package\n##\n## lists all the {\\GAP} options defined for functions of the {\\ANUPQ}\n## package.\n##\nInstallGlobalFunction( AllANUPQoptions, function()\n return Set( Concatenation(\n List( RecNames(ANUPQoptions), fld -> ANUPQoptions.(fld) )\n ) );\nend );\n\n#############################################################################\n##\n#V ANUPQGlobalOptions . . . . . options that can be set globally by PqStart\n##\n## A list of the options that `PqStart' can set and thereby make available\n## to any function interacting with the {\\ANUPQ} process initiated by\n## `PqStart'.\n##\nInstallValue( ANUPQGlobalOptions, [ \"Prime\", \"Exponent\", \"Relators\" ] );\n\n#############################################################################\n##\n#V ANUPQoptionChecks . . . . . . . . . . . the checks for admissible options\n##\n## A record whose fields are the names of admissible ANUPQ options and whose\n## values are one-argument functions that return `true' when given a value\n## that is a valid value for the option, and `false' otherwise.\n##\nInstallValue( ANUPQoptionChecks,\n rec( Prime := x -> IsInt(x) and IsPrimeInt(x),\n pQuotient := IsPcGroup and IsPGroup,\n ClassBound := IsPosInt,\n OrderBound := IsPosInt,\n Exponent := IsPosInt,\n Metabelian := IsBool,\n GroupName := IsString,\n Identities := x -> IsList(x) and ForAll(x, IsFunction),\n OutputLevel := x -> x in [0..3],\n Relators := x -> IsList(x) and ForAll(x, IsString),\n StandardPresentationFile := IsString,\n SetupFile := IsString,\n PqWorkspace := IsPosInt,\n StepSize := x -> IsPosInt(x) or\n (IsList(x) and ForAll(x, IsPosInt)), \n PcgsAutomorphisms := IsBool,\n BasicAlgorithm := IsBool,\n RankInitialSegmentSubgroups := x -> x = 0 or IsPosInt(x),\n SpaceEfficient := IsBool,\n CapableDescendants := IsBool,\n AllDescendants := IsBool,\n SubList := x -> IsPosInt(x) or\n (IsSet(x) and ForAll(x, IsInt)\n and IsPosInt(x[1])),\n CustomiseOutput := IsRecord,\n Bounds := x -> IsSet(x) and 2 = Length(x) and \n ForAll(x, IsPosInt),\n QueueFactor := IsPosInt,\n RedoPcp := IsBool,\n PrintAutomorphisms := IsBool,\n PrintPermutations := IsBool,\n NumberOfSolubleAutomorphisms := x -> x = 0 or IsPosInt(x),\n RelativeOrders := x -> IsList(x) and ForAll(x, IsPosInt),\n Filename := IsString,\n TreeDepth := IsPosInt\n )\n );\n\n#############################################################################\n##\n#V ANUPQoptionTypes . . . . . . the types (in words) for admissible options\n##\n## A record whose fields are the names of admissible ANUPQ options and whose\n## values are valid types of the options in plain words.\n##\nInstallValue( ANUPQoptionTypes,\n rec( Prime := \"prime integer\",\n pQuotient := \"pc p-group\",\n ClassBound := \"positive integer\",\n OrderBound := \"positive integer\",\n Exponent := \"positive integer\",\n Metabelian := \"boolean\",\n GroupName := \"string\",\n Identities := \"list of functions\",\n OutputLevel := \"integer in [0..3]\",\n Relators := \"list of strings\",\n StandardPresentationFile := \"string\",\n SetupFile := \"string\",\n PqWorkspace := \"positive integer\",\n StepSize := \"positive integer or positive integer list\",\n PcgsAutomorphisms := \"boolean\",\n BasicAlgorithm := \"boolean\",\n RankInitialSegmentSubgroups := \"nonnegative integer\",\n SpaceEfficient := \"boolean\",\n CapableDescendants := \"boolean\",\n AllDescendants := \"boolean\",\n SubList \n := \"pos've integer or increasing pos've integer list\",\n CustomiseOutput := \"record\",\n Bounds := \"pair of increasing positive integers\",\n QueueFactor := \"positive integer\",\n RedoPcp := \"boolean\",\n PrintAutomorphisms := \"boolean\",\n PrintPermutations := \"boolean\",\n NumberOfSolubleAutomorphisms := \"nonnegative integer\",\n RelativeOrders := \"list of positive integers\",\n Filename := \"string\",\n TreeDepth := \"positive integer\"\n )\n );\n\n#############################################################################\n##\n#F PQ_OTHER_OPTS_CHK( <funcname>, <interactive> ) . check opts belong to f'n\n##\n## checks the `OptionsStack' only has recognised options for (generic)\n## function <funcname> and if not and if `ANUPQWarnOfOtherOptions = true'\n## (see~\"ANUPQWarnOfOtherOptions\") `Info's the non-<funcname> options at\n## `InfoANUPQ' level 1.\n##\n## The argument <interactive> is only relevant for those functions that have\n## both an interactive and non-interactive form, namely those with fields in\n## `PQ_FUNCTION', for which some options need to be excluded.\n##\nInstallGlobalFunction(PQ_OTHER_OPTS_CHK, function(funcname, interactive)\nlocal optnames, excopts, generic, interactivestr;\n if ANUPQWarnOfOtherOptions and ValueOption(\"recursive\") = fail and \n not IsEmpty(OptionsStack) then\n excopts := [];\n if funcname in RecNames(PQ_FUNCTION) then\n if interactive then\n excopts := [\"PqWorkspace\", \"SetupFile\"];\n interactivestr := \"interactive\";\n else\n interactivestr := \"non-interactive\";\n if funcname = \"Pq\" then\n excopts := [\"RedoPcp\"];\n fi;\n fi;\n generic := \"generic \";\n else\n generic := \"\";\n fi;\n optnames := Difference( RecNames( OptionsStack[ Length(OptionsStack) ] ),\n Difference( ANUPQoptions.(funcname), excopts ) );\n if funcname = \"Pq\" then\n optnames := Difference( optnames, [\"PqEpiOrPCover\"] );\n fi;\n if not IsEmpty(optnames) then\n Info( InfoANUPQ + InfoWarning, 1, \n \"ANUPQ Warning: Options: \", optnames, \" ignored\" );\n if IsSubset(excopts, optnames) then\n Info( InfoANUPQ + InfoWarning, 1, \n \"(invalid for \", interactivestr, \" call of generic function: `\",\n funcname, \"').\" );\n else\n Info( InfoANUPQ + InfoWarning, 1,\n \"(invalid for \", generic, \"function: `\", funcname, \"').\" );\n fi;\n fi;\n fi;\nend);\n\n#############################################################################\n##\n#F VALUE_PQ_OPTION( <optname> ) . . . . . . . . . enhancement of ValueOption\n#F VALUE_PQ_OPTION( <optname>, <defaultval> ) \n#F VALUE_PQ_OPTION( <optname>, <datarec> ) \n#F VALUE_PQ_OPTION( <optname>, <defaultval>, <datarec> ) \n##\n## If the value <optval> of <optname> is not `fail' and it is an ok value\n## for <optname> then <optval> is returned; if <optval> is not an ok value\n## an error is signalled. If <optval> is `fail' and <datarec> is given and\n## <datarec>.(<optname>) is already bound then that value is returned;\n## otherwise, if <optval> is `fail' and a default value <defaultval>\n## different from `fail' is supplied then <defaultval> is returned.\n## Supplying a <defaultval> of `fail' is special; it indicates that option\n## <optname> must have a value i.e. <optval> is not allowed to be `fail' and\n## if it is an error is signalled. If a <datarec> argument is supplied,\n## which must be a record, then the return value, if not `fail' and a legal\n## value, is also stored in `<datarec>.(<optname>)'.\n##\n## *Note:* <defaultval> cannot be a record.\n##\nInstallGlobalFunction(VALUE_PQ_OPTION, function(arg)\nlocal optname, optval, len;\n optname := arg[1];\n optval := ValueOption(optname);\n len := Length(arg);\n if optval = fail then\n if 1 = len then\n return optval;\n elif IsRecord( arg[len] ) and IsBound( arg[len].(optname) ) then\n # return the previously recorded value\n return arg[len].(optname);\n elif not IsRecord(arg[2]) then\n if arg[2] = fail then\n Error(\"you must supply a value for option: \\\"\", optname, \"\\\"\\n\");\n fi;\n optval := arg[2]; \n fi;\n elif not ANUPQoptionChecks.(optname)(optval) then\n Error(\"\\\"\", optname, \"\\\" value must be a \", \n ANUPQoptionTypes.(optname), \"\\n\");\n fi;\n if (optval <> fail) and (2 <= len) and IsRecord(arg[len]) then\n arg[len].(optname) := optval;\n fi;\n return optval;\nend);\n \n#############################################################################\n##\n#F PQ_OPTION_CHECK(<basefn>,<datarec>) . check optns present/setable if nec.\n##\n## If `<basefn> = \"Pq\"' (i.e. this check is carried out if the function\n## called is `Pq', `PqEpimorphism' or `PqPCover') check that the option\n## `Prime' has been passed or, in a special `PqPCover' case, can be\n## determined from the `<datarec>.group' which must be present. In the\n## special `PqPCover' case, the options `Prime' and `ClassBound' determined\n## are saved in <datarec>. If `Prime' is not supplied in the cases where it\n## needs to be, an error is emitted.\n##\nInstallGlobalFunction(PQ_OPTION_CHECK, function(basefn, datarec)\nlocal optname, out;\n if basefn = \"Pq\" then\n if datarec.calltype = \"interactive\" then\n if VALUE_PQ_OPTION(\"RedoPcp\", false) then\n PQ_UNBIND(datarec, [\"Prime\", \"ClassBound\", \"Exponent\", \"Metabelian\",\n \"pCover\", \"pQuotient\", \"pQepi\"] );\n fi;\n fi;\n if ValueOption(\"PqEpiOrPCover\") = \"pCover\" and\n HasIsPGroup(datarec.group) and IsPGroup(datarec.group) then\n if VALUE_PQ_OPTION(\"Prime\", datarec) = fail then\n if not HasPrimePGroup(datarec.group) then\n Error( \"supplied group is not known to be a p-group or p unknown.\\n\",\n \"Option `Prime' must be supplied\" );\n else\n datarec.Prime := PrimePGroup(datarec.group);\n fi;\n fi;\n if VALUE_PQ_OPTION(\"ClassBound\", datarec) = fail and\n HasPClassPGroup(datarec.group) then\n datarec.ClassBound := PClassPGroup(datarec.group);\n fi;\n else\n VALUE_PQ_OPTION(\"Prime\", fail, datarec);\n fi;\n VALUE_PQ_OPTION(\"ClassBound\", 63, datarec);\n elif basefn = \"StandardPresentation\" then\n if VALUE_PQ_OPTION(\"Prime\", datarec) = fail and\n VALUE_PQ_OPTION(\"pQuotient\", datarec) = fail then\n if IsPcGroup(datarec.group) and IsPGroup(datarec.group) then\n datarec.Prime := PrimePGroup(datarec.group);\n else\n Error( \"since group of process is not a pc p-group, a prime or\\n\",\n \"p-quotient (pc group) of the group of the process \",\n \"must be supplied\\n\" );\n fi;\n fi;\n fi;\nend);\n\n#############################################################################\n##\n#F PQ_CUSTOMISE_OUTPUT(<datarec>, <subopt>, <suboptstring>, <suppstrings>)\n## \n## writes the required output to the `pq' binary for the sub-option <subopt>\n## of the option `CustomiseOutput', the value of that option having\n## previously been stored in `<datarec>.des.CustomiseOutput'; <suboptstring>\n## is part of the comment written to the `pq' binary for the sub-option and\n## <suppstrings> is a list of such comments for the supplementary questions\n## asked by the `pq' binary for the sub-option <subopt>.\n##\nInstallGlobalFunction( PQ_CUSTOMISE_OUTPUT, \nfunction(datarec, subopt, suboptstring, suppstrings)\nlocal optrec, isOptionSet, i;\n optrec := datarec.des.CustomiseOutput;\n if IsEmpty(suppstrings) then\n isOptionSet := IsBound( optrec.(subopt) ) and optrec.(subopt) in [1, true];\n ToPQ_BOOL(datarec, isOptionSet, suboptstring);\n elif IsBound( optrec.(subopt) ) and IsList( optrec.(subopt) ) then\n ToPQ(datarec, [ 0 ], [ \" #customise \", suboptstring ]);\n for i in [1 .. Length(suppstrings)] do\n isOptionSet := IsBound( optrec.(subopt)[i] ) and\n optrec.(subopt)[i] in [1, true];\n ToPQ_BOOL(datarec, isOptionSet, suppstrings[i]);\n od;\n else\n ToPQ(datarec, [ 1 ], [ \" #default \", suboptstring ]);\n fi;\nend);\n \n#############################################################################\n##\n#F PQ_APG_CUSTOM_OUTPUT(<datarec>, <subopt>, <suboptstring>, <suppstrings>)\n## \n## writes the required output to the `pq' binary for the sub-option <subopt>\n## of the option `CustomiseOutput', as required by an Advanced p-Group\n## Generation Menu item, the value of that option having previously been\n## stored in `<datarec>.des.CustomiseOutput'; <suboptstring> is part of the\n## comment written to the `pq' binary for the sub-option and <suppstrings>\n## is a list of such comments for the supplementary questions asked by the\n## `pq' binary for the sub-option <subopt>.\n##\nInstallGlobalFunction( PQ_APG_CUSTOM_OUTPUT, \nfunction(datarec, subopt, suboptstring, suppstrings)\nlocal optrec, optlist, isOptionSet, i;\n optrec := datarec.des.CustomiseOutput;\n if not( IsRecord(optrec) and IsBound( optrec.(subopt) ) and \n IsList( optrec.(subopt) ) ) then\n optlist := [];\n datarec.des.CustomiseOutput.(subopt) := optlist;\n else\n optlist := optrec.(subopt);\n fi;\n for i in [1 .. Length(suppstrings)] do\n isOptionSet := IsBound( optlist[i] ) and optlist[i] in [1, true];\n ToPQ_BOOL(datarec, isOptionSet, suppstrings[i]);\n od;\nend);\n \n#############################################################################\n##\n#F SET_ANUPQ_OPTIONS( <funcname>, <fnname> ) . set options from OptionStack\n## \n## When called by a function with name <funcname> sets the options from\n## `OptionsStack' checking that they are a subset of\n## `ANUPQoptions.<fnname>'. Both <funcname> and <fnname> should be strings.\n##\nInstallGlobalFunction( SET_ANUPQ_OPTIONS, function( funcname, fnname )\n local optrec, optnames, opt;\n\n # there should be options\n if IsEmpty( OptionsStack ) then\n # no options??\n optrec := rec();\n Info( InfoANUPQ, 1, funcname, \" called with no options!\" );\n else\n optrec := ShallowCopy( OptionsStack[ Length( OptionsStack ) ] );\n optnames := Set( REC_NAMES(optrec) );\n SubtractSet( optnames, Set( ANUPQoptions.(fnname) ) );\n Info( InfoANUPQ, 2, funcname, \" called with options: \", \n OptionsStack[ Length( OptionsStack ) ] );\n if 0 < Length(optnames) then\n # it's not an error to have unknown options,\n # function may have been called recursively and the \n # options may be intended for some other function\n Info( InfoWarning + InfoANUPQ, 2,\n funcname, \" called with unknown options: \", optnames);\n fi;\n for opt in optnames do\n Unbind( optrec.(opt) );\n od;\n fi;\n return optrec;\nend );\n\n#############################################################################\n##\n#F ANUPQoptError( <funcname>, <illegal> ) . . . . . create an error message\n##\n## creates an error message for the function with name <funcname>. If\n## <illegal> is a string it is taken to be the first line of the error\n## message. Otherwise <illegal> should be alist of illegal options (strings)\n## found. The error message (string) returned also gives the list of valid\n## options together with the value types expected for function <funcname>.\n##\nInstallGlobalFunction( ANUPQoptError, function( funcname, illegal )\n local Optstring, Valstring, errmsg, optname;\n\n Optstring := optname -> Concatenation(\"\\\"\", optname, \"\\\"\");\n Valstring := optval -> Concatenation(\"<\", optval, \">\");\n\n if IsString(illegal) then\n errmsg := illegal;\n else # IsList(illegal)\n errmsg := Concatenation(\"Illegal \", funcname, \" option\");\n if Length(illegal) > 1 then\n Append(errmsg, \"s\");\n fi;\n Append(errmsg, \": \");\n Append(errmsg, JoinStringsWithSeparator( List(illegal, Optstring) ));\n fi;\n Append(errmsg, Concatenation(\".\\nValid \", funcname, \" options:\\n\"));\n for optname in ANUPQoptions.(funcname) do\n Append(errmsg, \" \");\n Append(errmsg, Optstring(optname));\n if ANUPQoptionChecks.(optname) <> IsBool then\n Append(errmsg, \", \");\n Append(errmsg, Valstring( ANUPQoptionTypes.(optname) ));\n fi;\n Append(errmsg, \"\\n\");\n od;\n return errmsg;\nend );\n\n#############################################################################\n##\n#F ANUPQextractOptions( <funcname>, <args> ) . . . . . . . . extract options\n##\n## extracts options from <args> for function with name <funcname> and\n## returns a record suitable for use with `PushOptions'. Abbreviations are\n## allowed for option names so long as each abbreviates a unique option\n## name.\n##\nInstallGlobalFunction( ANUPQextractOptions, function(funcname, args)\n local Match, error, optrec, i, optname;\n\n # allow to give only a prefix\n Match := function( argi )\n local matches;\n if IsString(argi) then\n matches := Filtered(ANUPQoptions.(funcname), \n optname -> 0 < Length(argi) and\n Length(argi) <= Length(optname) and\n optname{[1..Length(argi)]} = argi);\n if 1 = Length(matches) then\n return matches[1];\n fi;\n error := Concatenation( \"argument: \\\"\", argi, \n \"\\\" doesn't abbreviate a unique option\");\n else\n error := Concatenation( \"argument: \", String(argi),\n \" is not a (non-null) string (option name)\"\n );\n fi;\n return fail;\n end;\n\n # extract options from args\n optrec := rec();\n i := 1;\n while i <= Length(args) do\n optname := Match( args[i] );\n if optname = fail then \n Error( ANUPQoptError( funcname, error ) );\n elif ANUPQoptionChecks.(optname) = IsBool then\n optrec.(optname) := true;\n i := i + 1;\n elif i = Length(args) then\n # all remaining options are non-boolean and expect a value to\n # follow\n Error( ANUPQoptError( \n funcname,\n Concatenation( \"Expected value for option: \", args[i] )\n ) );\n else\n # checking values are ok is done later\n optrec.(optname) := args[i + 1];\n i := i + 2;\n fi;\n od;\n return optrec;\n\nend );\n\n#E anupqopt.gi . . . . . . . . . . . . . . . . . . . . . . . . . . ends here \n", "meta": {"hexsha": "dc30e23bc9c99331d449083fb997aebce75903c6", "size": 27613, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "lib/anupqopt.gi", "max_stars_repo_name": "gap-system/anupq", "max_stars_repo_head_hexsha": "075d27ffe985d561f377a253563605ffea726448", "max_stars_repo_licenses": ["Artistic-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/anupqopt.gi", "max_issues_repo_name": "gap-system/anupq", "max_issues_repo_head_hexsha": "075d27ffe985d561f377a253563605ffea726448", "max_issues_repo_licenses": ["Artistic-2.0"], "max_issues_count": 8, "max_issues_repo_issues_event_min_datetime": "2015-03-04T12:41:28.000Z", "max_issues_repo_issues_event_max_datetime": "2015-09-27T22:17:27.000Z", "max_forks_repo_path": "lib/anupqopt.gi", "max_forks_repo_name": "gap-system/anupq", "max_forks_repo_head_hexsha": "075d27ffe985d561f377a253563605ffea726448", "max_forks_repo_licenses": ["Artistic-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.3512269939, "max_line_length": 80, "alphanum_fraction": 0.4891536595, "num_tokens": 6386, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4493926344647597, "lm_q2_score": 0.036220053784286124, "lm_q1q2_score": 0.01627702539057563}}
{"text": "\n# Copyright 2018-2019, Carnegie Mellon University\n# See LICENSE for details\n\nupdate_type := function(vars, newType)\n vars.t := newType;\nend;\n\n\nUnique := (lst) -> \n FoldL(lst, (b, a)->Concat( b, When(not a in b, [a], [])), []);\n\nSubstList:= function(expr, list_match, list_replace)\n local new_expr, index;\n new_expr := expr;\n for index in [1..Length(list_match)] do\n new_expr := SubstBottomUp(new_expr, @(2).cond(dc->dc=list_match[index]), x->list_replace[index]);\n od;\n return new_expr;\nend;\n\n\n\nClass(RulesStateHCOL, RuleSet, rec(inType := \"SigmaSPL\", outType := \"SigmaSPL\"));\nRewriteRules(RulesStateHCOL, rec(\n Constant_PointWise := ARule(OLCompose, [@(1, PointWise, e->Length(Collect(e.op.expr, e.op.vars[1]))=0), @(2)], e->[@(1).val])\n));\n\n\nClass(RulesTerminateReductionHCOL, RuleSet, rec(inType := \"SigmaSPL\", outType := \"SigmaSPL\"));\nRewriteRules(RulesTerminateReductionHCOL, rec(\n Reduction_GathH := ARule(OLCompose, [@(1, Reduction), @(2, GathH)], \n e->[ let(o:= @(1).val, i:= Ind(o.N), \n ISumReduction(i, o.N, o.op, o.idval, o.isSaturated, eT(@(2).val.N, add(i*@(2).val.stride, @(2).val.base)))) ]),\n\n Reduction_terminate := Rule(@(1, Reduction), e->let(o:= @(1).val, i := Ind(o.N), \n ISumReduction(i, o.N, o.op, o.idval, o.isSaturated, eT(o.N, i)))), \n\n\tScat1Union_Gath1 := ARule(OLCompose, [@(1, ScatHUnion, e1->e1.n=1), @(2, GathH, e2->e2.n=1)], \n\t\te->[ let(\n\t\tPrint(\"Scat1Union_Gath1: \", @(1).val.N, \" \", @(1).val.base, \" \", @(2).val.N, \" \", @(2).val.base,\"\\n\"),\n\t\tOLCompose(\n\t\t eUnion(@(1).val.N, @(1).val.base),\n\t eT(@(2).val.N, @(2).val.base)\n\t\t)\n\t)]),\n\t\t\n ScatHUnion_GathH := ARule(OLCompose, [@(1, ScatHUnion), @(2, GathH)], \n e->[let( i:= Ind(@(1).val.n),\t\n\t ISumUnion(i, @(1).val.n,\n\t OLCompose(\n\t eUnion(@(1).val.n, @(1).val.base+@(1).val.stride*i),\n\t eT(@(2).val.n, @(2).val.base+@(2).val.stride*i)\n\t )\n\t )\n\t)]),\n\n GathH0_terminate := Rule(@(1, GathH, e->e.n=0), e->eT(0, -1)),\n GathH1_terminate := Rule(@(1, GathH, e->e.n=1), e->eT(@(1).val.N, @(1).val.base)),\n GathHN_terminate := Rule(@(1, GathH, e->e.n>1), \n e-> let(i := Ind(@(1).val.n), \n\t \t ISumUnion(i, @(1).val.n, \n\t\t OLCompose(\n\t\t\teUnion(@(1).val.n, i), \n\t\t\teT(@(1).val.N, @(1).val.base+@(1).val.stride*i))))), \n\n ScatHUnion0_terminate := Rule(@(1, ScatHUnion, e->e.n=0), e->eUnion(0,-1)), #eUnion(@(1).val.N, @(1).val.base)),\n ScatHUnion1_terminate := Rule(@(1, ScatHUnion, e->e.n<=1), e->eUnion(@(1).val.N, @(1).val.base)),\n ScatHUnionN_terminate := Rule(@(1, ScatHUnion, e->e.n>1), \n e-> let(i := Ind(@(1).val.n), \n\t ISumUnion(i, @(1).val.n, \n \t OLCompose(\n\t\t\teUnion(@(1).val.N, @(1).val.base+@(1).val.stride*i), \n\t\t\teT(@(1).val.n, i)\n\t )\n ))\n ) ));\n\n\nClass(RulesSumsHCOLv2a, RuleSet, rec(inType := \"SigmaSPL\", outType := \"SigmaSPL\"));\nRewriteRules(RulesSumsHCOLv2a, rec(\n OLCompose_Assoc := ARule(OLCompose, [ @(1,OLCompose) ], e -> @(1).val.children() ),\n OLCompose_PointWise_PointWise := ARule(OLCompose, [ @(1, PointWise), @(2, PointWise) ],\n e -> [ PointWise(@(1).val.N, Lambda(@(2).val.op.vars, SubstVars(Copy(@(1).val.op.expr),\n rec((@(1).val.op.vars[2].id) := @(2).val.op.vars[2], (@(1).val.op.vars[1].id) := @(2).val.op.expr)))) ]),\n GathH_GathH := ARule(OLCompose, [@(1, GathH), @(2, GathH)],\n e -> [GathH(@(2).val.N, @(1).val.n, @(1).val.base+@(2).val.base, @(1).val.stride*@(2).val.stride)]),\n Reduction_ScatHUnion := ARule(OLCompose, [ @(1, Reduction), @(2, ScatHUnion, e->e.n=1) ], e->[]),\n PointWise_BinOp := ARule(OLCompose, [@(1, PointWise, e->e.N=1), @(2, BinOp, e->e.N=1)],\n e -> [BinOp(1,Lambda(@(2).val.op.vars, @(1).val.op.at(@(2).val.op.expr, V(0))))]), \n PointWise_ISumUnion := ARule(OLCompose, [ @(1, PointWise), @(2, ISumUnion) ],\n e -> [ CopyFields(@(2).val, rec(\n _children := List(@(2).val._children, c -> OLCompose(@(1).val, c)),\n dimensions := [Rows(@(1).val), Cols(@(2).val)] )) ]),\n PointWise_ScatHUnion := ARule(OLCompose, [@(1,PointWise), @(2, ScatHUnion)],\n e -> let(i := Ind(@(2).val.dims()[2]), [@(2).val, PointWise(@(2).val.dims()[2], \n Lambda([@(1).val.op.vars[1], i], SubstVars(@(1).val.op.expr, rec((@(1).val.op.vars[2].id) := i*@(2).val.stride+@(2).val.base))))])),\n ISumXXX_YYY := ARule(OLCompose, [ @(1, [ISumUnion, ISumReduction]), @(2, [GathH, PointWise, Induction, eT]) ],\n e -> [ CopyFields(@(1).val, rec(\n _children := List(@(1).val._children, c -> OLCompose(c, @(2).val)),\n dimensions := [Rows(@(1).val), Cols(@(2).val)] )) ]),\n SUMUnion_GathH := ARule(OLCompose, [@(1, SUMUnion), @(2, GathH)], \n e ->[SUMUnion(List(@(1).val._children, c->OLCompose(c, @(2).val)))] ),\n ScatHUnion_SUMUnion := ARule(OLCompose, [ @(1, ScatHUnion), @(2, SUMUnion) ], \n e -> [SUMUnion(List(@(2).val._children, c->OLCompose(@(1).val,c)))] ),\n ScatHUnion_ISumUnion := ARule(OLCompose, [@(1, ScatHUnion), @(2, ISumUnion)], \n e -> [ISumUnion(@(2).val.var, @(2).val.domain, OLCompose(@(1).val, @(2).val._children[1]))]),\n ScatHUnion_ScatHUnion := ARule(OLCompose, [@(1, ScatHUnion), @(2, ScatHUnion)], \n e -> [ScatHUnion(@1.val.N, @(2).val.n, @(1).val.base+@(2).val.base, @(2).val.stride)] ),\n SUMUnion_Assoc := ARule(SUMUnion, [@(1, SUMUnion) ], e->@(1).val.children())\n));\n\nClass(RulesSumsHCOLv2b, RuleSet, rec(inType := \"SigmaSPL\", outType := \"SigmaSPL\"));\nRewriteRules(RulesSumsHCOLv2b, rec(\n OLCompose_Assoc := ARule(OLCompose, [ @(1,OLCompose) ], e -> @(1).val.children() ),\n OLCompose_PointWise_PointWise := ARule(OLCompose, [ @(1, PointWise), @(2, PointWise) ],\n e -> [ PointWise(@(1).val.N, Lambda(@(2).val.op.vars, SubstVars(Copy(@(1).val.op.expr),\n rec((@(1).val.op.vars[2].id) := @(2).val.op.vars[2], (@(1).val.op.vars[1].id) := @(2).val.op.expr)))) ]),\n GathH_GathH := ARule(OLCompose, [@(1, GathH), @(2, GathH)],\n e -> [GathH(@(2).val.N, @(1).val.n, @(1).val.base+@(2).val.base, @(1).val.stride*@(2).val.stride)]),\n ISumReduction_PointWise := ARule(OLCompose, [ @(1, ISumReduction), @(2, PointWise) ],\n e -> [ ISumReduction(@(1).val.var, @(1).val.domain, @(1).val.op, @(1).val.idval, @(1).val.isSaturated,\n OLCompose(@(1).val._children[1], @(2).val))]),\n\n eT_Pointwise := ARule(OLCompose, [@(1, eT, e->IsVar(e.base)), @(2, PointWise)], \n e -> let(i := Ind(1),\n\t [PointWise(1, Lambda(\n SubstVars(Copy(@(2).val.op.vars), rec((@(2).val.op.vars[2].id):=i)),\n SubstVars(Copy(@(2).val.op.expr), rec((@(2).val.op.vars[2].id):=@(1).val.base)))), @(1).val])),\n ISumXXX_YYY := ARule(OLCompose, [ @(1, [ISumUnion, ISumReduction]), @(2, [GathH, PointWise, Induction, eT]) ],\n e -> [ CopyFields(@(1).val, rec(\n _children := List(@(1).val._children, c -> OLCompose(c, @(2).val)),\n dimensions := [Rows(@(1).val), Cols(@(2).val)] )) ]),\n eT_ISumUnion := ARule(OLCompose, [ @(1, eT), @(2, ISumUnion, e->ObjId(e._children[1]._children[1])=eUnion)],\n e -> [ Drop(SubstVars(Copy(@(2).val._children[1]._children), rec((@(2).val.var.id) := (@(1).val.base)) ), 1)]),\n eT_Induction := ARule(OLCompose, [@(1, eT), @(2, Induction)],\n e -> [Inductor(@(2).val.N, @(1).val.base, @(2).val.op, @(2).val.initval)]),\n PointWise_ISumUnion := ARule(OLCompose, [ @(1, PointWise), @(2, ISumUnion) ],\n e -> [ CopyFields(@(2).val, rec(\n _children := List(@(2).val._children, c -> OLCompose(@(1).val, c)),\n dimensions := [Rows(@(1).val), Cols(@(2).val)] )) ]),\n\n PointWise := ARule(OLCompose, [@(1, PointWise, e->Length(Collect(e.op.expr, e.op.vars[1]))=0), ...],\n e -> [@(1).val])\n));\n\n\n\n\n\nClass(RulesSumsHCOL, RuleSet, rec(inType := \"SigmaSPL\", outType := \"SigmaSPL\"));\nRewriteRules(RulesSumsHCOL, rec(\n OLCompose_Assoc := ARule(OLCompose, [ @(1,OLCompose) ], e -> @(1).val.children() ),\n OLCompose_PointWise_PointWise := ARule(OLCompose, [ @(1, PointWise), @(2, PointWise) ], \n e -> [ PointWise(@(1).val.N, Lambda(@(2).val.op.vars, SubstVars(Copy(@(1).val.op.expr), \n rec((@(1).val.op.vars[2].id) := @(2).val.op.vars[2], (@(1).val.op.vars[1].id) := @(2).val.op.expr)))) ]),\n PointWise_ISumUnion := ARule(OLCompose, [ @(1, PointWise), @(2, ISumUnion) ],\n e -> [ CopyFields(@(2).val, rec(\n _children := List(@(2).val._children, c -> OLCompose(@(1).val, c)),\n dimensions := [Rows(@(1).val), Cols(@(2).val)] )) ]),\n PointWise_ScatHUnion := ARule(OLCompose, [@(1,PointWise), @(2, ScatHUnion)],\n e -> let(i := Ind(@(2).val.dims()[2]), [@(2).val, PointWise(@(2).val.dims()[2], \n Lambda([@(1).val.op.vars[1], i], SubstVars(@(1).val.op.expr, rec((@(1).val.op.vars[2].id) := i*@(2).val.stride+@(2).val.base))))])),\n Reduction_ISumReduction := ARule(OLCompose, [ @(1, Reduction), @(2, ISumUnion) ],\n e -> [ ISumReduction(@(2).val.var, @(2).val.domain, @(1).val.op, @(1).val.idval, @(1).val.isSaturated,\n OLCompose(@(1).val, @(2).val._children[1]))]),\n Reduction_ScatHUnion := ARule(OLCompose, [ @(1, Reduction), @(2, ScatHUnion, e->e.n=1) ], e->[]),\n ISumReduction_PointWise := ARule(OLCompose, [ @(1, ISumReduction), @(2, PointWise) ],\n e -> [ ISumReduction(@(1).val.var, @(1).val.domain, @(1).val.op, @(1).val.idval, @(1).val.isSaturated,\n OLCompose(@(1).val._children[1], @(2).val))]),\n eT_Pointwise := ARule(OLCompose, [@(1, eT, e->IsVar(e.base)), @(2, PointWise)], \n e -> let(i := Ind(1), \n [PointWise(1, Lambda(\n SubstVars(Copy(@(2).val.op.vars), rec((@(2).val.op.vars[2].id):=i)),\n SubstVars(Copy(@(2).val.op.expr), rec((@(2).val.op.vars[2].id):=@(1).val.base)))), @(1).val])),\n ISumXXX_YYY := ARule(OLCompose, [ @(1, [ISumUnion, ISumReduction]), @(2, [GathH, PointWise, Induction, eT]) ],\n e -> [ CopyFields(@(1).val, rec(\n _children := List(@(1).val._children, c -> OLCompose(c, @(2).val)),\n dimensions := [Rows(@(1).val), Cols(@(2).val)] )) ]),\n GathH_GathH := ARule(OLCompose, [@(1, GathH), @(2, GathH)],\n e -> [GathH(@(2).val.N, @(1).val.n, @(1).val.base+@(2).val.base, @(1).val.stride*@(2).val.stride)]),\n PointWise_BinOp := ARule(OLCompose, [@(1, PointWise, e->e.N=1), @(2, BinOp, e->e.N=1)],\n e -> [BinOp(1,Lambda(@(2).val.op.vars, @(1).val.op.at(@(2).val.op.expr, V(0))))]),\n eT_Induction := ARule(OLCompose, [@(1, eT), @(2, Induction)],\n e -> [Inductor(@(2).val.N, @(1).val.base, @(2).val.op, @(2).val.initval)]),\n ScatHUnion_ScatHUnion := ARule(OLCompose, [@(1, ScatHUnion), @(2, ScatHUnion)], \n e -> [ScatHUnion(@1.val.N, @(2).val.n, @(1).val.base+@(2).val.base, @(2).val.stride)] )\n));\n\nClass(ToVectors, HierarchicalVisitor, rec(\n __call__ := meth(arg)\n local res;\n res := ApplyFunc(arg[1].visit, arg{[2..Length(arg)]});\n return res;\n end,\n PointWise := (self, o, opts) >> let(\n new_i := Ind(4), new_var := var.fresh_t(\"r\", TReal), times := (o.N - Mod(o.N, 4))/4,\n DirectSum(\n List([0..times-1], i->PointWise(4, Lambda([new_var, new_i], new_var*i)) ),\n\tPointWise(Mod(o.N, 4), o.op)\n ) \n )\n));\n\nmax_value := var(\"max_val\", TReal);\nmax_err := var(\"max_err\", TReal);\nClass(RulesErrorHCOL, RuleSet, rec(inType := \"iCode\", outType := \"iCode\"));\nRewriteRules(RulesErrorHCOL, rec(\n assign_const := Rule([@(1, assign), @(2, var), @(3, Value, v->v<>0)], \n\t\t\t\t\te->assign(@(2).val, @(3).val+@(3).val*max_err) ),\n assign_nth := Rule([@(1, assign), @(2, var), @(3, nth)], \n\t\t\t\t\te->assign(@(2).val, max_value+max_value*max_err) )\n));\n\n\nClass(RulesCodeHCOL, RuleSet, rec(inType := \"iCode\", outType := \"iCode\"));\nRewriteRules(RulesCodeHCOL, rec(\n#only assignments to state but state is not used\n\n\tsimplify_state := Rule(@@(1, decl, (e, cx)->(\n\t let(\n\t Length(Collect(e.cmd, decl))=0 and \n\t IsBound(cx.opts.state) and\t \n\t Length(Collect(e.cmd, @(1,nth).cond(j->IsVar(j.loc) and j.loc.id=cx.opts.state.id))) > 0 and \n\t Length(Collect(e.cmd, @(1,nth).cond(j->IsVar(j.loc) and j.loc.id=cx.opts.state.id)))=Length(Collect(e.cmd, @(1, assign).cond(i->ObjId(i.loc)=nth and i.loc.loc.id = cx.opts.state.id))) ))),\n\t (e, cx)-> let(Print(\"Remove State:\\n\", @@(1).val, \"\\n\"), SubstTopDown(@@(1).val, [@(2, assign), @(3, nth).cond(i->i.loc.id=cx.opts.state.id), @(4)], j->skip()))),\t\n\n chain_chain := Rule(@(1, chain, e->ObjId(e.cmds[1])=chain), \n e -> let(chain(Concat(@(1).val.cmds[1].cmds, Drop(@(1).val.cmds, 1))))),\n\n\t#replaces TArray of length one with a scalar variable\n scalarize1 := Rule(@(1, decl, e->Length(Filtered(e.vars, i->ObjId(i.t)=TArray and i.t.size=1))>=1),\n e->let(\t\t\t\t\t\t\t\n\t\t\toldvar := Filtered(e.vars, i->ObjId(i.t)=TArray and i.t.size=1)[1], \n\t\t\tPrint(\"Scalarizing \", oldvar, \"\\n\"),\n\t\t\n\t\t\ttmp := Collect(@(1).val, [@(5, assign), @(6).cond(ee->IsNth(ee) and ee.loc.id=oldvar.id), @(7)]),\n\t\t\tnewType := UnifyTypes(List(tmp, i->i.exp.t)),\n\t\t\tnewvar := var.fresh_t(\"s\", newType),\n\t\t\tPrint(\"Scalarizing \", oldvar, \" with \", newvar, \" of type: \", newType, \"\\n\"),\n\t\t\t\n\t\t\n decl(\n SubstVars(@(1).val.vars, rec((oldvar.id):=newvar)),\n SubstTopDown(@(1).val.cmd, [@(2, nth), @(3).cond(e->IsVar(e) and e.id=oldvar.id), @(4).cond(e->IsValue(e) and e.v = 0)],\n i->newvar) \n ))),\n\n\t#replace each fixed index array reference (i.e. nth(X, i), where i is a constant value) with a variable\n\t#This can only be done if there are no array references to X that is variable (this is to prevent potential aliasing)\n scalarize_const := Rule(@(1, decl, e->Length(Filtered(Filtered(e.vars, j->IsArray(j.t)), k->ForAll(Collect(e.cmd, [@(2, nth), @(3, var, u->u.id=k.id), @(4)]), j->IsValue(j.idx))))>=1),\n e->let(\n\t\t\toldvar := Filtered(Filtered(e.vars, j->IsArray(j.t)), #find all array variables\n\t k->ForAll(Collect(e.cmd, [@(2, nth), @(3, var, u->u.id=k.id), @(4)]), j->IsValue(j.idx)))[1], #make sure only const index\n\t\t\t \t\t\t\n newvars := List([1..oldvar.t.size], j->var.fresh_t(\"q\", oldvar.t.t)), \n cmmd := @(1).val.cmd,\n lst := List([0..Length(newvars)-1], i->[i, newvars[i+1]]),\n f := (c,l)->SubstTopDown(c, [@(2, nth), @(3).cond(k->IsVar(k) and k.id=oldvar.id), @(4).cond(j->IsValue(j) and j.v = l[1])], i->l[2]),\n Print(\"Scalarize_const: \",oldvar,\":: \", newvars, \"\\n\"),\n decl(Concat(Filtered(@(1).val.vars, j->j.id <> oldvar.id), newvars), FoldL(lst, f, cmmd))\n )),\n\t\t\n chain_xyz_chain := ARule(chain, [@(1), @(2, chain)], \n e->[chain(Concat([@(1).val], @(2).val.cmds))]),\n chain_chain_xyz := ARule(chain, [@(1, chain), @(2)], \n e->[chain(Concat(@(1).val.cmds), [@(2).val])]),\n\n chain_creturn := ARule(chain, [@(1, creturn), @(2)], \n e->[chain(Concat([@(2).val], [@(1).val]))] ),\n\n loop_pull_cond_1 := Rule([@(1, loop), @(2), @(3), [@(4, chain), [@(5, assign), @(6,var), \n [@(7,cond), @(8,eq, e->e.args[1]=@(2).val and e.args[2].v=0), @(9), @(10)]],...]],\n e->let(\n\t chain(assign(@(6).val, @(9).val), loop(@(1).val.var, @(1).val.range, chain([assign(@(6).val, @(10).val)]::Drop(@(4).val.cmds,1)))))),\n\n\t copyprop_var_val := Rule(@(1, decl, e->let(\n\t\t #only propagate values if the variable is SSA and only if it is within a basic block\n\t\t cnds := Collect(e.cmd, [assign, @(2, var, ee->ee in e.vars), @(3, Value)]),\n\t\t actual_cnds := Filtered(cnds, i->Length(Collect(e.cmd, [assign, @(8, var, ee->ee.id = i.loc.id), @(9)]))=1),\n\t\t #Print(\"CopyProp: \", cnds, \"\\n\\n\", e.cmd, \"\\n\\n\", actual_cnds, \"\\n\"),\n\t\t Length(actual_cnds) >= 1 and Length(Collect(e.cmd, [assign, @(4, var, ee->ee.id = actual_cnds[1].loc.id), @(5)]))=1)),\n\t\te->let(\t\t\t\n\t\t\tall_assigned_value := Collect(@(1).val.cmd, [assign, @(6, var, ee->ee in e.vars), @(7, Value)]),\n\t\t\tassigned_var_value := Filtered(all_assigned_value, i->Length(Collect(@(1).val.cmd, [assign, @(8, var, ee->ee.id = i.loc.id), @(9)]))=1)[1],\n\t\t #Print(\"CopyProp_value: \", assigned_var_value, \"\\n\"),\n\t\t\tdecl(Filtered(@(1).val.vars, j->j.id<>assigned_var_value.loc.id), \n\t\t\t\t SubstVars(@(1).val.cmd, rec((assigned_var_value.loc.id) := assigned_var_value.exp)))\n\t\t)\n ),\n\n\t copyprop_var_var := Rule(@(1, decl, e->let(\n\t\t #only propagate var if the assigned variable is SSA\n cnds := Collect(e.cmd, [assign, @(2, var, ee->ee in e.vars), @(3, var, e->e.id<>@(2).val.id)]),\n Length(cnds)>=1 and cnds[1].loc in e.vars and Length(Collect(e.cmd, [assign, @(4, var, ee->ee.id=cnds[1].loc.id), @(5)]))=1)), \n e->let(\t\t\t\t\n\t\t\t acnds := Collect(@(1).val.cmd, [assign, @(7, var, ee->ee in e.vars), @(8, var, e->e.id<>@(7).val.id)]), \n\t\t\t atests := Collect(e.cmd, [assign, @(9, var, ee->ee.id=acnds[1].loc.id), @(5)]),\n\t\t\t a := atests[1],\n\t\t\t decl(Filtered(@(1).val.vars, j->j <>a.loc), SubstVars(@(1).val.cmd, rec((a.loc.id) := a.exp))))),\n\n drop_selfassign_var := ARule(chain, [@(1, assign, e->IsVar(e.loc) and IsVar(e.exp) and e.exp=e.loc), @(2)], \n e->let(\n\t\t[@(2).val])), \n\t\n drop_selfassign2 := ARule(chain, [@(1, assign, e->e.exp=e.loc), @(2)], \n e->[@(2).val]), \n\n\t\n\t#this drops unused variables i.e. variables that are declared but not used.\n drop_unused_var := Rule(@(1, decl, e-> let(v := Collect(e.cmd, var), Filtered(e.vars, k->not k in v))<> []),\n e->let(v := Collect(@(1).val.cmd, var), \n decl(Filtered(@(1).val.vars, k->k in v), @(1).val.cmd))),\n\n\tdrop_unused_assign := Rule(@(1, decl, e->\n\t\t\tFiltered(List(e.vars, v->Collect(e.cmd, v)), l->Length(l)=1)<>[]) , \n\te->let(\n unused := Filtered(List(e.vars, v->Collect(e.cmd, v)), l->Length(l)=1)[1],\n\t empty_list := List([1..Length(unused)], i->skip()),\n\t target_list := Filtered(Collect(@(1).val.cmd, assign), a->a.loc in unused),\n\t Print(\"Unused assignements:\\n\", target_list, \"\\n\\n\"),\t \n\t decl(Filtered(@(1).val.vars, k->not k in unused), SubstList(@(1).val.cmd, target_list, empty_list))\n\t)),\t\t\t\n\t\t\t\n loop_decl := Rule(@(1, loop, e->ObjId(e.cmd)=decl and Length(Collect(e.cmd, decl))=1 and Length(Collect(e.cmd, chain))<=1), \n e -> decl(@(1).val.cmd.vars, loop(@(1).val.var, @(1).val.range, @(1).val.cmd.cmd))),\n\n chain_xyz_decl := ARule(chain, [@(1), @(2, decl)], \n e->[decl(@(2).val.vars, chain(@(1).val, @(2).val.cmd))]),\n\n chain_decl := Rule(@(1, chain, e->ObjId(e.cmds[1])=decl), \n e -> decl(@(1).val.cmds[1].vars, chain(Concat([@(1).val.cmds[1].cmd], Drop(@(1).val.cmds, 1))))),\n decl_decl := Rule(@(1, decl, e->ObjId(e.cmd)=decl), \n e -> decl(Set(Concat(@(1).val.vars, @(1).val.cmd.vars)), @(1).val.cmd.cmd)),\n));\n\n\nClass(RulesHCOLnoAbsMax, RuleSet, rec(inType := \"iCode\", outType := \"iCode\"));\nRewriteRules(RulesHCOLnoAbsMax, rec(\n abs_cond := Rule([@(1, assign), @(2), @(3, abs)], \n e->let(s := var.fresh_t(\"w\", @(3).val.t), decl(s, chain(assign(s, @(3).val.args[1]), assign(@(1).val.loc, cond(geq(s, V(0)), s, neg(s))))))),\n max_cond := Rule(@(1, max), \n e->cond(geq(@(1).val.args[1], @(1).val.args[2]), @(1).val.args[1], @(1).val.args[2])),\n));\n\nClass(RulesUnrollHCOL, RuleSet, RulesStrengthReduce, RulesCodeHCOL, rec(inType := \"iCode\", outType := \"iCode\"));\nRewriteRules(RulesUnrollHCOL, rec(\n unroll_wo_decl := Rule(@@(1, [loopn, loop], \n (e, cx) -> Length(Collect(e.cmd, loop))=0 and\n Length(Collect(e.cmd, decl))=0 and\n\t e.var.range <= When(IsBound(cx.opts) and IsBound(cx.opts.globalUnrolling),\n\t\t \t cx.opts.globalUnrolling,\n 5)),\n (e,cx)->let(i := @@(1).val.var, \n\t rng := @@(1).val.range, \n\t\t vvars := Filtered(Collect(@@(1).val.cmd, var), j->j.t in [TReal, TDouble]),\n\n chain(\t \n\t List(rng, j->let( \n\t\t ssvars := FoldL([[i, V(j)]], (b, a)->CopyFields(rec((a[1].id):= a[2]), b), rec()),\n\t\t new_cmd := SubstVars(Copy(@@(1).val.cmd), ssvars),\n \t\t new_cmd )) \n ))) ,\t\t\t \n unroll_w_decl := Rule(@@(1, [loop, loopn], \n (e,cx)->Length(Collect(e.cmd, loop))=0 and \n\t\t\t\t Length(Collect(e.cmd, decl))=1 and\n\t e.var.range <= When(IsBound(cx.opts) and IsBound(cx.opts.globalUnrolling),\n \t cx.opts.globalUnrolling,\n 5)),\n (e,cx)->let(i := @@(1).val.var, \n\t rng := @@(1).val.range, \n\t\t vvars := Filtered(Collect(@@(1).val.cmd, var), j->j.t in [TReal, TDouble]),\n\t\t \n\t\t localvar := Collect(@@(1).val.cmd, decl)[1].vars, \n\n chain(\t \n\t List(rng, j->let( \n\n\t \t\t nvars :=FoldL(localvar, (b,a)->Concat([[a, var.fresh_t(\"u\", a.t)]], b), [[i, V(j)]] ),\n\t \t\t ssvars := FoldL(nvars, (b, a)->CopyFields(rec((a[1].id):= a[2]) , b), rec()),\n\t\t\t\t\t\tsvars := FoldL(nvars, (b, a)->Concat( When(IsVar(a[2]) or a[2] in b, [a[2]], []), b), []),\n\n\t\t\t\tnew_cmd := SubstVars(Copy(@@(1).val.cmd.cmd), ssvars),\n\n\t\t\t\tdecl(svars, new_cmd) )\n\n #decl(svars, new_cmd ) )\n ))\n\t )\n )\t\n));\n\nRewriteRules(RulesStrengthReduce, rec(\n\taddsub00 := Rule([@(1, addsub_2x64f), @(2).cond(e->Cond(IsValue(e), isValueZero(e), e=0)), _0], \n\t\te->@(2).val)\n));\n\nClass(RulesUnifyType, RuleSet, rec(inType := \"iCode\", outType := \"iCode\"));\nRewriteRules(RulesUnifyType, rec(\n unify_value := Rule(@(1,assign, e-> IsValue(e.exp) and IsVar(e.loc) and e.loc.t <> e.exp.t),\n e->let(\n newtype := UnifyTypes([@(1).val.exp.t, e.loc.t]),\n Print(\"Unifying Type from a value to \", newtype,\"\\n\"),\n #if the newtype is the same as the loc, then need to cast the value\n #else error, upcast the type of the variable since we are losing info.\n Cond(newtype=e.loc.t, \n assign(@(1).val.loc, tcast(newtype, @(1).val.exp)),\n let(\n update_type(@(1).val.loc, newtype),\n assign(@(1).val.loc, @(1).val.exp)\n ))\n )),\n\tunify_vartype := Rule(@(1,assign,e->IsVar(e.loc) and not IsValue(e.exp) and e.loc.t <> e.exp.computeType()),\n\t e->let(\n\t\t oldtype := @(1).val.exp.t,\n\t\t newtype := @(1).val.exp.computeType(),\n\t\t Print(\"Unifying Type from \", oldtype, \" to \", newtype,\"\\n\"),\n\t\t update_type(@(1).val.loc, newtype),\n\t\t assign(@(1).val.loc, @(1).val.exp)\n\t )),\n));\nRulesTypeHCOL := CopyFields(MergedRuleSet(RulesUnifyType), \n rec(inType:=\"iCode\", outType := \"iCode\"));\n\n\n\nRulesOrigCodeUnrollHCOL := CopyFields(MergedRuleSet(RulesUnrollHCOL, RulesStrengthReduce, RulesCodeHCOL, RulesHCOLnoAbsMax), \n rec(inType:=\"iCode\", outType := \"iCode\"));\n\n\nRulesCodeUnrollHCOL := CopyFields(MergedRuleSet( RulesUnrollHCOL, RulesStrengthReduce, RulesCodeHCOL, RulesHCOLnoAbsMax), \n rec(inType:=\"iCode\", outType := \"iCode\"));\n\n\nRulesCodeNoUnrollHCOL := CopyFields(MergedRuleSet(RulesStrengthReduce, RulesCodeHCOL, RulesHCOLnoAbsMax), \n rec(inType:=\"iCode\", outType := \"iCode\"));\n\n#changes behaviour so that Spiral outputs abs(a) and max(a,b) C-code instead of \"(a >= b) ? a : b\"\nRulesCodeUnrollHCOLuseAbsMaxSR := CopyFields(MergedRuleSet(RulesUnrollHCOL, RulesStrengthReduce, RulesCodeHCOL), \n rec(inType:=\"iCode\", outType := \"iCode\"));\n\n", "meta": {"hexsha": "6b5c1fd06dd8e0a44214f42eb890206305b862d7", "size": 23665, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "rewrite.gi", "max_stars_repo_name": "spiral-software/spiral-package-hcol", "max_stars_repo_head_hexsha": "b4a0118382e3bba91ecd82a6c667f2cdb6389ceb", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "rewrite.gi", "max_issues_repo_name": "spiral-software/spiral-package-hcol", "max_issues_repo_head_hexsha": "b4a0118382e3bba91ecd82a6c667f2cdb6389ceb", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "rewrite.gi", "max_forks_repo_name": "spiral-software/spiral-package-hcol", "max_forks_repo_head_hexsha": "b4a0118382e3bba91ecd82a6c667f2cdb6389ceb", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-11-26T05:21:02.000Z", "max_forks_repo_forks_event_max_datetime": "2019-11-26T05:21:02.000Z", "avg_line_length": 53.5407239819, "max_line_length": 191, "alphanum_fraction": 0.544897528, "num_tokens": 8085, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.44552953503957277, "lm_q2_score": 0.033589508431438486, "lm_q1q2_score": 0.014965118073666598}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\n# Higher-order functions support\n#\n\n# Functional expression base class\nClass(FuncExp, Exp, rec(\n isFuncExp := true,\n\n at := arg >> let(\n\tself := arg[1],\n\tCond(Length(arg)=2 and IsList(arg[2]), \n\t ApplyFunc(fcall, [self] :: arg[2]),\n\t ApplyFunc(fcall, arg))),\n\n mkVars := self >> \n List(DropLast(self.computeType().params, 1), x->var.fresh_t(\"q\", x)),\n\n getRankType := (self, r) >> let(\n\tt := self.computeType(),\n\trank := Length(t.params)-2,\n\tCond(r > rank,\n\t TDummy, \n\t t.params[ Length(t.params) - 1 - r ])\n )\n));\n\nFunction.mkVars := FuncExp.mkVars;\nFunction.getRankType := FuncExp.getRankType;\n\nSymbolic.mkVars := FuncExp.mkVars;\nSymbolic.getRankType := FuncExp.getRankType;\n\nIsFuncExp := o -> IsRec(o) and \n ((IsBound(o.isFuncExp) and o.isFuncExp) or (IsBound(o.t) and ObjId(o.t)=TFunc));\n\n# Same as IsFuncExp(<o>) but returns false for param's with t = TFunc \n# (these are considered 'trivial')\nIsNonTrivFuncExp := o -> IsRec(o) and (IsBound(o.isFuncExp) and o.isFuncExp);\n\n\n# !!! Below is no longer needed/used, autolib handles this via Parametrizer\n# These are hacks for dealing with types which are integers like 2\n# these really mean the range of an integer variable\n# _convType converts 2 to TInt not to confuse other parts of the system\n#\n\n# !!! Below is no longer needed/used, autolib handles this via Parametrizer\n#_convType := t -> Cond(IsSymbolic(t) or IsInt(t) or IsValue(t), TInt, \n# SubstBottomUp(Copy(t), TFunc, \n# e -> ApplyFunc(TFunc, List(e.params, p -> When(IsInt(p) or IsSymbolic(p) or IsValue(p), TInt, p)))));\n_convType := t->t; \n\n# !!! Below is no longer needed/used, autolib handles this via Parametrizer\n#_convTypeExp := t -> \n# SubstBottomUp(Copy(t), TFunc, \n# e -> ApplyFunc(TFunc, List(e.params, p -> When(IsInt(p) or IsSymbolic(p) or IsValue(p), TInt, p))));\n_convTypeExp := t->t;\n\n\n#F fcurry(<func>, <pos>, <arg>) - symbolic representation of function currying\n#F Given a function with n arguments returns a functino with n-1 arguments\n#F where <arg> is plugged into position <pos> \n#F\n#F Example: p := param(TFunc(TInt, 4, TComplex), \"p\"); # ie. rank-1 4-elt diagonal func\n#F i1 := Ind(4);\n#F fcurry(p, 1, i1).t; \n#F => TFunc(4, TComplex);\n#F\nClass(fcurry, FuncExp, rec(\n computeType := self >> let(\n n := self.args[2],\n ct := self.args[1].computeType(), \n Checked(IsValue(n), ObjId(ct)=TFunc, n.v < Length(ct.params),\n ApplyFunc(TFunc, ListWithout(ct.params, n.v)))),\n\n eval := self >> let(\n torig := self.args[1].t.params, \n tcurried := self.t.params,\n n := self.args[2].v,\n vars := List([1..Length(tcurried)-1], i -> var.fresh_t(\"q\", tcurried[i])),\n plugin := List([1..Length(torig)-1], i -> Cond(i<n, vars[i], i=n, self.args[3],vars[i-1])),\n Lambda(vars, ApplyFunc(fcall, Concatenation([self.args[1].eval()], plugin)))),\n\n at := (self, i) >> self.eval().at(i)\n));\n\n#F flift(<func>, <t>) - symbolic representation of function \"lifting\"\n#F\n#F Given a function with n arguments returns a function with n+1 arguments,\n#F extra argument is of type <t> and is the \"one but last\" argument of new function.\n#F It is the ignored when computing the value of the function.\n#F\n#F The purpose of flift is to increase the rank of functions. It implicitly creates\n#F a new inner loop, which loop variable is ignored. This is needed for rewrite rules\n#F like GT(T, ..) * Gath(f) -> GT(T*Gath(f), ...), where f is pulled into the loop.\n#F\nClass(flift, FuncExp, rec(\n computeType := self >> let(ct := self.args[1].computeType(), Checked(\n ObjId(ct)=TFunc, IsType(self.args[2]),\n let(tt := ct.params, n := Length(tt), \n ApplyFunc(TFunc, Concatenation(tt{[1..n-2]}, [self.args[2]], tt{[n-1..n]}))))), \n\n # NOTE: define what exactly .lambda() does in these cases\n lambda := self >> self.eval(),\n\n eval := self >> let(vars := List(DropLast(self.t.params,1), x->var.fresh_t(\"q\", x)), n := Length(vars),\n Lambda(vars, ApplyFunc(fcall, Concatenation([self.args[1].eval()], ListWithout(vars, n-1)))))\n));\n\n#F fsplit(<func>, <loopid>, <inner_its>, <outer_its>)\nClass(fsplit, FuncExp, rec(\n computeType := self >> let(ct := self.args[1].computeType(), Checked(\n ObjId(ct)=TFunc, IsValue(self.args[2]), self.args[2].t=TInt, \n let(tt := ct.params, loopid := self.args[2].v, pos := Length(tt)-1-loopid,\n ApplyFunc(TFunc, Concatenation(tt{[1..pos-1]}, [tt[pos], tt[pos]], tt{[pos+1..Length(tt)]}))))),\n\n # NOTE: define what exactly .lambda() does in these cases\n lambda := self >> self.eval(),\n\n eval := self >> let(\n vars := List(DropLast(self.computeType().params, 1), x->var.fresh_t(\"q\", x)),\n loopid := self.args[2].v,\n inner_its := self.args[3], \n pos := Length(vars)-loopid,\n callargs := vars{[1..pos-2]} :: \n\t Cond(vars[pos].t=TDummy, [0], [inner_its * vars[pos-1] + vars[pos]]) ::\n vars{[pos+1..Length(vars)]},\n Lambda(vars, ApplyFunc(fcall, Concatenation([self.args[1].eval()], callargs))))\n));\n\n#F frotate(<func>, <n>)\n#F switch the order of loops (=ranks), by making <n>-th loop innermost\nClass(frotate, FuncExp, rec(\n computeType := self >> let(ct := self.args[1].computeType(), nn := self.args[2], Checked(\n ObjId(ct)=TFunc, IsValue(nn), nn.t=TInt, \n\tlet(tt := ct.params, rank := Length(tt)-2, n := nn.v, pos := rank+1-n, \n Cond(rank=0 or (rank=1 and n=1), ct,\n\t\t n > rank, \n\t\t ApplyFunc(TFunc, tt{[1..rank]} :: [TDummy] :: [tt[rank+1], tt[rank+2]]),\n\t\t # else \n ApplyFunc(TFunc, tt{[1..pos-1]} :: tt{[pos+1..rank]} :: [tt[pos], tt[rank+1], tt[rank+2]]))))),\n\n # NOTE: define what exactly .lambda() does in these cases\n lambda := self >> self.eval(),\n\n eval := self >> let(f := self.args[1], rank := f.rank(), n := self.args[2].v, pos := rank+1-n, \n\tCond(rank=0 or (rank=1 and n=1), f,\n\t n > rank, \n let(vars := List(DropLast(self.computeType().params, 1), x->var.fresh_t(\"q\", x)),\n\t\t Lambda(vars, ApplyFunc(fcall, [f] :: vars{[Length(vars)-1-rank..Length(vars)-2]} :: [Last(vars)]))),\n\t # else\n let(vars := List(DropLast(self.computeType().params, 1), x->var.fresh_t(\"q\", x)),\n\t\t Lambda(vars, ApplyFunc(fcall, [f] :: vars{[1..pos-1]} :: [vars[rank]] :: vars{[pos..rank-1]} :: [vars[rank+1]])))\n\t))\n));\n\n\n## Ranked functions support\n## Ranked functions == functions with implicit dependencies on loop variables\n##\n## These are used in paradigms.common.GT and autolib.*\n##\n## NOTE: get rid of _, these functions are not private, but public exports\n##\n_rankManip := (obj, newfunc) >> \n SubstTopDownNR(Copy(obj), @.cond(e->IsFunction(e) or IsFuncExp(e)), e -> newfunc(e));\n\n_rank := o -> Cond(\n IsList(o), Maximum0(List(o, _rank)),\n not IsRec(o) or not IsBound(o.rank), 0, o.rank());\n_upRank := o -> Cond(\n IsList(o), List(o, _upRank),\n not IsRec(o) or not IsBound(o.upRank), o, o.upRank());\n_upRankNeq0 := o -> Cond(\n IsList(o), List(o, _upRankNeq0),\n not IsRec(o) or not IsBound(o.upRank) or o.rank()=0, o, o.upRank());\n_upRankBy := (o,n) -> Cond(IsList(o), # NOTE: =0 ??\n List(o, x->_upRankBy(x,n)),\n not IsRec(o) or not IsBound(o.upRankBy) or o.rank()=0, o, o.upRankBy(n));\n_downRank := (o,loopid,ind) -> Cond(\n IsList(o), List(o, x->_downRank(x, loopid, ind)),\n not IsRec(o) or not IsBound(o.downRank), o, o.downRank(loopid, ind));\n_downRankFull := (o,inds) -> Cond(\n IsList(o), List(o, x->_downRankFull(x, inds)),\n not IsRec(o) or not IsBound(o.downRankFull), o, o.downRankFull(inds));\n_split := (o, loopid, iits, oits) -> Cond(\n IsList(o), List(o, x->_split(x, loopid, iits, oits)), \n not IsRec(o) or not IsBound(o.split), o, o.split(loopid, iits, oits));\n_rotate := (o, n) -> Cond(\n IsList(o), List(o, x->_rotate(x, n)), \n not IsRec(o) or not IsBound(o.rotate), o, o.rotate(n)); \n\n\n_rch_rank := self >> Maximum0(List(self.rChildren(), _rank));\n_rch_upRank := self >> self.from_rChildren(List(self.rChildren(), _upRank));\n_rch_upRankBy := (self, n) >> self.from_rChildren(List(self.rChildren(), c->_upRankBy(c,n)));\n_rch_downRank := (self, loopid, ind) >> \n self.from_rChildren(List(self.rChildren(), c->_downRank(c,loopid,ind)));\n_rch_downRankFull := (self, inds) >> \n self.from_rChildren(List(self.rChildren(), c->_downRankFull(c,inds)));\n_rch_split := (self, loopid, iits, oits) >> \n self.from_rChildren(List(self.rChildren(), c->_split(c,loopid, iits, oits)));\n_rch_rotate := (self, n) >> \n self.from_rChildren(List(self.rChildren(), c->_rotate(c, n))); \n\n\nSymbolic.domain := self >> Checked(ObjId(self.t)=TFunc, Length(self.t.params) > 1, \n self.computeType().params[Length(self.t.params)-1]);\n\nSymbolic.range := self >> Checked(ObjId(self.t)=TFunc, Length(self.t.params) > 1,\n self.computeType().params[Length(self.t.params)]);\n \nSymbolic.rank := self >> Cond(ObjId(self.t)=TFunc and Length(self.t.params) > 1,\n Length(self.t.params) - 2, \n _rch_rank(self));\n\nSymbolic.at := (self, vars) >> Checked(ObjId(self.t)=TFunc, self.lambda().at(vars));\n\nSymbolic.lambda := self >> Checked(ObjId(self.t)=TFunc, let(\n selft := self.computeType(), \n vars := List([1..self.rank()+1], x -> let(t:=selft.params[x], \n Cond(IsType(t), var.fresh_t(\"w\", t), var.fresh(\"w\", TInt, t)))),\n Lambda(vars, ApplyFunc(fcall, Concatenation([self], vars)))));\n\nSymbolic.upRank := self >> Cond(ObjId(self.t)<>TFunc, _rch_upRank(self), flift(self, TDummy));\n\nSymbolic.upRankBy := (self, n) >> Cond(\n ObjId(self.t)<>TFunc, _rch_upRankBy(self,n), \n Checked(IsPosInt0(n), FoldL([1..n], (f, i) -> f.upRank(), self)));\n\nSymbolic.downRankFull := (self, inds) >> Cond(\n ObjId(self.t)<>TFunc, _rch_downRankFull(self, inds), \n FoldL(Reversed([1..Minimum(self.rank(), Length(inds))]), (f, i) -> f.downRank(i, inds[i]), self));\n\nSymbolic.downRank := (self, loopid, ind) >> let(rank := self.rank(), Cond(\n loopid > rank, self, \n ObjId(self.t)<>TFunc, _rch_downRank(self, loopid, ind),\n fcurry(self, rank+1-loopid, ind))); # !! loop variables are ordered with decreasing rank, highest-rank (outermost) is first var\n\nSymbolic.split := (self, loopid, inner_its, outer_its) >> Cond(\n loopid > self.rank(), self, \n ObjId(self.t)<>TFunc, _rch_split(self, loopid, inner_its, outer_its),\n fsplit(self, loopid, inner_its, outer_its));\n\nSymbolic.rotate := (self, n) >> Cond(\n self.rank() <= 1 and n <= 1, self, \n ObjId(self.t)<>TFunc, _rch_rotate(self, n), \n frotate(self, n)); \n\n\n# NOTE: below is really a hack, since the first argument might also have ranked\n# things, although this is not obvious at first glance, an example of such first\n# argument would be fcurry(func, lambdaWrap(rank-n function))\n\nfcall.rank := self >> Cond(ObjId(self.t)=TFunc and Length(self.t.params) > 1,\n Length(self.t.params) - 2, \n _rank(Drop(self.args, 1)));\n\nfcall.upRank := self >> Cond(ObjId(self.t)<>TFunc, \n ApplyFunc(fcall, [self.args[1]] :: _upRank(Drop(self.args, 1))), \n flift(self, TDummy));\n\nfcall.upRankBy := (self, n) >> Cond(ObjId(self.t)<>TFunc, \n ApplyFunc(fcall, [self.args[1]] :: _upRankBy(Drop(self.args, 1), n)),\n Checked(IsPosInt0(n), FoldL([1..n], (f, i) -> f.upRank(), self)));\n\nfcall.downRankFull := (self, inds) >> Cond(ObjId(self.t)<>TFunc, \n ApplyFunc(fcall, [self.args[1]] :: _downRankFull(Drop(self.args, 1), inds)),\n FoldL(Reversed([1..Minimum(self.rank(), Length(inds))]), (f, i) -> f.downRank(i, inds[i]), self));\n\nfcall.downRank := (self, loopid, ind) >> let(rank := self.rank(), Cond(\n loopid > rank, self, \n ObjId(self.t) <> TFunc, \n ApplyFunc(fcall, [self.args[1]] :: _downRank(Drop(self.args, 1), loopid, ind)), \n # else\n fcurry(self, rank+1-loopid, ind))); # !! loop variables are ordered with decreasing rank, highest-rank (outermost) is first var\n\nfcall.split := (self, loopid, inner_its, outer_its) >> Cond(\n loopid > self.rank(), self, \n ObjId(self.t) <> TFunc, \n ApplyFunc(fcall, [self.args[1]] :: _split(Drop(self.args, 1), loopid, inner_its, outer_its)),\n fsplit(self, loopid, inner_its, outer_its));\n\nfcall.rotate := (self, n) >> Cond(\n self.rank() <= 1 and n <= 1, self,\n ObjId(self.t) <> TFunc, \n ApplyFunc(fcall, [self.args[1]] :: _rotate(Drop(self.args, 1), n)),\n frotate(self, n)); \n\n\nFunction.rank := _rch_rank;\nFunction.upRank := _rch_upRank;\nFunction.upRankBy := _rch_upRankBy;\nFunction.downRank := _rch_downRank;\nFunction.downRankFull := _rch_downRankFull;\nFunction.split := _rch_split;\nFunction.rotate := _rch_rotate;\nFunction.computeType := self >> self.lambda().t;\n\nLambda.rank := Symbolic.rank; \nLambda.upRank := Symbolic.upRank;\nLambda.upRankBy := Symbolic.upRankBy;\n#Lambda.downRank := Symbolic.downRank; downRank now defined in lambda.gi\nLambda.downRankFull := Symbolic.downRankFull;\nLambda.split := Symbolic.split;\nLambda.rotate := Symbolic.rotate;\n\n# ind(<range>, <n>) - \"nameless\" reference to a loop index of n-th inner most loop\n# (eg. ind(1) is inner most, ind(n) is outermost in n-loop nest)\n# loop counter runs from 0..range-1\nClass(ind, Loc, rec(\n __call__ := (self, range, n) >> Checked(IsInt(n),\n\tWithBases(self, rec(operations := ExpOps, range:=range, n:=n))),\n print := self >> Print(self.name, \"(\", self.range, \", \", self.n, \")\"),\n rChildren := self >> [self.range, self.n],\n rSetChild := rSetChildFields(\"range\", \"n\"),\n t := TInt,\n eval := self >> self,\n can_fold := False,\n \n upRank := self >> ObjId(self)(self.range, self.n+1),\n\n split := (self, loopid, inner_its, outer_its) >> \n Cond( loopid > self.n, self, \n loopid < self.n, ObjId(self)(self.range, self.n+1), \n ObjId(self)(inner_its, self.n) + inner_its*ObjId(self)(outer_its, self.n+1)),\n rotate := (self, n) >> \n Cond( n < self.n, self, \n n > self.n, ObjId(self)(self.range, self.n+1), \n ObjId(self)(self.range, 1)),\n\n));\n\n\n# NOTE: ind.downRank might be a hack\nind.downRankFull := (self, inds) >> inds[self.n];\nind.downRank := (self, loopid, ind) >> Cond(loopid=self.n, ind, self);\nind.rank := self >> self.n;\n\n\n_hofnew := true;\n# ExpMarkActiveRank(<s>)\n# performs a recursive walk over <s> and sets ._expMarkActiveRank attribute to the \"active rank\"\n# of each subexpression.\n#\n# Active rank of an expression denotes the maximum implicit loop id that the expression refers to.\n# Implicit loop id's are introduced by objects such as GT and Lambda.\n#\nExpMarkActiveRank := function(s)\n local c, rch, rank;\n rch := Cond(IsRec(s) and IsBound(s.rChildren), s.rChildren(), IsList(s) and not IsString(s), s, []);\n if ObjId(s) = ind then\n rank := s.n;\n else\n\tif _hofnew then\n\t rank := _rank(s); \n\t DoForAll(rch, ExpMarkActiveRank);\n\telse\n# this was invalid (fcurry, fcall, etc) -> \n\t rank := Maximum(_rank(s), Maximum0(List(rch, ExpMarkActiveRank))); \n\tfi;\n fi;\n\n if IsRec(s) and IsSymbolic(s) then s._expMarkActiveRank := rank; fi;\n return rank;\nend;\n\n_ExpMarkPassiveRank := function(s, parent_rank) \n local c, rch, rank, my_rank;\n rch := Cond(IsRec(s) and IsBound(s.rChildren), s.rChildren(), IsList(s) and not IsString(s), s, []);\n my_rank := _rank(s);\n\n # NOTE: this is a terrible hack! WHAT ABOUT Lambda?\n if spiral.paradigms.common.IsGT(s) then rank := my_rank + parent_rank;\n elif ObjId(s)=ind then rank := Maximum(parent_rank, s.n);\n else rank := Maximum(parent_rank, my_rank);\n fi;\n if IsRec(s) and (IsSymbolic(s) or IsFuncExp(s)) then s._expMarkPassiveRank := rank; fi;\n\n DoForAll(rch, x -> _ExpMarkPassiveRank(x, rank)); \n return rank;\nend;\n# ExpMarkPassiveRank(<s>)\n# performs a recursive walk over <s> and sets ._expMarkPassiveRank attribute to the \"passive rank\"\n# of each subexpression.\n#\n# Passive rank of an expression denotes the maximum implicit loop id that is defined in the expression.\n# Regardless of whether expression refers to it or now. In contracst, an \"active rank\" is the loop id\n# that is actually referred to.\n#\n# Implicit loop id's are introduced by objects such as GT and Lambda.\n#\nExpMarkPassiveRank := s -> _ExpMarkPassiveRank(s, 0);\n\n\nClass(lambdaWrap, Exp, rec(\n computeType := self >> Checked(ObjId(self.args[1].t) = TFunc, Last(self.args[1].t.params))\n));\n", "meta": {"hexsha": "59aab908b4300843aab88cdca901ae2118199ed4", "size": 16674, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/code/hof.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/code/hof.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/code/hof.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 41.3746898263, "max_line_length": 132, "alphanum_fraction": 0.6240854024, "num_tokens": 5104, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4455295350395727, "lm_q2_score": 0.03358950698030741, "lm_q1q2_score": 0.014965117427144842}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\nDeclare(TPrmMulti,CodeBlock);\nIsTwoPower := i >> 2 ^ Log2Int(i) = i;\n\nget_l_power := function(t,exp)\n local p;\n if (exp=0) then\n p := L(2^t,1);\n else\n p:= L(2^t,2^(t-exp));\n fi;\n return p; \nend;\n\n# Declaration of SortBase, a 2x2 sorter.\nClass(SortBase, BaseMat, rec(\n abbrevs := [()-> []],\n new := (self) >> SPL( WithBases(self, rec()) ).setDims(),\n dims := self >> [ 2, 2 ],\n isReal := True,\n sums := self >> self,\n rChildren := self >> [],\n rSetChild := rSetChildFields(),\n toAMat := self >> Error(\"not supported\"),\n transpose := self >> self,\n));\n\n# Declaration of SortBase, a 1x1 sorter.\nClass(SortBase_w1, BaseMat, rec(\n abbrevs := [(a)-> [a]],\n new := (self, a) >> SPL( WithBases(self, rec(dimensions:=[1,1], a := a))),\n print := (self, i, is) >> Print(self.name, \"(\", self.a, \")\"),\n dims := self >> [ 1, 1 ],\n isReal := True,\n sums := self >> self,\n rChildren := self >> [self.a],\n rSetChild := rSetChildFields(\"a\"),\n toAMat := self >> Error(\"not supported\"),\n transpose := self >> self,\n));\n\nClass(SortConfigBase_w1, BaseMat, rec(\n abbrevs := [(a)-> [a] , (b)-> [b]],\n new := (self, a, b) >> SPL( WithBases(self, rec(dimensions:=[1,1], a := a, b:=b))),\n print := (self, i, is) >> Print(self.name, \"(\", self.a, \",\", self.b, \")\"),\n dims := self >> [ 1, 1 ],\n isReal := True,\n sums := self >> self,\n rChildren := self >> [self.a, self.b],\n rSetChild := rSetChildFields(\"a\",\"b\"),\n toAMat := self >> Error(\"not supported\"),\n transpose := self >> self,\n));\n\n# Declaration of SortConfigBase, a 2x2 Configurable sorter.\nClass(SortConfigBase, BaseMat, rec(\n abbrevs := [(a)-> [a]],\n new := (self, a) >> SPL( WithBases(self, rec(dimensions:=[2,2], a := a))),\n print := (self, i, is) >> Print(self.name, \"(\", self.a, \")\"),\n dims := self >> [ 2, 2 ],\n isReal := True,\n sums := self >> self,\n rChildren := self >> [self.a],\n rSetChild := rSetChildFields(\"a\"),\n toAMat := self >> Error(\"not supported\"),\n transpose := self >> self,\n));\n\n# Declaration of SortLinearBase, used for linear sorter with w = 1\nClass(LinearSortBase, BaseMat, rec(\n abbrevs := [()-> []],\n new := (self) >> SPL( WithBases(self, rec()) ).setDims(),\n dims := self >> [ 2, 2 ],\n isReal := True,\n sums := self >> self,\n rChildren := self >> [],\n rSetChild := rSetChildFields(),\n toAMat := self >> Error(\"not supported\"),\n transpose := self >> self,\n));\n\n\n\n#taken from: .../spiral/compiler/dag.gi\nregassign.op_in := self >> ConcatList(self.loc.rChildren(), ArgsExp) :: ArgsExp(self.exp);\nregassign.op_out := self >> [self.loc];\nregassign.op_inout := self >> [];\nregassign.getNoScalar := self >> When(IsBound(self.exp.getNoScalar), self.exp.getNoScalar(), []);\n\n# This tells Spiral how to translate 'SortBase' into code.\nHDLCodegen.SortBase := (self, o, y, x, opts) >>\n chain(\n\tassign(nth(y,0), cond(leq(nth(x,0), nth(x,1)), nth(x,0), nth(x,1))), \n\tassign(nth(y,1), cond(leq(nth(x,0), nth(x,1)), nth(x,1), nth(x,0)))\n ); \n\nHDLCodegen.SortBase_w1 := (self, o, y, x, opts) >>\n let(\n t0 := TempVar(x.t.t),\n t1 := TempVar(x.t.t),\n t3 := TempVar(x.t.t),\n t5 := TempVar(x.t.t),\n t6 := TempVar(x.t.t),\n\n chain(\n\tassign(t3, imod(o.a, 2)),\n\tregassign(t0, cond(t3, t0, nth(x,0))),\n\tassign(t5, cond(leq(t0, nth(x,0)), nth(x,0), t0)),\n\tassign(t6, cond(leq(t0, nth(x,0)), t0, nth(x,0))),\n\tregassign(t1, cond(t3, t5, t1)),\n\tassign(nth(y,0), cond(t3, t6, t1))\n )\n );\n\nHDLCodegen.SortConfigBase_w1 := (self, o, y, x, opts) >>\n let(\n t0 := TempVar(x.t.t),\n t1 := TempVar(x.t.t),\n t3 := TempVar(x.t.t),\n t5 := TempVar(x.t.t),\n t6 := TempVar(x.t.t),\n t7 := TempVar(x.t.t),\n t8 := TempVar(x.t.t),\n t9 := TempVar(x.t.t),\n t10 := TempVar(x.t.t),\n t2 := TempVar(x.t.t),\n\n chain(\n\tassign(t3, imod(o.a, 2)),\n\tregassign(t0, cond(t3, t0, nth(x,0))),\n\tassign(t7, eq(o.b,0)),\n\tassign(t8, eq(o.b,1)),\n\t\t\n\tassign(t2, leq(t0, nth(x,0))),\n\tassign(t9, cond(t2, t0, nth(x,0))),\n\tassign(t10, cond(t2, nth(x,0), t0)),\n\tassign(t5, cond(t7, nth(x,0) , t8, t9, t10)),\n\tassign(t6, cond(t7, t0 , t8, t10, t9)),\n\t\n\tregassign(t1, cond(t3, t5, t1)),\n\tassign(nth(y,0), cond(t3, t6, t1))\n )\n );\n\nHDLCodegen.LinearSortBase := (self, o, y, x, opts) >>\n let(\n #x[1] indicates the start of a new list. When x[1] equals 1, y[0] \n #is set to the value of the register t0, and t0 is set to the value of x[0]\n\n t0 := TempVar(x.t.t),\n t1 := TempVar(x.t.t),\n t2 := TempVar(x.t.t),\n t3 := TempVar(x.t.t),\n t4 := TempVar(x.t.t),\n t5 := TempVar(x.t.t),\n r0 := TempVar(x.t.t),\n x0 := TempVar(x.t.t),\n x1 := TempVar(x.t.t),\n \n chain(\n\n\t assign(x0, nth(x,0)),\n\t assign(x1, nth(x,1)),\n\t assign(t3, eq(x1, 1)),\n\t regassign(r0, cond(t3, x0, t1)),\n\t #regassign(r0, t0),\n\t assign(t4, leq(r0, x0)),\n\t assign(t1, cond(t4, x0, r0)),\n\t assign(t2, cond(t4, r0, x0)),\n\t assign(nth(y, 0), cond(t3, r0, t2)),\n\t #regassign(t5, x1),\n\t assign(nth(y, 1), x1)\n )\n );\n\n# HDLCodegen.LinearSortBase := (self, o, y, x, opts) >>\n# let(\n# t0 := TempVar(x.t.t),\n# #x[1] indicates the start of a new list. When x[1] equals 1, y[0] \n# #is set to the value of the register t0, and t0 is set to the value of x[0]\n# chain(\n# \tassign(nth(y,0),cond(eq(nth(x,1),1),t0,leq(t0, nth(x,0)),t0,nth(x,0))),\n# \tregassign(t0,cond(eq(nth(x,1),1),nth(x,0),leq(t0, nth(x,0)),nth(x,0),t0)),\n# \tassign(nth(y,1),nth(x,1))\n# )\n# );\n\nHDLCodegen.SortConfigBase := (self, o, y, x, opts) >>\n let(\n\tt0 := TempVar(x.t.t),\n\tt1 := TempVar(x.t.t),\n\tt2 := TempVar(x.t.t),\n\tt3 := TempVar(x.t.t),\n\tchain(\n\t assign(t2, nth(x,0)),\n\t assign(t3, nth(x,1)),\n\t assign(t0, cond(leq(t2, t3), t2, t3)), \n\t assign(t1, cond(leq(t2, t3), t3, t2)),\t \n\t assign(nth(y,0), cond(eq(o.a,0), t2, eq(o.a,1), t1, t0)),\n\t assign(nth(y,1), cond(eq(o.a,0), t3, eq(o.a,1), t0, t1))\n\t)\n ); \n\n\n# Declaration of a sorter of size n\nClass(Sort, TaggedNonTerminal, rec(\n abbrevs := [\n (n) -> Checked(IsPosIntSym(n), [_unwrap(n)]),\n ],\n\n hashAs := self >> ObjId(self)(self.params[1]).withTags(self.getTags()),\n\n dims := self >> [ self.params[1], self.params[1] ],\n\n terminate := self >> Error(\"not supported\"), # we could probably support this\n));\n\n\n# SortIJPerm(n): DirectSum(I(n/2), J(n/2))\n# We do this so we can define a .permBits() function.\n# This will let us easily generate large-size hardware implementations.\n\n# (If we do not do this, the perm tool will have to manually compute the \n# bit matrix representation, which will include making an n-times-n matrix.\nClass(SortIJPerm, PermClass, rec(\n def := (n) -> Checked(\n IsPosIntSym(n),\n rec(size := n)),\n\n lambda := self >> let(\n n := self.params[1],\n\tfDirsum(fId(n/2), J(n/2)).lambda()\n ),\n\n transpose := self >> self,\n isSymmetric := self >> true,\n\n permBits := meth(self)\n local n, k, a, b, tmp, i;\n\tn := self.params[1];\n\tk := LogInt(n, 2);\n\ta := [List([1..k], i->0)];\n\tfor i in [1 .. k-1] do\t \n\t tmp := Concatenation([1], List([1..k-1], i->0));\n\t Append(a, [tmp]);\n od;\n\ta := a * GF(2).one;\n\tb := MatSPL(I(k))*GF(2).one;\n\t\n\treturn (a+b);\n end, \n));\n\n\n\n\n# Rule to breakdown Sort(n), where n is a power of two.\nNewRulesFor(Sort, rec(\n Sort_Stream := rec(\n info := \"Streaming sorting network\",\n\n applicable := nt -> Length(nt.params) = 1 and IsTwoPower(nt.params[1]),\n\n children := (self, nt) >> let(\n\n\t tag_w_tmp := nt.tags[1],\n\t tag_w := tag_w_tmp.bs,\n\t t := Log2Int(nt.params[1]),\n\t p := Ind(2^t),\n\t get_bb := w -> Cond(w=1, TTensorInd(SortBase_w1(p), p, APar, APar),TTensorI(SortBase(), 2^(t-1), APar, APar)),\n\n\t [[ TCompose(\n\t [TCompose(List([1..t-1], i ->\n\t TCompose([\n\t\t #TTensorI(SortBase(), 2^(t-1), APar, APar), \n\t\t get_bb(tag_w), \n\t\t TCompose(List([2..(t-i+1)], j -> \n\t\t TCompose([\n\t\t\t TTensorI(TPrm(Tensor(I(2), L(2^(j-1), 2^(j-2))) * L(2^j,2)), 2^(t-j), APar, APar),\n\t\t\t get_bb(tag_w)\n\t\t\t #TTensorI(SortBase(), 2^(t-1), APar, APar)\n\t\t\t ])\n\t\t )),\n\t\t # TTensorI(TPrm(L(2^(t-i+1), 2^(t-i)) * DirectSum(I(2^(t-i)), J(2^(t-i))) ), 2^(i-1), APar, APar) \n\t\t\t TTensorI(TPrm(L(2^(t-i+1), 2^(t-i)) * SortIJPerm(2^(t-i+1))), 2^(i-1), APar, APar)\n\t\t ])\n\t )),\t\t\n\t\t get_bb(tag_w)] \n\t\t #TTensorI(SortBase(), 2^(t-1), APar, APar)] \n ).withTags(nt.getTags())\n ]]\n\t),\n\n apply := (nt, c, cnt) -> c[1],\n\n ),\n \n Sort_Stream6 := rec(\n info := \"Version of Sort_Stream (sortAlg1) removing J permutations and with configurable 2-input sorters\",\n\n applicable := nt -> Length(nt.params) = 1 and IsTwoPower(nt.params[1]),\n\n children := (self, nt) >> let(\n\t t := Log2Int(nt.params[1]),\n k := Ind(2^(t-1)),\n z := (s) >> t-s,\n\n c1 := (s) >> logic_and(eq(bit_sel(k, z(s)), 1), neq(s, 1)),\n access_f := (s) >> cond(c1(s), 1, 2),\n\n\t [[ TCompose(\n\t [TCompose(List([1..t-1], i ->\n\t TCompose([\n\t\t\t TTensorInd(SortConfigBase(access_f(i)), k, APar, APar),\n\t\t TCompose(List([2..(t-i+1)], j -> \n\t\t TCompose([\n\t\t\t TTensorI(TPrm(Tensor(I(2), L(2^(j-1), 2^(j-2))) * L(2^j,2)), 2^(t-j), APar, APar),\n\t\t\t TTensorInd(SortConfigBase(access_f(i)), k, APar, APar)\n\t\t\t ])\n\t\t )),\n\t\t TTensorI(TPrm(L(2^(t-i+1), 2^(t-i))), 2^(i-1), APar, APar) \n\t\t ])\n\t )),\t\t\n\t\t TTensorInd(SortConfigBase(access_f(t)), k, APar, APar)]\n\t\t #TTensorI(SortBase(), 2^(t-1), APar, APar)] #what is this line?\n ).withTags(nt.getTags())\n ]]\n\t),\n\n apply := (nt, c, cnt) -> c[1],\n\n ),\n\n Sort_Stream_Iter := rec(\n info := \"Stream/Iter sorting network\",\n\n\tdepth_params := [],\n\n applicable := (self, nt) >> Length(nt.params) = 1 and IsTwoPower(nt.params[1]) and\n\t Length(self.depth_params) = Log2Int(nt.params[1])-1 and\t\t\t \n\t\t\t\t let(\n\t\t\t\t\t t := Log2Int(nt.params[1]),\n\t\t\t\t\t d := self.depth_params,\n\t\t\t\t ForAll(List([1..t-1], i -> IsInt((t-i+1)/d[i])), j -> j)\n\t\t\t\t ),\n\n\n children := (self, nt) >> let(\n \t t := Log2Int(nt.params[1]),\n\n\t tag_w_tmp := nt.tags[1],\n\t tag_w := tag_w_tmp.bs,\n\t p := Ind(2^t),\n\n\t get_bb := w -> Cond(w=1, TTensorInd(SortBase_w1(p), p, APar, APar),TTensorI(SortBase(), 2^(t-1), APar, APar)),\n\n\t stage := i >> TCompose([\n\t\t\t get_bb(tag_w),\n\t\t\t #TTensorI(SortBase(), 2^(t-1), APar, APar),\n\t\t\t TTensorI(TPrm(L(2^(t-i+1), 2^(t-i))) , 2^(i-1), APar, APar)\n\t\t\t ]),\n\n\t full_stage := i >> TCompose(List([1..self.depth_params[i]], j2 -> stage(i))), \n\n \t [[ TCompose(\n\t [TCompose(List([1..t-1], i -> let(\n\t\t j := Ind(t-i+1),\n\t\t d := self.depth_params[i],\n\t\t j1 := Ind(d),\n\t\t j2 := Ind((t-i+1)/d),\n\t TCompose([\n\t\t\t Cond(d = ((t-i+1)),\n full_stage(i), \n\t\t\t\tTCompose(List([1..d],j1 -> \n\t\t\t\tTICompose(j2, (t-i+1)/d, stage(i))\n\t\t\t\t)) \n\t\t\t ),\n\t\t \t #TTensorI(TPrm(DirectSum(I(2^(t-i)), J(2^(t-i)))), 2^(i-1), APar, APar)\n\t\t \t TTensorI(TPrm(SortIJPerm(2^(t-i+1))), 2^(i-1), APar, APar)\n\t\t ])\n\t ))),\n\t\t get_bb(tag_w)] #last iterations left outside of TCompose\n\t\t #TTensorI(SortBase(), 2^(t-1), APar, APar)] #last iterations left outside of TCompose\n ).withTags(nt.getTags())\n ]]\n\t),\n\n apply := (nt, c, cnt) -> c[1],\n\n ),\n \n #old version -works-\n# Sort_Stream_Iter := rec(\n# info := \"Stream/Iter sorting network\",\n#\n#\tdepth_params := [],\n#\n# applicable := (self, nt) >> Length(nt.params) = 1 and IsTwoPower(nt.params[1]) and\n#\t Length(self.depth_params) = Log2Int(nt.params[1])-1 and\t\t\t \n#\t\t\t\t let(\n#\t\t\t\t\t t := Log2Int(nt.params[1]),\n#\t\t\t\t\t d := self.depth_params,\n#\t\t\t\t ForAll(List([1..t-1], i -> IsInt((t-i+1)/d[i])), j -> j)\n#\t\t\t\t ),\n#\n#\n# children := (self, nt) >> let(\n# \t t := Log2Int(nt.params[1]),\n#\n#\t stage := i >> TCompose([\n#\t\t\t TTensorI(SortBase(), 2^(t-1), APar, APar),\n#\t\t\t TTensorI(TPrm(L(2^(t-i+1), 2^(t-i))) , 2^(i-1), APar, APar)\n#\t\t\t ]),\n#\n#\t full_stage := i >> TCompose(List([1..self.depth_params[i]], j2 -> stage(i))),\n#\n#\n# \t [[ TCompose(\n#\t [TCompose(List([1..t-1], i -> let(\n#\t\t j := Ind(t-i+1),\n#\t\t d := self.depth_params[i],\n#\t\t j1 := Ind((t-i+1)/d),\n#\t TCompose([\n#\t\t\t Cond(j1.range = 1,\n#\t\t\t full_stage(i),\n#\t\t\t TICompose(j1, (t-i+1)/d, full_stage(i))\n#\t\t\t ),\n#\t\t \t TTensorI(TPrm(DirectSum(I(2^(t-i)), J(2^(t-i)))), 2^(i-1), APar, APar)\n#\t\t ])\n#\t ))),\n#\t\t TTensorI(SortBase(), 2^(t-1), APar, APar)]\n# ).withTags(nt.getTags())\n# ]]\n#\t),\n#\n# apply := (nt, c, cnt) -> c[1],\n#\n# ),\n \n Sort_Stream5 := rec(\n info := \"Version of Sort_Stream_Iter (sortAlg2) removing J permutations and with configurable 2-input sorters\",\n\n\tdepth_params := [],\n\n applicable := (self, nt) >> Length(nt.params) = 1 and IsTwoPower(nt.params[1]) and\n\t Length(self.depth_params) = Log2Int(nt.params[1])-1 and\t\t\t \n\t\t\t\t let(\n\t\t\t\t\t t := Log2Int(nt.params[1]),\n\t\t\t\t\t d := self.depth_params,\n\t\t\t\t ForAll(List([1..t-1], i -> IsInt((t-i+1)/d[i])), j -> j)\n\t\t\t\t ),\n\n\n children := (self, nt) >> let(\n \t t := Log2Int(nt.params[1]),\n\t k := Ind(2^(t-1)),\n\t z := (s) >> t-s,\n\n\t c1 := (s) >> logic_and(eq(bit_sel(k, z(s)), 1), neq(s, 1)),\n\t access_f := (s) >> cond(c1(s), 1, 2),\n\t \n\t stage := i >> TCompose([\n\t\t\t TTensorInd(SortConfigBase(access_f(i)), k, APar, APar),\n\t\t\t TTensorI(TPrm(L(2^(t-i+1), 2^(t-i))) , 2^(i-1), APar, APar)\n\t\t\t ]),\n\n\t full_stage := i >> TCompose(List([1..self.depth_params[i]], j2 -> stage(i))), \n\n \t [[ TCompose(\n\t [TCompose(List([1..t-1], i -> let(\n\t\t j := Ind(t-i+1),\n\t\t d := self.depth_params[i],\n\t\t j1 := Ind(d),\n\t\t j2 := Ind((t-i+1)/d),\n\t\t Cond(d = ((t-i+1)),\n full_stage(i), \n\t\t\t\tTCompose(List([1..d],j1 -> \n\t\t\t\tTICompose(j2, (t-i+1)/d, stage(i))\n\t\t\t\t)) \n\t\t\t #unroll this change to TCompose\n\t\t\t)\n\t ))),\n\t\t TTensorInd(SortConfigBase(access_f(t)), k, APar, APar)] #last iterations left outside of TCompose\n ).withTags(nt.getTags())\n ]]\n\t),\n\n apply := (nt, c, cnt) -> c[1],\n\n ),\n\n Sort_Stream3 := rec(\n info := \"\",\n\t\n\tdepth_out := 1,\n depth_in := [],\n\n applicable := (self, nt) >> Length(nt.params) = 1 and IsTwoPower(nt.params[1]) and\n\t\t\t \t Length(self.depth_in) = Log2Int(nt.params[1])-1 and\n\t\t\t\t let(\n t := Log2Int(nt.params[1]), d_out := self.depth_out,\n d_in := self.depth_in, IsInt(t/d_out) and ((d_out=1) or ((d_out=t) and \n \t (ForAll(List([1..t-1], i -> IsInt((t-i+1)/d_in[i])), j -> j))))\n ),\n\n children := (self, nt) >> let(\n\t d_out := self.depth_out, \n\t d_in := self.depth_in,\n t := Log2Int(nt.params[1]),\n\t k := Ind(2^(t-1)),\n\t iter_d1 := Ind(t),\n\n z := (lp, jp) >> (t-1)-(lp+jp),\n c2 := (lp, jp) >> logic_and(eq(bit_sel(k, z(lp, jp)), 1), neq(lp, 0)),\n access_f := (lp, jp) >> cond(c2(lp, jp), 1, 2),\n stage := (lp, jp) >> TCompose([\n TTensorInd(SortConfigBase(access_f(lp, jp)), k, APar, APar),\n TPrm(L(2^t, 2^(t-1)))\n ]),\n\t full_stage := i >> TCompose(List([0..d_in[i+1]-1], j -> stage(i,j))),\n\t [[ Cond(d_out=1,\n\t\t\tTICompose(iter_d1,t,let(\n\t\t\t\titer_d2 := Ind(t-iter_d1),\n\t \t\t\tp_list := List([0..t-1], i-> get_l_power(t,i)),\n\t\t\t\tTCompose([\n\t\t\t\t\tTICompose(iter_d2,t-iter_d1, stage(iter_d1,iter_d2)),\n\t\t \t \t\tTPrmMulti(p_list,iter_d1)\n\t\t\t\t])\t\n\t\t\t)).withTags(nt.getTags()),\n\t\t d_out=t,\n\t\t\tTCompose([\n\t\t\t\tTCompose(List([0..t-2], iter_d3 -> let(\n\t\t\t\t d_stage := d_in[iter_d3+1],\t\n \t\t\t iter_d5 := Ind((t-iter_d3)/d_stage),\n\t\t\t\t TCompose([\n\t\t\t\t\tCond(d_stage=(t-iter_d3),\n\t\t\t\t\t\tfull_stage(iter_d3),\n\t\t\t\t\t\tTCompose(List([0..d_stage-1],iter_d4 ->\n\t\t\t\t\t\t TICompose(iter_d5,(t-iter_d3)/d_stage,stage(iter_d3,iter_d4*iter_d5))))\n\t\t\t\t\t),\n\t\t\t\t\tget_l_power(t,iter_d3)\n\t\t\t\t ])\n\t\t\t\t))),\n\t\t\t\tstage(t-1,0),\n\t\t\t\tget_l_power(t,t-1)\n\t\t\t]).withTags(nt.getTags())\t\n\t )]]\n\t\t\n\t),\n apply := (nt, c, cnt) -> c[1],\n ),\n\n Sort_Stream4 := rec(\n info := \"\",\n\n\tdepth := 1,\n\n applicable := (self, nt) >> Length(nt.params) = 1 and IsTwoPower(nt.params[1]) and\n\t let (d := self.depth, t := Log2Int(nt.params[1]), IsInt(t*t/self.depth) and\n\t\t\t\t (IsInt(d/t) or IsInt(t/d))),\n\n children := (self, nt) >> let(\n \t t := Log2Int(nt.params[1]),\n\t d := self.depth,\n\t d1 := cond(leq(d,t), d, t).ev(),\n\t d2 := cond(leq(d,t), 1, d/t).ev(), \n\n\t k := Ind(2^(t-1)),\n\t j := Ind(t),\n\t l := Ind(t),\n\t n := Ind(t/d2),\n\t v := Ind(t/d1),\n\t \n d_tmp := cond(leq(d,t), t/d, 0).ev(),\n d2_tmp := cond(leq(t,d), d/t, 0).ev(),\n\t s_tmp := ((t*t)/d),\n m2 := Ind(d_tmp),\n\t s2 := Ind(s_tmp),\n\t v2 := Ind(d2_tmp),\n\t n2 := Ind(d),\n\t n3 := Ind(d),\n\t l2 := Ind(t),\n\t \n\t tag_w_tmp := nt.tags[1],\n\t tag_w := tag_w_tmp.bs,\n\t p := Ind(2^t),\n\n \n\t c1 := (lp, jp) >> lt((t-1), (lp+jp)),\n\t z := (lp, jp) >> (t-1)-(lp+jp),\n\t z_w1 := (lp, jp) >> (t-1)-(lp+jp)+1,\n\t c2 := (lp, jp) >> logic_and(eq(bit_sel(k, z(lp, jp)), 1), neq(lp, 0)),\n\t c2_w1 := (lp, jp) >> logic_and(eq(bit_sel(p, z_w1(lp, jp)), 1), neq(lp, 0)),\n\t \t \n\t access_f := (lp, jp) >> cond(c1(lp, jp), 0, c2(lp, jp), 1, 2),\n\t access_f_w1 := (lp, jp) >> cond(c1(lp, jp), 0, c2_w1(lp, jp), 1, 2),\n\t \n\t get_bb := (lp,jp) -> Cond(tag_w=1, TTensorInd(SortConfigBase_w1(p,access_f_w1(lp,jp)), p, APar, APar),TTensorInd(SortConfigBase(access_f(lp, jp)), k, APar, APar)),\n\n\t stage := (lp, jp) >> TCompose([\n\t\t get_bb(lp, jp),\n\t\t #TTensorInd(SortConfigBase(access_f(lp, jp)), k, APar, APar),\n\t\t TPrm(L(2^t, 2^(t-1)))\n\t ]),\n\n\t full_stage := np_1 >> TCompose(List([0..t-1], m_1 -> TCompose(List([0..t-1], j_1 -> stage(m_1, j_1))))),\n\t full_stage1 := np >> TCompose(List([0..d2-1], m -> TCompose(List([0..t-1], j -> stage(d2*np+m, j))))),\n\t full_stage2 := vp >> TCompose(List([0..d1-1], s -> stage(l, vp+s))),\n full_stage1b := np2 >> TICompose(m2,d_tmp, TICompose(j,t, stage((t/d)*np2+m2, j))),\n\n # Old: problem is that it's assuming the l2 above, which is an unassigned iterator. \n\t # There is also a problem with the vp2+s2 parameter: you need to multiply vp2 by the number of iterations.\n # full_stage2b := (vp2) >> TICompose(s2,s_tmp, stage(l2, vp2+s2)),\n full_stage2b := (vp2, l3) >> TICompose(s2,s_tmp, stage(l3, vp2*s_tmp+s2)),\n\t\n \t [[ Cond(d=t*t, full_stage(0).withTags(nt.getTags()),\t\t\n\t\t d<t, TCompose(List([0..d-1], n2 -> full_stage1b(n2))).withTags(nt.getTags()),\n d=t, TCompose(List([0..d-1], n3 -> full_stage1b(n3))).withTags(nt.getTags()),\n d>t, TCompose(List([0..t-1], l3 -> TCompose(List([0..d2_tmp-1], v2 -> full_stage2b(v2, l3))))).withTags(nt.getTags())) #the problem seems to be the outer most TCompose works if it was TICompose\t\t \n\t\t #d>t, TICompose(n, t/d2, full_stage1(n)).withTags(nt.getTags())) #old one but will leave it as new one does not work yet\n\t ]]\n\t),\n\t\n#\tOld version -works-\n#\t Sort_Stream4 := rec(\n# info := \"\",\n#\n#\tdepth := 1,\n#\n# applicable := (self, nt) >> Length(nt.params) = 1 and IsTwoPower(nt.params[1]) and\n#\t let (d := self.depth, t := Log2Int(nt.params[1]), IsInt(t*t/self.depth) and\n#\t\t\t\t (IsInt(d/t) or IsInt(t/d))),\n#\n#\n# children := (self, nt) >> let(\n# \t t := Log2Int(nt.params[1]),\n#\t d := self.depth,\n#\t d1 := cond(leq(d,t), d, t).ev(),\n#\t d2 := cond(leq(d,t), 1, d/t).ev(), \n#\n#\t k := Ind(2^(t-1)),\n#\t j := Ind(t),\n#\t l := Ind(t),\n#\t n := Ind(t/d2),\n#\t v := Ind(t/d1),\n#\t \n#\t \n#\t c1 := (lp, jp) >> lt((t-1), (lp+jp)),\n#\t z := (lp, jp) >> (t-1)-(lp+jp),\n#\t c2 := (lp, jp) >> logic_and(eq(bit_sel(k, z(lp, jp)), 1), neq(lp, 0)),\n#\t \t \n#\t access_f := (lp, jp) >> cond(c1(lp, jp), 0, c2(lp, jp), 1, 2),\n#\t \n#\t stage := (lp, jp) >> TCompose([\n#\t\t TTensorInd(SortConfigBase(access_f(lp, jp)), k, APar, APar),\n#\t\t TPrm(L(2^t, 2^(t-1)))\n#\t ]),\n#\n#\t full_stage1 := np >> TCompose(List([0..d2-1], m -> TCompose(List([0..t-1], j -> stage(d2*np+m, j))))),\n#\t full_stage2 := vp >> TCompose(List([0..d1-1], s -> stage(l, vp+s))),\n#\n# \t [[ Cond(d=t*t, full_stage1(0).withTags(nt.getTags()),\t\t\n#\t\t d>t, TICompose(n, t/d2, full_stage1(n)).withTags(nt.getTags()),\n#\t\t d<t, TICompose(l, t, TICompose(v, t/d1, full_stage2(d1*v))).withTags(nt.getTags()),\n#\t\t d=t, TICompose(l, t, full_stage2(0)).withTags(nt.getTags()))\n#\t ]]\n#\t),\n#\t\n# apply := (nt, c, cnt) -> c[1],\n# ),\n\n\t# this works, but only for d=1.\n# children := (self, nt) >> let(\n# \t t := Log2Int(nt.params[1]),\n# \t k := Ind(2^(t-1)),\n# \t l := Ind(t),\n# \t j := Ind(t),\n\t \n# \t c1 := lt((t-1), (l+j)),\n# \t z := (t-1)-(l+j),\n# \t c2 := logic_and(eq(bit_sel(k, z), 1), neq(l, 0)),\n\t \t \n# \t access_f := cond(c1, 0, c2, 1, 2),\n\t \n# \t d1 := cond(leq(d,t), d, t),\n# \t d2 := cond(leq(d,t), 1, d/t), \n\t \n# \t c1 := lt((t-1), (l+j)),\n# \t z := (t-1)-(l+j),\n# \t c2 := logic_and(eq(bit_sel(k, z), 1), neq(l, 0)),\n\t \t \n# \t access_f := cond(c1, 0, c2, 1, 2),\n\t \n# \t d1 := cond(leq(d,t), d, t),\n# \t d2 := cond(leq(d,t), 1, d/t), \n\n# \t [[ TICompose(l, t, \n# \t\t TICompose(j, t, TCompose([\n# \t\t TTensorInd(SortConfigBase(access_f), k, APar, APar),\n# \t\t TPrm(TL(2^t, 2^(t-1), 1, 1))\n# \t ]))).withTags(nt.getTags())\n# ]]\n# \t),\n\n apply := (nt, c, cnt) -> c[1],\n\n ),\n\n Linear_Sort := rec(\n info := \"\",\n\t\n applicable := (self, nt) >> IsTwoPower(nt.params[1]),\n\n children := (self, nt) >> let(\n t := Log2Int(nt.params[1]),\n\t [[ TCompose(List([1..2^t], i -> \n\t\tTTensorI(LinearSortBase(), nt.params[1], APar, APar)\n\t\t\t)).withTags(nt.getTags()),\n\t ]]\n\t\t\n\t),\n apply := (nt, c, cnt) -> c[1],\n ),\n\n));\t \n\n\n\n#---------------------------------------------------------------------\n#---------------------------------------------------------------------\n#---------------------------------------------------------------------\n# Old stuff, not used now\n\n\n# Sort_Stream_old := rec(\n# info := \"Streaming sorting network\",\n\n# switch := true,\n# applicable := nt ->\n# Length(nt.params) = 1 and IsTwoPower(nt.params[1]),\n\n# children := (self, nt) >> let(\n# \t t := Log2Int(nt.params[1]),\n# \t [[ TCompose(List([1..t], i ->\n# \t \tTCompose([\n# \t\t TTensorI(BitonicSort(2^(t-i+1)), 2^(i-1), APar, APar),\n# \t\t TTensorI(TPrm(DirectSum(I(2^(t-i)), J(2^(t-i)))), 2^(i-1), APar, APar)\n# \t\t])\n# )).withTags(nt.getTags())]]\n# ),\n\n# apply := (nt, c, cnt) -> c[1],\n\n# ),\n\n# Declaration of a bitonic sorter of size n\n# Class(BitonicSort, TaggedNonTerminal, rec(\n# abbrevs := [\n# (n) -> Checked(IsPosIntSym(n), [_unwrap(n)]),\n# ],\n\n# hashAs := self >> ObjId(self)(self.params[1]).withTags(self.getTags()),\n\n# dims := self >> [ self.params[1], self.params[1] ],\n\n# terminate := self >> Error(\"not supported\"), # we could probably support this\n# ));\n\n\n\n# Old stuff, not used now.\t\t \n# # Rules to break-down BitonicSort()\n# NewRulesFor(BitonicSort, rec(\n# BitonicSort_Stream := rec(\n# info := \"Streaming Bitonic sorting network\",\n\n# switch := true,\n# applicable := nt ->\n# Length(nt.params) = 1 and IsTwoPower(nt.params[1]) and nt.params[1] > 2,\n\n# children := (self, nt) >> let(\n# \t k := Log2Int(nt.params[1]),\n# \t [[ TCompose([ TTensorI(SortBase(), 2^(k-1), APar, APar),\n# \t\t TCompose(List([2..k], j -> TCompose([\n# \t\t TTensorI(TPrm(Tensor(I(2), L(2^(j-1), 2^(j-2))) * L(2^j, 2)), 2^(k-j), APar, APar),\n# \t\t TTensorI(SortBase(), 2^(k-1), APar, APar)\n# \t\t ]))),\n# \t\t TPrm(L(2^k, 2^(k-1)))\n# \t ]).withTags(nt.getTags())\n# \t ]]\n# ),\n\n# apply := (nt, c, cnt) -> c[1],\n# ),\n\n# BitonicSort_Base := rec(\n# \tinfo := \"Bitonic soring network base rule\",\n# \tapplicable := nt -> nt.params[1] = 2,\n# \tchldren := (self, nt) >> [[ ]],\n# \tapply := (nt, c, cnt) -> SortBase()\n# )\n\n# ));\t \n", "meta": {"hexsha": "853ea381761c4f9dcfb59da089a32c265540a5e6", "size": 25488, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/paradigms/stream/sort.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/paradigms/stream/sort.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/paradigms/stream/sort.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 31.5445544554, "max_line_length": 219, "alphanum_fraction": 0.4808929692, "num_tokens": 8666, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4571367316191468, "lm_q2_score": 0.03067579860909325, "lm_q1q2_score": 0.014023034315968057}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\nImport(search);\n\n# These functions merge multiple hashtables into a single one\nAllHashEntries := function(table)\n local e, i, res;\n res := [];\n for e in Filtered(table.entries, IsList) do\n for i in e do\n if i.data <> [] then Add(res, i); fi;\n od;\n od;\n return res;\nend;\n\n\nAddMergedHashTables := function(target, newhashs)\n local e, v, h, i;\n for e in Flat(List(newhashs, i->AllHashEntries(i))) do\n v := [];\n for h in newhashs do\n Add(v, HashLookup(h, e.key));\n od;\n v := Filtered(v, i -> i <> [] and i <> false);\n if v <> [] then\n Sort(v, (j,k) -> j[1].measured < k[1].measured);\n HashAdd(target, e.key, v[1]);\n fi;\n od;\nend;\n\n# Build all base cases for a given SIMD ISA.\n# Currently only L(2v, 2), L(2v, v), L(v^2, v)\n#\nSIMD_ISA_DB.buildBases := meth(self, isa)\n local rebind, t, v, tags, cxtags, t1, t2, rt, brules, common, rset1, rset2, tab1, tab2, e, h;\n\n if self.verbose then Print(\"Building bases for \", isa, \"\\n\"); fi;\n self.hash_rebuilt := true;\n v := isa.v;\n tags := isa.getTags();\n cxtags := isa.getTagsCx();\n\n # == do TL base cases======================================\n # TL usually is not measured in DP\n rebind := IsBound(TL.doNotMeasure) and TL.doNotMeasure;\n if rebind then \n TL.doNotMeasure := false; \n fi;\n\n brules := paradigms.tSPL_Globals.getDPOpts().breakdownRules;\n common := [ SIMD_ISA_Bases1, SIMD_ISA_Bases2, IxLxI_kmn_n, IxLxI_kmn_km, paradigms.vector.breakdown.IxLxI_vtensor ];\n\n rset1 := CopyFields(brules, rec(TL := Concat(common, [IxLxI_IxLxI_up])));\n rset2 := CopyFields(brules, rec(TL := Concat(common, [IxLxI_IxLxI_down])));\n\n tab1 := HashTableDP();\n for t in SIMD_ISA_DB.getBases(isa) do\n# [ TL(2*v,v,1,1).withTags(tags), TL(2*v,2,1,1).withTags(tags), TL(v*v,v,1,1).withTags(tags), TL(v*v/4,v/2,1,2).withTags(tags) ]\n t1 := DP(t, rec(measureFunction := VCost, verbosity := 0, hashTable := tab1, globalUnrolling := true),\n CopyFields(isa.splopts, rec(breakdownRules := rset1, dataType := \"no default\", baseHashes := [], globalUnrolling := 10000)));\n od;\n\n tab2 := HashTableDP();\n for t in SIMD_ISA_DB.getBases(isa) do\n# [ TL(2*v,v,1,1).withTags(tags), TL(2*v,2,1,1).withTags(tags), TL(v*v,v,1,1).withTags(tags), TL(v*v/4,v/2,1,2).withTags(tags) ]\n t2 := DP(t, rec(measureFunction := VCost, verbosity := 0, hashTable := tab2, globalUnrolling := false),\n CopyFields(isa.splopts, rec(breakdownRules := rset2, dataType := \"no default\", baseHashes := [], globalUnrolling := 10000)));\n od;\n AddMergedHashTables(self.hash, [tab1, tab2]);\n # restore TL\n if rebind then\n TL.doNotMeasure:=true;\n fi;\n\n # == do other base cases===================================\n # do other base cases\n #\n # none here yet :(\n #\n\n # == final check - did all work? ==========================\n for e in self.getBases(isa) do\n h := HashLookup(self.hash, e);\n if h=false or h=[] then Print(e, \" could not be built\\n\"); fi;\n od;\nend;\n", "meta": {"hexsha": "fc14c97c168a045435f1792ee1948b1dd1c0ef67", "size": 3225, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/paradigms/vector/bases/isa_db.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/paradigms/vector/bases/isa_db.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/paradigms/vector/bases/isa_db.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 35.0543478261, "max_line_length": 141, "alphanum_fraction": 0.5792248062, "num_tokens": 1017, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.396068180531364, "lm_q2_score": 0.03410042203124954, "lm_q1q2_score": 0.013506092109268647}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\nDeclare(TTensorI_OL);\nDeclare(TTensorI_OL_Vectorize_AVecLast);\n\n#Class(RewriteBarrier,RewritableObject);\n#Class(RewriteBarrier,DFT);\n#RewriteBarrier.numops:=self>>1;\n\nDropVectorTag:=function(nt)\n return nt.withoutTag(AVecReg); \n#D return SetTag(nt,Filtered(GetTags(nt),t->ObjId(t)<>AVecReg));\nend;\n\nDropParTag:=function(nt)\n return nt.withoutTag(AParSMP);\n#D return SetTag(nt,Filtered(GetTags(nt),t->ObjId(t)<>AParSMP));\nend;\n\nDevectorize:=function(l,vlen)\n return List(l,e->\n Cond(\n ObjId(e)=TArray and e.t=TUnknown, TArray(e.t,e.size*vlen),\n ObjId(e)=TArray and ObjId(e.t)=TVect, TArray(e.t.t,e.size*e.t.size),\n ObjId(e)=TVect, TArray(e.t,e.size),\n e)\n );\nend;\n\nClass(VTensor_OL, Tensor, rec(\n new := (self, L) >> SPL(WithBases(self, rec(\n _children := [L[1]],\n vlen := L[2]))),\n print := (self,i,is) >> Print(self.name, \"(\",\n self.child(1).print(i+is,is), \", \", self.vlen,\")\"),\n sums := self >> Inherit(self, rec(_children := [self.child(1).sums()])),\n isPermutation := False,\n rng := meth(self) #FULL HACK\n return Devectorize(self.child(1).rng(),self.vlen);\n end,\n dmn := meth(self) #FULL HACK\n return Devectorize(self.child(1).dmn(),self.vlen);\n end,\n dims := meth(self)\n if (IsBound(self.rng)and IsBound(self.dmn)) then\n return [StripList(List(self.rng(),l->l.size)),\n StripList(List(self.dmn(),l->l.size))];\n fi;\n end,\n));\n\n#VTensor.dmn:= meth(self) #FULL HACK\n# local x; \n# x:=self.child(1).dmn()[1];\n# if ObjId(x)=TArray and x.t=TUnknown then \n# return [TArray(TUnknown,x.size*self.vlen)];\n# else\n# return Devectorize(self.child(1).dmn());\n# fi;\n#end;\n#VTensor.rng:= meth(self) #FULL HACK\n# local x; \n# x:=self.child(1).rng()[1];\n# if ObjId(x)=TArray and x.t=TUnknown then \n# return [TArray(TUnknown,x.size*self.vlen)];\n# else\n# return Devectorize(self.child(1).rng());\n# fi;\n#end;\n\nBlockVPerm.dmn := meth(self)\n return [TArray(self.child(1).dmn()[1].t,self.child(1).dmn()[1].size*self.n)];\nend;\nBlockVPerm.rng := meth(self)\n return [TArray(self.child(1).rng()[1].t,self.child(1).rng()[1].size*self.n)];\nend;\n\nClass(ScatQuestionMark, Scat, rec());\nClass(ICScatAcc,Scat,rec(codeletName:=\"ICSA\"));\n\nClass(VScatQuestionMark, VScat, rec());\n\nClass(VScat_svQuestionMark, VScat_sv, rec());\n\nClass(ScatInit, BaseMat, rec(\n new := meth(self, f,con,c)\n local res;\n res := SPL(WithBases(self, rec(func:=f,cond:=con, _children:=c)));\n return res;\n end,\n rng:=self>>self._children.rng(),\n dmn:=self>>self._children.dmn(),\n print := meth(self,i,is)\n Print(self.name, \"(\", self.func, \", \",self.cond,\", \");\n Print(\"\\n\", Blanks(i+is));\n SPLOps.Print(self._children, i + is, is);\n Print(\"\\n\", Blanks(i),\")\");\n return;\n end,\n rChildren := self >> [self._children,self.func],\n rSetChild := meth ( self, n, newChild )\n if n= 1 then\n self._children :=newChild;\n elif n=2 then\n self.func := newChild;\nelse\n Error(\"<n> must be 1\");\n fi;\n end\n\n));\n\nClass(ScatInitProbe,ScatInit,rec());\nClass(ScatInitFixed,ScatInit,rec());\n\nClass(KroneckerSymbol, BaseMat, rec(\n abbrevs := [ arg -> [Flat(arg)] ],\n new := meth(self, l)\n local res;\n res := SPL(WithBases(self, rec(element:=l)));\n return res;\n end,\n isExp:=true,\n dims:=self>>[1,1] #avoid recursive definition for the old-school Tensor\n));\n\n## Base Vector\nClass(BV, BaseMat, rec(\n new := (self, i) >> #Checked(IsVar(i),SPL(WithBases(self, rec(element:=i))))\n SPL(WithBases(self, rec(element:=i))),\n dims:=self>>self.element.dimensions #[0,0] #avoid recursive definition for the old-school Tensor\n));\n\n## Multiplication operator\n## Multiplication(1,n) is I(n)\n## Multiplication(2,n) is a point-wise multiplication of two vectors of size n\n Class(Multiplication, BaseMat, rec(\n abbrevs := [ arg -> [Flat(arg)] ],\n new := meth(self, l)\n local res;\n if l[1]=1 then return Prm(fId(l[2])); fi;\n res := SPL(WithBases(self, rec(element:=l,TType:=Replicate(l[1],TUnknown))));\n return res;\n end,\n isPermutation := self >> false,\n# dmn:=self>>Replicate(self.element[1],TArray(self.TType,self.element[2])),\n#HACK\n# dmn:=meth(self) local a; a:=Replicate(self.element[1],TArray(self.TType,self.element[2]));a[1]:=TArray(TReal,1);return a; end,\n dmn:=self >>List(self.TType,x->TArray(x,self.element[2])),\n rng:=self>>let(a:=Try(First(self.TType,x->ObjId(x)=TVect)),t:=Cond(a[1],a[2],self.TType[1]),[TArray(t,self.element[2])]),\n sums:= self>>self,\n numops:=self>>self.element[2]*(self.element[1]-1),\n transpose := self >>self,\n print := meth(self,i,is)\n Print(self.name, \"(\", self.element[1], \", \",self.element[2],\")\"); self.printA();\n return;\n end\n ));\n Class(ICMultiplication,Multiplication, rec(\n\n ));\n\n _mk_advdim_r := (e) -> List(e, x -> When(IsList(x), _mk_advdim_r(x), [x]));\n _mk_advdim := (d) -> _mk_advdim_r(When(IsList(d), d, [d]));\n \n Class(Glue, BaseMat, rec(\n abbrevs := [(n,size) ->[n,size]],\n new := meth(self,n,size)\n local res;\n res := SPL(WithBases(self, rec(element:=[n,size],dimensions:=[size*n,Replicate(n,size)],TType:=Replicate(n,TUnknown))));\n return res;\n end,\n isPermutation := self >> false,\n dmn:=self >>List([1..(self.element[1])],x->TArray(self.TType[x],self.element[2])),\n rng:=self>>[TArray(self.TType[1],self.element[1]*self.element[2])],\n sums:= self>>self,\n transpose:=self>>Copy(self),\n numops:=self>>self.element[2]*(self.element[1]-1),\n print := meth(self,i,is)\n Print(self.name, \"(\", self.element[1], \", \",self.element[2],\")\"); self.printA();\n return;\n end,\n rChildren := self >> self.element,\n rSetChild := meth( self, n, newChild ) self.element[n] := Checked(n=1 or n=2, newChild); end,\n advdims := self >> let( d := self.dims(), [ _mk_advdim(d[1]), _mk_advdim(d[2]) ]),\n normalizedArithCost := (self) >> 0,\n isReal := self >> true, # makes no sense\n ));\n\n\n Class(Split, BaseMat, rec(\n abbrevs := [(size,n) ->[size,n]],\n new := meth(self,size,n)\n local res;\n res := SPL(WithBases(self, rec(element:=[size,n],dimensions:=[Replicate(n,size / n),size],TType:=[TUnknown])));\n return res;\n end,\n isPermutation := self >> false,\n rng:=self >>List([1..self.element[2]],x->TArray(self.TType[1],self.element[1] / self.element[2])),\n dmn:=self>>[TArray(self.TType[1],self.element[1])],\n sums:= self>>self,\n transpose:= self>>Copy(self),\n numops:=self>>(self.element[1]),\n print := meth(self,i,is)\n Print(self.name, \"(\", self.element[1], \", \",self.element[2],\")\"); self.printA();\n return;\n end,\n rChildren := self >> self.element,\n rSetChild := meth( self, n, newChild ) self.element[n] := Checked(n=1 or n=2, newChild); end,\n advdims := self >> let( d := self.dims(), [ _mk_advdim(d[1]), _mk_advdim(d[2]) ]),\n normalizedArithCost := (self) >> 0,\n isReal := self >> true, # makes no sense\n ));\n\n\n## NoOp, used with in COND_OL()\nClass(NoOp, BaseMat, rec(\n abbrevs := [ arg -> [Flat(arg)] ],\n new := meth(self, l)\n local res;\n if (Length(l) = 1) then\n return SPL(WithBases(self, rec(element:=l, TType:=Replicate(1, TUnknown))));\n fi;\n end,\n isPermutation := self >> false,\n dmn:=self >> [TArray(self.TType[1], self.element[1])],\n rng:=self >> [TArray(self.TType[1], self.element[1])],\n sums:= self>>self,\n numops:=self>> 0,\n print := meth(self,i,is)\n Print(self.name, \"(\", self.element[1], \")\"); self.printA();\n return;\n end\n));\n\n\n## Constant\nClass(Const, BaseMat, rec(\n abbrevs := [ arg -> [Flat(arg)] ],\n new := meth(self, l)\n local res;\n if (Length(l) = 1) then\n return SPL(WithBases(self, rec(element:=l, TType:=Replicate(1, TUnknown))));\n fi;\n\t# Here\n end,\n isPermutation := self >> false,\n dmn:=self >> [],\n# [TArray(self.TType[1], 0)],\n rng:=self >> [TArray(self.TType[1], 1)],\n sums:= self>>self,\n numops:=self>> 0,\n print := meth(self,i,is)\n Print(self.name, \"(\", self.element[1], \")\"); self.printA();\n return;\n end\n));\n\nClass(Or, BaseMat, rec(\n abbrevs := [ arg -> [Flat(arg)] ],\n new := meth(self, l)\n local res;\n if (Length(l) = 1) then\n return SPL(WithBases(self, rec(element:=l, TType:=Replicate(l[1], TUnknown))));\n fi;\n\t# Here\n end,\n isPermutation := self >> false,\n dmn:=self >> List(self.TType, x->TArray(x,1)),\n rng:=self >> [ TArray(self.TType[1], 1)],\n sums:= self>>self,\n numops:=self>> 0,\n print := meth(self,i,is)\n Print(self.name, \"(\", self.element[1], \")\"); self.printA();\n return;\n end\n));\n\nClass(And, BaseMat, rec(\n abbrevs := [ arg -> [Flat(arg)] ],\n new := meth(self, l)\n local res;\n if (Length(l) = 1) then\n return SPL(WithBases(self, rec(element:=l, TType:=Replicate(l[1], TUnknown))));\n fi;\n\t# Here\n end,\n isPermutation := self >> false,\n dmn:=self >> List(self.TType, x->TArray(x,1)),\n rng:=self >> [ TArray(self.TType[1], 1)],\n sums:= self>>self,\n numops:=self>> 0,\n print := meth(self,i,is)\n Print(self.name, \"(\", self.element[1], \")\"); self.printA();\n return;\n end\n));\n\nClass(NotEqual, BaseMat, rec(\n abbrevs := [ arg -> [Flat(arg)] ],\n new := meth(self, l)\n local res;\n if (Length(l) = 1) then\n return SPL(WithBases(self, rec(element:=l, TType:=Replicate(l[1], TUnknown))));\n fi;\n\t# Here\n end,\n isPermutation := self >> false,\n dmn:=self >> List(self.TType, x->TArray(x,1)),\n rng:=self >> [ TArray(self.TType[1], 1)],\n sums:= self>>self,\n numops:=self>> 0,\n print := meth(self,i,is)\n Print(self.name, \"(\", self.element[1], \")\"); self.printA();\n return;\n end\n));\n\nClass(Equal, BaseMat, rec(\n abbrevs := [ arg -> [Flat(arg)] ],\n new := meth(self, l)\n local res;\n if (Length(l) = 1) then\n return SPL(WithBases(self, rec(element:=l, TType:=Replicate(l[1], TUnknown))));\n fi;\n\t# Here\n end,\n isPermutation := self >> false,\n dmn:=self >> List(self.TType, x->TArray(x,1)),\n rng:=self >> [ TArray(self.TType[1], 1)],\n sums:= self>>self,\n numops:=self>> 0,\n print := meth(self,i,is)\n Print(self.name, \"(\", self.element[1], \")\"); self.printA();\n return;\n end\n));\n\nClass(ExclusiveOr, BaseMat, rec(\n abbrevs := [ arg -> [Flat(arg)] ],\n new := meth(self, l)\n local res;\n if (Length(l) = 1) then\n return SPL(WithBases(self, rec(element:=l, TType:=Replicate(l[1], TUnknown))));\n fi;\n\t# Here\n end,\n isPermutation := self >> false,\n dmn:=self >> List(self.TType, x->TArray(x,1)),\n rng:=self >> [ TArray(self.TType[1], 1)],\n sums:= self>>self,\n numops:=self>> 0,\n print := meth(self,i,is)\n Print(self.name, \"(\", self.element[1], \")\"); self.printA();\n return;\n end\n));\n\n## Minimums\n## Minimums(n) -> Input is n-way vector\nClass(Minimums, BaseMat, rec(\n abbrevs := [ arg -> [Flat(arg)] ],\n new := meth(self, l)\n local res;\n if (Length(l) = 1) then\n return SPL(WithBases(self, rec(element:=l, TType:=Replicate(l[1], TUnknown))));\n fi;\n\t# Here\n end,\n isPermutation := self >> false,\n dmn:=self >> List(self.TType, x->TArray(x,1)),\n rng:=self >> [ TArray(self.TType[1], 1)],\n sums:= self>>self,\n numops:=self>> 0,\n print := meth(self,i,is)\n Print(self.name, \"(\", self.element[1], \")\"); self.printA();\n return;\n end\n));\n\n## Maximums\n## Maximums(n) -> Input is n-way vector\nClass(Maximums, BaseMat, rec(\n abbrevs := [ arg -> [Flat(arg)] ],\n new := meth(self, l)\n local res;\n if (Length(l) = 1) then\n return SPL(WithBases(self, rec(element:=l, TType:=Replicate(l[1], TUnknown))));\n fi;\n\t# Here\n end,\n isPermutation := self >> false,\n dmn:=self >> List(self.TType, x->TArray(x,1)),\n rng:=self >> [ TArray(self.TType[1], 1) ],\n sums:= self>>self,\n numops:=self>> 0,\n print := meth(self,i,is)\n Print(self.name, \"(\", self.element[1], \")\"); self.printA();\n return;\n end\n));\n\n\n#Addition\nClass(Addition, BaseMat, rec(\n abbrevs := [ arg -> [Flat(arg)] ],\n new := meth(self, l)\n local res;\n if l[1]=1 then return Prm(fId(l[2])); fi;\n res := SPL(WithBases(self, rec(element:=l,TType:=Replicate(l[1],TUnknown))));\n return res.setDims();\n end,\n isPermutation := self >> false,\n \n dmn:=self >> List( [1..self.element[1]], i -> TArray(TUnknown, self.element[2])),\n rng:=self >> [TArray(TUnknown, self.element[2])],\n sums:= self>>self,\n numops:=self>>self.element[2]*(self.element[1]-1),\n print := meth(self,i,is)\n Print(self.name, \"(\", self.element[1], \", \",self.element[2],\")\"); self.printA();\n return;\n end,\n transpose := self >> InertTranspose(self),\n area := self >> self.element[2]*(self.element[1]-1),\n));\n\nClass(Subtraction, BaseMat, rec(\n abbrevs := [ arg -> [Flat(arg)] ],\n new := meth(self, l)\n local res;\n if l[1]=1 then return Prm(fId(l[2])); fi;\n res := SPL(WithBases(self, rec(element:=l,TType:=Replicate(l[1],TUnknown))));\n return res;\n end,\n isPermutation := self >> false,\n dmn:=self >>List(self.TType,x->TArray(x,self.element[2])),\n rng:=self>>let(a:=Try(First(self.TType,x->ObjId(x)=TVect)),t:=Cond(a[1],a[2],self.TType[1]),[TArray(t,self.element[2])]),\n sums:= self>>self,\n numops:=self>>self.element[2]*(self.element[1]-1),\n print := meth(self,i,is)\n Print(self.name, \"(\", self.element[1], \", \",self.element[2],\")\"); self.printA();\n return;\n end\n));\n\n# Declare(Cross);\n# Class(Cross, BaseOperation, rec(\n# abbrevs := [ arg -> [Flat(arg)] ],\n\n# new := meth(self, L)\n# if Length(L)=1 then return L[1]; fi;\n# return SPL(WithBases(self, rec(_children:=L)));\n# end,\n\n# codeletName:=\"C\",\n# isPermutation := self >> false,\n# dmn:=self>>let(li:=[],Flat(List(self._children, x-> x.dmn()))),\n# rng:=self>>let(li:=[],Flat(List(self._children, x-> x.rng()))),\n# sums:= meth(self)\n# local i;\n# for i in [1..Length(self._children)] do\n# self._children[i]:=self._children[i].sums();\n# od;\n# return self;\n# end,\n# hasLeftGath:=meth(self)\n# local i;\n# for i in self._children do\n# # if (ObjId(i)=Compose and ObjId(i.rChildren()[1])=Gath) or \n# # (ObjId(i)=Gath) then\n# # return true;\n# if (ObjId(i)=Compose and IsBound(i.rChildren()[1].func) and i.rChildren()[1].func.free()<>Set([])) or (IsBound(i.func) and (not ObjId(i)=VGath_dup) and i.func.free()<>Set([])) and not(ObjId(i)=ISum) then\n# return true;\n# fi;\n# od;\n# return false;\n# end,\n# hasRightScat:=meth(self)\n# local i;\n# for i in self._children do\n# # if (ObjId(i)=Compose and ObjId(Last(i.rChildren()))=Scat) or \n# # (ObjId(i)=Scat) then\n# # return true;\n# # fi;\n# if (ObjId(i)=Compose and ((IsBound(Last(i.rChildren()).func) and Last(i.rChildren()).func.free()=Set([])) or (ObjId(Last(i.rChildren()))=ISum) or (ObjId(Last(i.rChildren()))=VGath_dup and Length(Last(i.rChildren()).func.free())=1))) or (IsBound(i.func) and i.func.free()=Set([])) or (ObjId(i)=VGath_dup and Length(i.func.free())=1) or ObjId(i)=ISum then\n# return true;\n# fi;\n# od;\n# return false;\n# end,\n# splitCross:=meth(self)\n# local l,r;\n# l:=Copy(self);\n# r:=[];\n# for i in [1..Length(l._children)] do\n# # if (ObjId(l._children[i])=Compose and ObjId(Last(l._children[i].rChildren()))=Scat) then\n# if (ObjId(l._children[i])=Compose and ((IsBound(Last(l._children[i].rChildren()).func) and Last(l._children[i].rChildren()).func.free()=Set([])) or (ObjId(Last(l._children[i].rChildren()))=ISum) or (ObjId(Last(l._children[i].rChildren()))=VGath_dup and Length(Last(l._children[i].rChildren()).func.free())=1))) or (ObjId(l._children[i])=ISum) then\n# Add(r,Last(l._children[i].rChildren()));\n# l._children[i]._children:=DropLast(l._children[i]._children,1);\n# # elif (ObjId(l._children[i])=Scat) then\n# elif (IsBound(l._children[i].func) and l._children[i].func.free()=Set([])) or (ObjId(i)=VGath_dup and Length(i.func.free())=1) then\n# Add(r,l._children[i]);\n# l._children[i]:=Prm(fId(l._children[i].dims()[1]));\n# else\n# Add(r,Prm(fId(l._children[i].dims()[2])));\n# fi;\n# od;\n# return [l,Cross(r)];\n# end\n# )\n# );\n\nClass(CrossBlockTop,Cross);\n\nIdentities:=function(l)\n return Cross(List(l,x->Prm(fId(x.size))));\nend;\n\n\nBB.numops:= self>>self.child(1).numops();\nNoPull.numops:= self>>self.child(1).numops();\nNoPullRight.numops:= self>>self.child(1).numops();\nNoPullLeft.numops:= self>>self.child(1).numops();\n\nPushR.numops:= self>>self.child(1).numops();\n\nISum.numops:=self>>self.child(1).numops()*self.domain;\n\nSUM.numops:=self>>Sum(List(self._children,c->c.numops()));\n\nCross.numops:=self>>Sum(List(self._children,c->c.numops()));\n\nCompose.numops:=self>>Sum(List(self._children,c->c.numops()));\n\nScat.numops:=self>>self.dims()[2];\n\nGath.numops:=self>>self.dims()[1];\n\nVGath.numops:=self>>self.dims()[1];\nVGath_dup.numops:=self>>self.dims()[1]; \nVReplicate.numops:=self>>self.v;\nVHAdd.numops:=self>>self.v*self.v;\nVPerm.numops:=self>>self.dimensions[1];\nTensor.numops:=self>>self.dimensions[1];\n\nScatAcc.numops:=self>>self.dimensions[2]*2; #an add and a store\nVScatAcc.numops:=self>>self.dimensions[2]*2; #an add and a store\nVScat.numops:=self>>self.dimensions[2];\n\nfBase.numops:=self>>0;\nfTensor.numops:=self>>0;\nfId.numops:=self>>0;\nScatInit.numops:=self>>self._children.numops();\n\nPrm.numops:=self>>0;\nI.numops:=self>>0;\n\nVTensor_OL.numops:=self>>self._children[1].numops()*self.vlen;\n\nClass(AOne,AGenericTag);\nClass(AMul,AGenericTag, rec(\n __call__ := meth ( arg )\n local result, self, params;\n self := arg[1];\n params := arg{[ 2 .. Length(arg) ]};\n result := WithBases(self, rec(\n params := params,\n operations := PrintOps));\n return result;\n end,\n print := self >> Print(self.__name__, \"(\", PrintCS(self.params), \")\")\n ));\n\nClass(VOLWrap, VWrapBase, rec(\n __call__ := (self,isa) >> Checked(IsSIMD_ISA(isa), \n WithBases(self, rec(operations:=PrintOps, isa:=isa))),\n\n wrap := (self,r,t) >> let(isa := self.isa, v := isa.v,\n#This is OBVIOUSLY a hack. only deals with some kind of vectorization\n nontransforms.ol.TTensorI_OL_Vectorize_AVecLast(TTensorI_OL(t, [ AOne, AVec ],[ [ 0, 2 ] ], [ 1, v ], [ AVecReg(isa) ]), r)),\n\n twrap := (self, t) >> let(isa := self.isa, v := isa.v, \n#This is OBVIOUSLY a hack. only deals with some kind of vectorization\n TTensorI_OL(t, [ AOne, AVec ],[ [ 0, 2 ] ], [ 1, v ], [ AVecReg(isa) ])\n ),\n \n print := self >> Print(self.name, \"(\", self.isa, \")\")\n));\n\nClass(TTensorI_OL, Tagged_tSPL, rec(\n abbrevs := [ \n (nt,g,s,v) -> [nt,List([1..Length(g)],i->When(v[i]=1,AOne,g[i])),s,v] \n ],\n\n dmn := self >> let(\n nt := self.params[1],\n sizes := self.params[4],\n List([1..Length(sizes)], i->\n TArray(nt.dmn()[i].t,sizes[i] * nt.dmn()[i].size)\n )),\n\n rng := self >> let(\n nt := self.params[1],\n s := self.params[3],\n v := self.params[4],\n List([1..Length(s)], i->\n TArray(nt.rng()[i].t, Product(List(s[i], a ->\n When(a=0,\n nt.rng()[i].size,\n v[a]\n )\n )))\n )\n ),\n\n isReal := self >> self.params[1].isReal(),\n doNotMeasure:=true,\n doNotSaveInHashtable:=true,\n decomposePerformance:=true,\n transpose := self >> Copy(self),\n#D tagpos :=5,\n));\n\n#Changed by Marek, looks OK\nNewRulesFor(TTensorI_OL, rec(\n TTensorI_OL_Base :=rec(\n applicable := (self,t) >> not(t.hasTag(AParSMP)) and t.getTags() = t.params[1].getTags(),\n freedoms := nt -> let(\n g := nt.params[2],\n nbvars := Length(Filtered(g,x->x=APar or x=AVec)),\n [Arrangements([1..nbvars],nbvars)]\n ),\n child := (nt,freedoms) -> [nt.params[1],InfoNt(freedoms)],\n recompose := (nt,cnt,cperf) -> cperf[1]*Product(List(Filtered(Zip2(nt.params[2],nt.params[4]),l->l[1] in [APar,AVec]),x->x[2])),\n apply := function(nt,c,cnt)\n local g,s,v,perm,ind1,ind,ind2,gathers,scatters,result,z;\n g := nt.params[2];\n s := nt.params[3];\n v := nt.params[4];\n perm := cnt[2].params[1][1];\n ind1 := List([1..Length(g)], i ->\n Cond(g[i]=APar or g[i]=AVec, fBase(Ind(v[i])),\n g[i]=AOne, fId(1),\n ObjId(g[i])=AMul, g[i],\n Error(\"PV not known!\")\n )\n );\n ind := List(ind1, x -> When(ObjId(x)=AMul,ind1[x.params[1]],x));\n gathers := Cross(List([1..Length(g)], i -> let(\n kernelsize := fId(cnt[1].dmn()[i].size),\n When(g[i]=APar or (ObjId(g[i])=AMul and g[i].params[2]=APar),\n Gath(fTensor(ind[i],kernelsize)),\n Gath(fTensor(kernelsize,ind[i]))\n )\n )));\n scatters := Cross(List([1..Length(s)], i -> \n ScatQuestionMark( fTensor(\n List(s[i], y ->\n When(y=0, \n fId(cnt[1].rng()[i].size),\n ind[y]\n )\n )\n ))\n ));\n result := scatters*c[1]*gathers;\n ind2:=[];\n for i in [1..Length(g)] do\n if g[i]=APar or g[i]=AVec then\n Add(ind2,ind[i]);\n fi;\n od;\n for i in [1..Length(ind2)] do\n result:=ISum(ind2[perm[i]].params[2], ind2[perm[i]].params[1], result);\n od;\n\n return result;\n end\n ),\n#D applicable :=(self,t) >> Length(Filtered(GetTags(t),x->ObjId(x)=AParSMP))=0 and GetTags(t)=GetTags(t.params[1])\n#D,\n#D freedoms := nt -> let(g:=nt.params[2],\n#D nbvars:=Length(Filtered(g,x->x=APar or x=AVec)),\n#D [Arrangements([1..nbvars],nbvars)]),\n#D child := (nt,freedoms) -> [nt.params[1],InfoNt(freedoms)],\n#D recompose := (nt,cnt,cperf) -> cperf[1]*Product(List(Filtered(Zip2(nt.params[2],nt.params[4]),l->l[1] in [APar,AVec]),x->x[2])),\n#D apply := function(nt,c,cnt)\n#D local g,s,v,perm,ind1,ind,ind2,gathers,scatters,result,z;\n#D g:=nt.params[2];\n#D s:=nt.params[3];\n#D v:=nt.params[4];\n#D perm:=cnt[2].params[1][1];\n#D ind1:=List([1..Length(g)],\n#D i->Cond(g[i]=APar or g[i]=AVec,fBase(Ind(v[i])),\n#D g[i]=AOne,fId(1),\n#D ObjId(g[i])=AMul,g[i],\n#D Error(\"PV not known!\")));\n#D ind:=List(ind1,x->When(ObjId(x)=AMul,ind1[x.params[1]],x));\n#D gathers:= Cross(List([1..Length(g)],\n#D i->let(kernelsize:=fId(cnt[1].dmn()[i].size),\n#D When(g[i]=APar or (ObjId(g[i])=AMul and g[i].params[2]=APar),\n#D Gath(fTensor(ind[i],kernelsize)),\n#D Gath(fTensor(kernelsize,ind[i]))))));\n#D scatters:=Cross(List([1..Length(s)],\n#D i->ScatQuestionMark(fTensor(\n#D List(s[i],y->\n#D When(y=0,fId(cnt[1].rng()[i].size),\n#D ind[y]))))));\n#D result:=scatters*c[1]*gathers;\n#D ind2:=[];\n#D for i in [1..Length(g)] do\n#D if g[i]=APar or g[i]=AVec then\n#D Add(ind2,ind[i]);\n#D fi;\n#D od;\n#D for i in [1..Length(ind2)] do\n#D result:=ISum(ind2[perm[i]].params[2],ind2[perm[i]].params[1],result);\n#D od;\n#D\n#D return result;\n#D end\n#D ),\n \n#Changed by Marek, looks OK\n TTensorI_OL_Parrallelize_AParFirst := rec(\n applicable :=(self,t) >> \n t.isTag(1, AParSMP)\n and 0 <> t.params[3][1][1]\n and APar = t.params[2][t.params[3][1][1]]\n and t.firstTag().params[1] = t.params[4][t.params[3][1][1]]\n and 1 = t.params[3][1][1], #t.params[3][1][1]=1 is a trick to prevent // the 2nd input because TensorGeneral breaks at the moment\n\n freedoms := nt -> [[1]],\n\n child := function (nt,freedoms)\n local PV,sizes;\n sizes := Copy(nt.params[4]);\n sizes[nt.params[3][1][1]] := 1;\n if Length(Filtered(sizes, t -> t<>1)) > 0 then\n PV:=Copy(nt.params[2]);\n PV[nt.params[3][1][1]] := AOne;\n return [TTensorI_OL(\n DropParTag(nt.params[1]),\n PV,\n nt.params[3],\n sizes,\n Drop(nt.params[5],1)\n )];\n else\n return [ DropParTag(Copy(nt.params[1])) ];\n fi;\n end,\n\n apply := function(nt,c,cnt)\n local myCross,a,b,index;\n\n index := Ind(nt.firstTag().params[1]);\n\n a := List(c[1].dims()[2], x -> fId(x));\n a[nt.params[3][1][1]] := fTensor(fBase(index), a[nt.params[3][1][1]]);\n\n b:=List(a, x -> Gath(x));\n\n myCross:=Cross(b);\n\n# return SMPSum(GetFirstTag(nt).params[1],index, GetFirstTag(nt).params[1],ScatQuestionMark(fTensor(fBase(index), fId(c[1].dims()[1]))) *c[1]* Cross(Gath(fTensor(fBase(index), fId(c[1].dims()[2][1]))),Gath(fId(c[1].dims()[2][2]))));\n return SMPSum(\n nt.firstTag().params[1],\n index,\n nt.firstTag().params[1],\n ScatQuestionMark(fTensor(\n fBase(index), \n fId(c[1].dims()[1])\n ))\n * c[1] * myCross\n );\n end\n ),\n#D applicable :=(self,t) >> FirstTagEq(t, AParSMP) and t.params[3][1][1]<>0 and \n#D t.params[2][t.params[3][1][1]]=APar and \n#D t.params[4][t.params[3][1][1]]=GetFirstTag(t).params[1] and \n#D t.params[3][1][1]=1, #t.params[3][1][1]=1 is a trick to prevent // the 2nd input because TensorGeneral breaks at the moment\n#D freedoms := nt -> [[1]],\n#D child := function (nt,freedoms)\n#D local PV,sizes;\n#D sizes:=Copy(nt.params[4]);\n#D sizes[nt.params[3][1][1]]:=1;\n#D if Length(Filtered(sizes, t->t<>1))>0 then\n#D PV:=Copy(nt.params[2]);\n#D PV[nt.params[3][1][1]]:=AOne;\n#D return [TTensorI_OL(DropParTag(nt.params[1]),\n#D PV,nt.params[3],sizes,Drop(nt.params[5],1))];\n#D else\n#D return [DropParTag(Copy(nt.params[1]))];\n#D fi;\n#D end,\n#D apply := function(nt,c,cnt)\n#D local myCross,a,b,index;\n#D index:=Ind(GetFirstTag(nt).params[1]);\n#D a:=List(c[1].dims()[2],x->fId(x));\n#D a[nt.params[3][1][1]]:=fTensor(fBase(index),a[nt.params[3][1][1]]);\n#D b:=List(a,x->Gath(x));\n#D myCross:=Cross(b);\n#D# return SMPSum(GetFirstTag(nt).params[1],index, GetFirstTag(nt).params[1],ScatQuestionMark(fTensor(fBase(index), fId(c[1].dims()[1]))) *c[1]* Cross(Gath(fTensor(fBase(index), fId(c[1].dims()[2][1]))),Gath(fId(c[1].dims()[2][2]))));\n#D return SMPSum(GetFirstTag(nt).params[1],index, GetFirstTag(nt).params[1],ScatQuestionMark(fTensor(fBase(index), fId(c[1].dims()[1]))) *c[1]* myCross);\n#D end),\n\n #That code vectorizes the last guy if it is a AVec of the vector size\n #Hack, only works with one output\n#Changed by Marek, looks OK\n TTensorI_OL_Vectorize_AVecLast :=rec(\n applicable := (self,t) >> \n t.isTag(1, AVecReg)\n and Last(t.params[3][1])<>0 \n and AVec = t.params[2][Last(t.params[3][1])]\n and t.params[4][Last(t.params[3][1])] = t.firstTag().v,\n\n freedoms := nt -> [[1]],\n\n child := function(nt, freedoms)\n local PV, sizes;\n\n sizes := Copy(nt.params[4]);\n sizes[Last(nt.params[3][1])] := 1;\n\n if Length(Filtered(sizes, t->t<>1))>0 then\n PV:=Copy(nt.params[2]);\n PV[Last(nt.params[3][1])]:=AOne;\n return [TTensorI_OL(\n DropVectorTag(nt.params[1]).setWrap(VOLWrap(nt.firstTag().isa)),\n PV,\n nt.params[3],\n sizes,\n Drop(nt.params[5],1)\n )];\n else\n return [ DropVectorTag(Copy(nt.params[1])).setWrap(VOLWrap(nt.firstTag().isa)) ];\n fi;\n end,\n\n apply := function(nt,c,cnt)\n local myCross, myScat, mydims, v;\n\n v := nt.firstTag().v;\n\n #little hack for KernelDup\n if ObjId(nt.params[1]).name <> \"KernelMMMDuped\" then\n myCross := Cross(List(nt.dims()[2], t ->\n VGath_dup(fId(t), v)\n ));\n myCross._children[Last(nt.params[3][1])] :=\n VPrm_x_I(\n fId( nt.dims()[2][Last(nt.params[3][1])] / v ), \n nt.firstTag().v\n );\n else \n mydims := nt.dims()[2];\n mydims[1] := mydims[1] * v;\n myCross := Cross(List(mydims, t ->\n VPrm_x_I( fId(t/v), v )\n ));\n fi;\n\n myScat := VScat(fId( nt.dims()[1]/v ), v );\n\n return myScat * VTensor_OL(c[1], v) * myCross;\n end\n ),\n#D applicable :=(self,t) >> FirstTagEq(t, AVecReg) and Last(t.params[3][1])<>0 and t.params[2][Last(t.params[3][1])]=AVec and t.params[4][Last(t.params[3][1])]=GetFirstTag(t).v,\n#D freedoms := nt -> [[1]],\n#D child := function (nt,freedoms)\n#D local PV,sizes;\n#D sizes:=Copy(nt.params[4]);\n#D sizes[Last(nt.params[3][1])]:=1;\n#D if Length(Filtered(sizes, t->t<>1))>0 then\n#D PV:=Copy(nt.params[2]);\n#D PV[Last(nt.params[3][1])]:=AOne;\n#D return [TTensorI_OL(DropVectorTag(nt.params[1]).setWrap(VOLWrap(GetFirstTag(nt).isa)),\n#D PV,nt.params[3],sizes,Drop(nt.params[5],1))];\n#D else\n#D return [DropVectorTag(Copy(nt.params[1])).setWrap(VOLWrap(GetFirstTag(nt).isa))];\n#D fi;\n#D end,\n#D apply := function(nt,c,cnt)\n#D local myCross,myScat,mydims;\n#D#little hack for KernelDup\n#D if (ObjId(nt.params[1]).name<>\"KernelMMMDuped\") then\n#D myCross:=Cross(List(nt.dims()[2],t->VGath_dup(fId(t),GetFirstTag(nt).v)));\n#D myCross._children[Last(nt.params[3][1])]:=\n#D VPrm_x_I(fId(nt.dims()[2][Last(nt.params[3][1])]/GetFirstTag(nt).v),GetFirstTag(nt).v);\n#D else \n#D mydims:=nt.dims()[2];\n#D mydims[1]:=mydims[1]*GetFirstTag(nt).v;\n#D myCross:=Cross(List(mydims,t->VPrm_x_I(fId(t/GetFirstTag(nt).v),GetFirstTag(nt).v)));\n#D fi;\n#D myScat:=VScat(fId(nt.dims()[1]/GetFirstTag(nt).v),GetFirstTag(nt).v);\n#D return myScat*VTensor_OL(c[1],GetFirstTag(nt).v)*myCross;\n#D end),\n\n#Changed by Marek, looks OK\n TTensorI_OL_Vectorize_AParFirst :=rec(\n switch:=false,\n\n applicable := (self,t) >> \n t.isTag(1, AVecReg)\n and 0 <> First(t.params[3][1], x -> true)\n and APar = t.params[2][First(t.params[3][1],x -> true)]\n and t.firstTag().v = t.params[4][First(t.params[3][1], x -> true)],\n\n freedoms := nt -> [[1]],\n\n child := function (nt,freedoms)\n local PV,outorder,theguy;\n\n PV := Copy(nt.params[2]);\n PV[First(nt.params[3][1],x->true)] := AVec;\n\n theguy := Copy(First(nt.params[3][1], x->true));\n outorder := Drop(Copy(nt.params[3][1]),1);\n Add(outorder,theguy);\n\n return [\n TTensorI_OL( nt.params[1], PV, [outorder], nt.params[4], nt.params[5]),\n TL(nt.rng()[1].size, nt.firstTag().v, 1, 1, nt.params[5]),\n TL(\n nt.dmn()[First(nt.params[3][1], x -> true)].size, \n nt.dmn()[First(nt.params[3][1], x -> true)].size / nt.firstTag().v,\n 1,\n 1,\n nt.params[5]\n )\n ];\n end,\n\n apply := function(nt,c,cnt)\n local i;\n\n i := Identities(nt.dmn());\n i._children[First(nt.params[3][1], x -> true)] := c[3];\n\n return c[2] * c[1] * i;\n end\n ),\n\n#D applicable :=(self,t) >> FirstTagEq(t, AVecReg) and First(t.params[3][1],x->true)<>0 and t.params[2][First(t.params[3][1],x->true)]=APar and t.params[4][First(t.params[3][1],x->true)]=GetFirstTag(t).v,\n#D freedoms := nt -> [[1]],\n#D child := function (nt,freedoms)\n#D local PV,outorder,theguy;\n#D PV:=Copy(nt.params[2]);\n#D PV[First(nt.params[3][1],x->true)]:=AVec;\n#D theguy:=Copy(First(nt.params[3][1],x->true));\n#D outorder:=Drop(Copy(nt.params[3][1]),1);\n#D Add(outorder,theguy);\n#D return [TTensorI_OL(nt.params[1],PV,[outorder],nt.params[4],nt.params[5]),TL(nt.rng()[1].size,GetFirstTag(nt).v,1,1,nt.params[5]),TL(nt.dmn()[First(nt.params[3][1],x->true)].size,nt.dmn()[First(nt.params[3][1],x->true)].size/GetFirstTag(nt).v,1,1,nt.params[5])];\n#D end,\n#D apply := function(nt,c,cnt)\n#D local i;\n#D i:=Identities(nt.dmn());\n#D i._children[First(nt.params[3][1],x->true)]:=c[3];\n#D return c[2]*c[1]*i;\n#D end),\n));\n\n\n\n\n\n\n\n\n\n\n", "meta": {"hexsha": "9ecab60a40ab69f575d8134db6d1701ae2cec8d7", "size": 35111, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/nontransforms/ol/operators.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/nontransforms/ol/operators.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/nontransforms/ol/operators.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 35.9743852459, "max_line_length": 367, "alphanum_fraction": 0.5194383527, "num_tokens": 10589, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4882833952958347, "lm_q2_score": 0.02758528252657529, "lm_q1q2_score": 0.013469435412271044}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\n_sum2 := function(lst)\n local i, res;\n res := 0;\n for i in [2..Length(lst)] do\n res := res + lst[i][1] + lst[i][2];\n od;\n return res;\nend;\n\n# objhead = [ objid_addr, param1_uid, param2_uid, ... ]\n# uid is unique position in the hashtable returned by HashAdd\nClass(ObjHashBase, HashTable( \n (objhead,size) -> When(IsInt(objhead), 1 + (objhead mod size),\n 1 + ((objhead[1] + _sum2(objhead)) mod size)),\n (objhead1, objhead2) -> objhead1 = objhead2)\n);\n\nObjHashBase.operations := WithBases(HashOps, rec(\n Print := o -> Print(o.name)\n));\n\nClass(ObjHash, ObjHashBase, rec(\n liveEntries := self >> Filtered(self.entries, True),\n numLiveEntries := self >> Sum(List(self.liveEntries(), Length)),\n\n nonrecLookupAdd := meth(self, o)\n local lkup;\n\tlkup := HashLookupUID(self, InternalHash(o));\n\tif Same(lkup, false) then\n\t return HashAdd(self, InternalHash(o), o);\n\telse return lkup;\n\tfi;\n end,\n\n listLookupAdd := meth(self, o)\n local lkup, uids;\n\tuids := [T_LIST];\n\tAppend(uids, List(o, e -> self.uidObj(e)));\n\tlkup := HashLookupUID(self, uids);\n\tif Same(lkup, false) then\n\t return HashAdd(self, uids, o);\n\telse return lkup;\n\tfi;\n end,\n\n uidObj := (self,o) >> Cond(\n IsRec(o) and IsBound(o.uid), o.uid, \n IsRec(o), Error(\"Unhashed object <o>\"),\n IsList(o), self.listLookupAdd(o),\n self.nonrecLookupAdd(o)),\n\n objAdd := meth(self, res, h)\n local uid;\n uid := HashAdd(self, h, res);\n res.h := h;\n res.uid := uid;\n return res;\n end,\n\n singletonAdd := (self, o) >> self.objAdd(o, [BagAddr(o)]),\n\n _prList := meth(self, lst) \n local p;\n for p in lst do\n if IsRec(p) then Print(ObjId(p));\n elif IsList(p) then Print(\"(\",self._prList(p), \")\");\n else Print(p);\n fi;\n Print(\":\",self.uidObj(p), \" \");\n od;\n end,\n\n debug := true,\n\n objLookup := meth(self, objid, params) \n local h,lkup,hcodes;\n\th := [BagAddr(objid)];\n\tAppend(h, List(params, p -> self.uidObj(p))); \n\tlkup := HashLookup(self, h);\n\n\tif self.debug then \n\t if Same(lkup,false) then \n\t\tPrint(\"(\", objid, \" \", self._prList(params), \")\\n\");\n\t else \n\t\tPrint(objid, \" : hit \", lkup.uid, \"\\n\"); \n\t fi;\n\tfi;\n\t \n\treturn [lkup,h];\n end,\n\n memClassFunc := meth(self, cls, orig, bck)\n Constraint(IsBound(cls.(orig)));\n #Constraint(not IsBound(cls.__call_no_memo__));\n cls.(bck) := cls.(orig);\n cls._hash := self;\n bck := RecName(bck); # this will make lookup a bit faster\n\n cls.(orig) := meth(arg)\n local clsself, params, lkup, res, h;\n clsself := arg[1]; params := Drop(arg,1);\n h := clsself._hash;\n if h<>false then \n lkup := h.objLookup(clsself, params);\n if lkup[1] <> false then return lkup[1]; fi;\n fi;\n res := ApplyFunc(clsself.(bck), params);\n if h<>false then \n return h.objAdd(res, lkup[2]);\n else return res;\n fi;\n end;\n end,\n\n memClass := (self,cls) >> self.memClassFunc(cls, \"__call__\", \"__call_no_memo__\")\n));\n", "meta": {"hexsha": "57852b088217dcd4882d614d0899d0d9a6387eb1", "size": 3189, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/spl/objhash.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/spl/objhash.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/spl/objhash.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 26.1393442623, "max_line_length": 84, "alphanum_fraction": 0.5697710881, "num_tokens": 954, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4225046493573919, "lm_q2_score": 0.030214585975821884, "lm_q1q2_score": 0.012765803053193395}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\nDeclare(SSEUnparser);\n\n_toReal := v -> Cond(IsValue(v), Value(TReal, v.v), tcast(TReal, v));\n\n@Value := @.cond(IsValue);\n@TInt := @.cond(x->IsIntT(x.t));\n@TReal := @.cond(x->IsRealT(x.t));\n@TRealInt := @.cond(x->IsIntT(x.t) or IsRealT(x.t));\n@_scalar := @.cond(x->IsIntT(x.t) or IsRealT(x.t) or IsPtrT(x.t));\n@TVect := @.cond(x->IsVecT(x.t));\n@TVectUChar := @.cond(x->IsVecT(x.t) and ObjId(x.t.t)=TUChar);\n\n_isa := self -> self.opts.vector.isa;\n_epi_or_px := (self, o) -> When(_isa(self).isFixedPoint or IsOrdT(o.t.t),\n \"epi\" :: self.ctype_suffixval(o.t, _isa(self)),\n self.ctype_suffix(o.t, _isa(self)));\n\n_epu_or_px := (self, o) -> When(_isa(self).isFixedPoint,\n \"epu\" :: self.ctype_suffixval(o.t, _isa(self)),\n self.ctype_suffix(o.t, _isa(self)));\n\n_epi := (self, o) -> Concat(\"epi\", self.ctype_suffixval(o.t, _isa(self)));\n\n_epu_to_epi := (s) -> Cond( s{[1..3]} = \"epu\", \"epi\" :: s{[4..Length(s)]}, s );\n\n\nClass(SSEUnparser, CMacroUnparserProg, rec(\n # -----------------------------\n # ISA independent constructs\n # -----------------------------\n nth := (self, o, i, is) >> self.printf(\"$1[$2]\", [o.loc, o.idx]),\n fdiv := (self, o, i, is) >> self.printf(\"(((double)$1) / ($2))\", o.args),\n div := (self, o, i, is) >> self.printf(\"(($1) / ($2))\", o.args),\n idiv := (self, o, i, is) >> self.printf(\"(($1) / ($2))\", o.args),\n\n # --------------------------------\n # ISA constructs, general\n # -------------------------------\n\n # This is a general suffix for intrinsics that is determine from the data type\n ctype_suffix := (self, t, isa) >> Cond(\n t = TVect(T_Int(128), 1), \"epi128\",\n t = TVect(T_UInt(128), 1), \"epu128\",\n\n t = TVect(T_Real(32), 4) or\n t = TVect(T_Real(32), 2) and isa=SSE_2x32f or\n t = TVect(TReal, 4) and isa=SSE_4x32f or\n t = TVect(TReal, 2) and isa=SSE_2x32f,\n \"ps\",\n\n # no way to create __m64 type directly from floats, have to go thru integers\n t = TVect(T_Real(32), 2) and isa=SSE_4x32f or\n t = TVect(TReal, 2) and isa=SSE_4x32f,\n \"ps_half\",\n\n t = TVect(TInt, 4) or\n t = TVect(T_Int(32), 4) or\n t = TVect(TReal, 4) and isa.isFixedPoint,\n \"epi32\",\n\n t = TVect(T_UInt(32), 4), \"epu32\",\n\n t = TVect(T_Real(64), 2) or\n t = TVect(TReal, 2) and isa=SSE_2x64f,\n \"pd\",\n\n t = TVect(TInt, 2) or\n t = TVect(T_Int(64), 2) or\n t = TVect(TReal, 2) and isa.isFixedPoint,\n \"epi64\",\n\n t = TVect(T_UInt(64), 2), \"epu64\",\n\n t = TVect(T_Int(16), 8), \"epi16\",\n t = TVect(T_UInt(16), 8), \"epu16\",\n t = TVect(TInt, 8), \"epi16\",\n t = TVect(TReal, 8), \"epi16\",\n\n t = TVect(T_Int(8), 16), \"epi8\",\n t = TVect(T_UInt(8), 16), \"epu8\",\n t = TVect(TReal, 16), When(isa.isSigned, \"epi8\", \"epu8\"),\n t = TVect(TInt, 16), \"epi8\",\n t = TVect(TUChar, 16), \"epu8\",\n \"\"\n ),\n\n mul_suffix := (t,isa) -> Cond(\n t = TVect(T_Real(32), 2), \"_ps\",\n t = TVect(T_Real(32), 4), \"_ps\",\n t = TVect(T_Real(64), 2), \"_pd\",\n t = TVect(TReal, 2) and isa = SSE_2x32f, \"_ps\",\n t = TVect(TReal, 2), \"_pd\",\n t = TVect(TInt, 2), \"_epi64\",\n t = TVect(TReal, 4), \"_ps\",\n t = TVect(TInt, 4), \"_epi32\",\n t = TVect(T_Int(32), 4), \"lo_epi32\",\n t = TVect(TReal, 8), \"lo_epi16\",\n t = TVect(TReal, 16), Error(\"16-way multiplication is not supported\"),\n t = TVect(TUChar, 16), Error(\"16-way multiplication is not supported\"),\n \"\"\n ),\n\n # This is a general suffix for intrinsics that is determine from the data type\n ctype_suffixval := (t, isa) -> Cond(\n\tt = TVect(TReal, 2), \"64\",\n\tt = TVect(TInt, 4), \"32\",\n\tt = TVect(TReal, 4), \"32\",\n\tt = TVect(T_Int(32), 4), \"32\",\n t = TVect(T_UInt(32), 4), \"32\",\n\tt = TVect(TReal, 8), \"16\",\n\tt = TVect(TInt, 8), \"16\",\n\tt = TVect(T_Int(16), 8), \"16\",\n t = TVect(T_UInt(16), 8), \"16\",\n\tt = TVect(TReal, 16), \"8\",\n\tt = TVect(TInt, 16), \"8\",\n\tt = TVect(T_Int(8), 16), \"8\",\n t = TVect(T_UInt(8), 16), \"8\",\n\tt = TVect(TUChar, 16), \"8\",\n\tt = TVect(T_Real(32), 4), \"32\",\n\tt = TVect(T_Real(64), 2), \"64\",\n\t\"\"\n ),\n\n # This is the type used for declarations of vector variables\n ctype := (self, t, isa) >> Cond(\n # NOTE: used for unaligned vector pointers,for single prec, it should be \"float\"\n\tt in [TReal, TVect(TReal, 1)],\n Cond(isa = SSE_2x64f, \"double\",\n\t\t isa = SSE_2x64i, \"__int64\",\n\t\t isa = SSE_4x32f, \"float\",\n\t\t isa = SSE_2x32f, \"float\",\n\t\t isa = SSE_4x32i, \"__int32\",\n\t\t isa = SSE_8x16i, \"short\",\n\t\t isa = SSE_16x8i, Cond(isa.isSigned, \"char\", \"unsigned char\"),\n\t\t isa.ctype),\n\n\tt = TVect(TReal, 2),\n Cond(isa = SSE_2x64f, \"__m128d\",\n\t\t isa = SSE_2x64i, \"__m128i\",\n\t\t isa = SSE_4x32f, \"__m64\",\n\t\t isa = SSE_8x16i, \"__int32\",\n\t\t isa = SSE_16x8i, \"__int16\",\n\t\t isa = SSE_2x32f, \"__m64\"),\n\n\tt = TVect(TReal, 4),\n Cond(isa = SSE_4x32f, \"__m128\",\n\t\t isa = SSE_2x32f, \"__m128\",\n\t\t isa = SSE_4x32i, \"__m128i\"),\n\n t = TVect(TInt, 2), \"__m128i\",\n\tt = TVect(TInt, 4), \"__m128i\",\n\tt = TVect(TInt, 8), \"__m128i\",\n\tt = TVect(TReal, 8), \"__m128i\",\n\tt = TVect(TInt, 16), \"__m128i\",\n\tt = TVect(TUChar, 16), \"__m128i\",\n\tt = TVect(TReal, 16), \"__m128i\",\n\n\tt = TInt,\n Cond(isa = SSE_2x64i, \"__int64\",\n\t\t isa = SSE_4x32i, \"__int32\",\n\t\t isa = SSE_8x16i, \"short\",\n\t\t isa = SSE_16x8i, \"char\",\n\t\t \"int\"),\n\n\tt = TVect(T_Int(128), 1), \"__m128i\",\n\tt = TVect(T_Int(64), 2), \"__m128i\",\n\tt = TVect(T_Int(32), 4), \"__m128i\",\n\tt = TVect(T_Int(16), 8), \"__m128i\",\n\tt = TVect(T_Int(8), 16), \"__m128i\",\n\n\tt = TVect(T_UInt(128), 1), \"__m128i\",\n\tt = TVect(T_UInt(64), 2), \"__m128i\",\n\tt = TVect(T_UInt(32), 4), \"__m128i\",\n\tt = TVect(T_UInt(16), 8), \"__m128i\",\n\tt = TVect(T_UInt(8), 16), \"__m128i\",\n\n t = TVect(T_Real(32), 2), \"__m64\",\n\tt = TVect(T_Real(32), 4), \"__m128\",\n\tt = TVect(T_Real(64), 2), \"__m128d\",\n\tError(self,\".ctype doesn't know type \",t)\n ),\n\n cvalue_suffix := (self, t) >> let( isa := _isa(self), Cond(\n (t = TReal and isa in [SSE_2x32f, SSE_4x32f]) or t = T_Real(32), \"f\",\n (t = TReal) or t = T_Real(64), \"\",\n Error(self,\".cvalue_suffix doesn't know type \",t)\n )),\n\n vhex := (self, o, i, is) >> Print(\"_mm_set_\", _epi(self, o), \"(\", self.infix(Reversed(o.p), \", \"), \")\"),\n\n Value := (self, o, i, is) >> let(zero := \"0\" :: self.cvalue_suffix(TReal), Cond(\n o.t = TString, Print(o.v),\n\n o.t = TReal or ObjId(o.t)=T_Real, let(v := When(IsCyc(o.v), ReComplex(Complex(o.v)), Double(o.v)),\n When(v<0, Print(\"(\", v, self.cvalue_suffix(o.t), \")\"), Print(v, self.cvalue_suffix(o.t)))),\n\n #IsComplexT(o.t),\n\t# Print(\"COMPLEX(\", ReComplex(Complex(o.v)), self.cvalue_suffix(o.t.realType()), \", \",\n\t# ImComplex(Complex(o.v)), self.cvalue_suffix(o.t.realType()), \")\"),\n\n IsIntT(o.t) or IsUIntT(o.t),\n When(o.v < 0, Print(\"(\", o.v, \")\"), Print(o.v)),\n\n ObjId(o.t) = TVect and _isa(self) = SSE_2x32f,\n Cond(self.cx.isInside(Value) and Length(self.cx.Value) >= 2, # nested in an array\n\t\t Print( \"{\", zero, \", \", zero, \", \", self.infix((o.v), \", \"), \"}\"),\n\t\t Print(\"_mm_set_ps(\", zero, \", \", zero, \", \", self.infix(Reversed(o.v), \", \"), \")\")),\n\n ObjId(o.t) = TVect and Length(Set(o.v)) = 1,\n Cond(self.cx.isInside(Value) and Length(self.cx.Value) >= 2, # nested in an array\n\t\t Print(\"{\", self.infix(Replicate(o.t.size, o.v[1]), \", \"), \"}\"),\n\t\t Print(\"_mm_set1_\", _epi_or_px(self, o), \"(\", self(o.v[1], i, is), \")\")),\n\n ObjId(o.t) = TVect,\n Cond(self.cx.isInside(Value) and Length(self.cx.Value) >= 2, # nested in an array\n\t\t Print( \"{\", self.infix((o.v), \", \"), \"}\"),\n\t\t Print(\"_mm_set_\", _epi_or_px(self, o), \"(\", self.infix(Reversed(o.v), \", \"), \")\")),\n\n IsArray(o.t),\n Print(\"{\", self.infix(o.v, \", \"), \"}\"),\n\n ObjId(o.t) = TSym,\n Print(\"(\", self.declare(o.t, [], 0, 0), \") \", o.v),\n\n o.t = TBool, Print(When(o.v = true, \"1\", \"0\")),\n\n\tInherited(o, i, is)\n )),\n\n vpack := (self, o, i, is) >> let(\n sfx := _epi_or_px(self, o),\n Print(\"_mm_set_\", sfx, \"(\", self.infix(Reversed(o.args), \", \"), \")\")),\n\n vdup := (self, o, i, is) >> let(\n\tsfx := _epi_or_px(self, o),\n CondPat(o,\n [vdup, nth, @.cond(x->x.t=TInt and x.v=2)], self.printf(\"_mm_loaddup_$1(&($2))\", [sfx, o.args[1]]),\n [vdup, @, @TInt], self.printf(\"_mm_set1_$1($2)\", [sfx, o.args[1]]))),\n\n # --------------------------------\n # Declarations\n _declTVect := (self, t, vars, i, is) >> let(ctype := self.ctype(t, _isa(self)), Print(ctype, \" \", self.infix(vars, \", \", i+is))),\n _unparseTVect := (self, t, i, is) >> let(ctype := self.ctype(t, _isa(self)), Print(ctype)),\n\n TVect := arg >> When(Length(arg)=5, arg[1]._declTVect(arg[2], arg[3], arg[4], arg[5]),\n\t arg[1]._unparseTVect(arg[2], arg[3], arg[4])),\n TReal := ~.TVect,\n TInt := (self, t, vars, i, is) >> Print(\"int \", self.infix(vars, \", \", i+is)),\n TBool := (self, t, vars, i, is) >> Print(\"int \", self.infix(vars, \", \", i+is)),\n\n # --------------------------------\n # Arithmetic\n #\n mul := (self, o, i, is) >> let(n := Length(o.args), Cond(\n not IsVecT(o.t),\n Print(\"(\",self.pinfix(o.args, \")*(\"),\")\"),\n\tn > 2 and n mod 2 <> 0,\n self(mul(o.args[1], ApplyFunc(mul, Drop(o.args, 1))), i, is),\n n > 2,\n self(mul(ApplyFunc(mul, o.args{[1..n/2]}), ApplyFunc(mul, o.args{[n/2+1..n]})), i, is),\n CondPat(o,\n\t [mul, @TReal, @TVect], Cond(_isa(self) = SSE_2x32f,\n self(mul(vdup(o.args[1], 4), o.args[2]), i, is), # NOTE: HACK for SSE_2x32f\n self(mul(vdup(o.args[1], o.t.size), o.args[2]), i, is)),\n\t [mul, @TVect, @TReal], self(mul(o.args[1], vdup(o.args[2],o.t.size)), i, is),\n # NOTE: This hack is probably no longer necessary (was used for PRDFTs)\n\t [mul, @(1, cond, e -> e.t=TInt), @TVect],\n\t self(mul(cond(o.args[1].args[1],\n\t\t\t vdup(o.t.t.value(o.args[1].args[2]), o.t.size),\n\t\t\t vdup(o.t.t.value(o.args[1].args[3]), o.t.size)), o.args[2]), i, is),\n\t [mul, @TInt, @TVect], self(mul(vdup(_toReal(o.args[1]),o.t.size), o.args[2]), i, is),\n\t [mul, @TVect, @TInt], self(mul(o.args[1], vdup(_toReal(o.args[2]),o.t.size)), i, is),\n\t [mul, @TVect, @TVect], self.printf(\"_mm_mul$1($2, $3)\", [self.mul_suffix(o.t, _isa(self)), o.args[1], o.args[2]]),\n\t Error(\"Don't know how to unparse <o>. Unrecognized type combination\")\n ))),\n\n fpmul := (self, o, i, is) >> let(isa := _isa(self), CondPat(o,\n # preparing for SSSE3 _mm_mulhrs_epi16 (__m128i a, __m128i b)\n # self.printf(\"_mm_mulhrs_epi16($1, $2)\", [o.args[2], o.args[3].t.value(List(o.args[3].v, i->bin_shl(i,1)))]),\n [fpmul, @, @TVect, @], self.printf(\"$1($2($3, $4), $5)\",\n\t [isa.vlshift, isa.vmul, o.args[2], o.args[3], isa.bits-o.args[1]]),\n\n [fpmul, @, @, @], self.printf(\"$1($2(_mm_set1_$3($4), $5), $6)\",\n\t [isa.vlshift, isa.vmul, self.ctype_suffix(o.t, _isa(self)), o.args[2], o.args[3], isa.bits-o.args[1]]))),\n\n add := (self, o, i, is) >> let(n := Length(o.args), Cond(\n\tnot IsVecT(o.t),\n self.pinfix(o.args, \" + \"),\n n > 2 and n mod 2 <> 0,\n self(add(o.args[1], ApplyFunc(add, Drop(o.args, 1))), i, is),\n n > 2,\n self(add(ApplyFunc(add, o.args{[1..n/2]}), ApplyFunc(add, o.args{[n/2+1..n]})), i, is),\n let(isa := _isa(self), # ugly, backward compatibility, use <adds> instead\n\t saturated := When(IsBound(isa.isFloat) and IsBound(isa.saturatedArithmetic) and not isa.isFloat and isa.saturatedArithmetic, \"s\", \"\"),\n\t _sfx := self.ctype_suffix(o.t, isa),\n\t sfx := Cond( saturated=\"\", _epu_to_epi(_sfx), _sfx),\n\t CondPat(o,\n\t\t[add, @TVect, @TVect], self.printf(\"_mm_add$1_$2($3, $4)\", [saturated, sfx, o.args[1], o.args[2]]),\n\t\tError(\"Don't know how to unparse <o>. Unrecognized type combination\"))))),\n\n adds := (self, o, i, is) >> CondPat(o,\n\t\t[adds, @TVect, @TVect, ...],\n\t\t Cond( Length(o.args)>2,\n\t\t self(adds(o.args[1], brackets(ApplyFunc(adds, Drop(o.args, 1)))), i, is),\n\t\t self.printf(\"_mm_adds_$1($2, $3)\", [self.ctype_suffix(o.t, rec()), o.args[1], o.args[2]])),\n\t\tInherited(o, i, is)),\n\n _sub := (self, t, a, i, is) >> let(\n\tisa := _isa(self),\n\tsfx := _epu_to_epi(self.ctype_suffix(t, isa)),\n\tsaturated := When(IsBound(isa.isFloat) and IsBound(isa.saturatedArithmetic) and not isa.isFloat and isa.saturatedArithmetic, \"s\", \"\"),\n\tCondPat(a,\n [ListClass, @TVect, @TVect], self.printf(\"_mm_sub$1_$2($3, $4)\", [saturated, sfx, a[1], a[2]]),\n [ListClass, @, @], self.printf(\"($1 - ($2))\", a),\n Error(\"Don't know how to unparse subtraction of a[1] and a[2]. Unrecognized type combination\"))),\n\n sub := (self, o, i, is) >> self._sub(o.t, o.args, i, is),\n\n neg := (self, o, i, is) >> CondPat(o,\n [@, @TVect], self._sub(o.t, [o.t.zero(), o.args[1]], i, is),\n self.printf(\"(-$1)\", o.args)),\n\n stickyNeg := ~.neg,\n\n sqrt := (self, o, i, is) >> Cond( IsVecT(o.t),\n Checked( IsRealT(o.t.t), self.printf(\"_mm_sqrt_$1($2)\", [self.ctype_suffix(o.t, _isa(self)), o.args[1]])),\n Inherited(o, i, is)),\n\n rsqrt := (self, o, i, is) >> Cond( IsVecT(o.t), let( sfx := self.ctype_suffix(o.t, _isa(self)),\n Checked( sfx=\"ps\", self.printf(\"_mm_rsqrt_ps($1)\", [o.args[1]]))),\n Inherited(o, i, is)),\n\n # assuming we have ICC <ia32intrin.h> here\n log := (self, o, i, is) >> Cond( IsVecT(o.t), let( sfx := self.ctype_suffix(o.t, _isa(self)),\n Checked( sfx in [\"ps\", \"pd\"], Cond(\n Length(o.args)>1 and (o.args[2]=2 or o.args[2]=o.t.value(2)),\n self.printf(\"_mm_log2_$1($2)\", [sfx, o.args[1]]),\n Length(o.args)>1 and (o.args[2]=10 or o.args[2]=o.t.value(10)),\n self.printf(\"_mm_log10_$1($2)\", [sfx, o.args[1]]),\n Length(o.args)=1 or o.args[2]=d_exp(1) or o.args[2]=o.t.value(d_exp(1)),\n self.printf(\"_mm_log_$1($2)\", [sfx, o.args[1]]),\n self.printf(\"_mm_div_$1(_mm_log_$1($2), _mm_log_$1($3))\", [sfx, o.args[1]])))),\n Inherited(o, i, is)),\n\n # assuming we have ICC <ia32intrin.h> here\n exp := (self, o, i, is) >> Cond( IsVecT(o.t), let( sfx := self.ctype_suffix(o.t, _isa(self)),\n Checked( sfx in [\"ps\", \"pd\"], self.printf(\"_mm_exp_$1($2)\", [sfx, o.args[1]]))),\n Inherited(o, i, is)),\n\n # assuming we have ICC <ia32intrin.h> here\n pow := (self, o, i, is) >> Cond( IsVecT(o.t), let( sfx := self.ctype_suffix(o.t, _isa(self)),\n Checked( sfx in [\"ps\", \"pd\"], Cond(\n o.args[1]=2 or o.args[1]=o.t.value(2),\n self.printf(\"_mm_exp2_$1($2)\", [sfx, o.args[2]]),\n o.args[1]=d_exp(1) or o.args[1]=o.t.value(d_exp(1)),\n self.printf(\"_mm_exp_$1($2)\", [sfx, o.args[2]]),\n self.printf(\"_mm_pow_$1($2, $3)\", [sfx, o.args[1], o.args[2]])))),\n Inherited(o, i, is)),\n\n imod := (self, o, i, is) >> Cond( IsIntT(o.t.base_t()) and Is2Power(o.args[2]),\n # in two's complement arithmetics this will work for both positive and negative o.args[1]\n self(bin_and(o.args[1], o.args[2]-1), i, is),\n self.printf(\"(($1) % ($2))\", o.args)),\n\n # --------------------------------\n # logic\n #\n arith_shl := (self, o, i, is) >> self.prefix(_isa(self).vlshift, o.args),\n arith_shr := (self, o, i, is) >> CondPat( o,\n [arith_shr, @.cond(x->x.t=TVect(T_Int(32), 4)), @],\n self.prefix(\"_mm_srai_epi32\", o.args),\n [arith_shr, @.cond(x->x.t=TVect(T_Int(16), 8)), @],\n self.prefix(\"_mm_srai_epi16\", o.args),\n [arith_shr, @TVect, @],\n self.prefix(_isa(self).vrshift, o.args),\n Inherited(o, i, is)),\n\n bin_xor := (self, o, i, is) >> CondPat(o,\n [bin_xor, @TVect, @TVect], self.prefix(\"_mm_xor_si128\", o.args),\n Inherited(o, i, is)),\n bin_and := (self, o, i, is) >> CondPat(o,\n [bin_and, @TVect, @TVect], self.prefix(\"_mm_and_si128\", o.args),\n Inherited(o, i, is)),\n\n bin_andnot := (self, o, i, is) >> self.prefix(\"_mm_andnot_si128\", o.args),\n\n bin_or := (self, o, i, is) >> CondPat(o,\n [bin_or, @TVect, @TVect], let(sfx := self.ctype_suffix(o.t, _isa(self)),\n\t Cond( not (sfx in [\"ps\", \"pd\", \"ps_half\"]), #was: _isa(self).isFixedPoint,\n\t\tself.printf(\"_mm_or_si128($1, $2)\", o.args),\n\t\tself.printf(\"_mm_castsi128_$3(_mm_or_si128(_mm_cast$3_si128($1), _mm_cast$3_si128($2)))\",\n\t\t o.args :: [sfx]))),\n [bin_or, @TReal, @TReal], self.printf(\"(($1) | ($2))\", o.args),\n\n\tInherited(o, i, is)),\n\n min := (self, o, i, is) >> CondPat(o,\n [min, @TVect, @TVect], self.prefix(\"_mm_min_\" :: self.ctype_suffix(o.t, _isa(self)), o.args),\n Inherited(o, i, is)),\n\n max := (self, o, i, is) >> let(n := Length(o.args), When(\n \tIsVecT(o.t) and n > 2, self.printf(\"_mm_max_$1($2, $3)\", [self.ctype_suffix(o.t, _isa(self)), o.args[1], ApplyFunc(max, Drop(o.args, 1))]),\n CondPat(o,\n [max, @TVect, @TVect], self.prefix(\"_mm_max_\" :: self.ctype_suffix(o.t, _isa(self)), o.args),\n Inherited(o, i, is)))),\n\n abs := (self, o, i, is) >> CondPat(o,\n [abs, @TVect], let( sfx := self.ctype_suffix(o.t, _isa(self)),\n Cond( sfx = \"ps\", self.printf(\"_mm_castsi128_ps(_mm_and_si128(_mm_castps_si128($1), _mm_set_epi32(0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF)))\", o.args),\n sfx = \"pd\", self.printf(\"_mm_castsi128_pd(_mm_and_si128(_mm_castpd_si128($1), _mm_set_epi32(0x7FFFFFFF, 0xFFFFFFFF, 0x7FFFFFFF, 0xFFFFFFFF)))\", o.args),\n Error(\"not implemented\"))),\n Inherited(o, i, is)),\n\n bin_shl := (self, o, i, is) >> CondPat(o,\n [bin_shl, @TVect, @TInt], let(\n sfx := self.ctype_suffix(o.t, _isa(self)),\n\t Cond( _isa(self).isFixedPoint, # legacy\n\t\t self.printf(\"_mm_slli_si128($1, $2)\", o.args), # legacy\n\t\t sfx in [\"epi16\", \"epi32\", \"epi64\", \"epu16\", \"epu32\", \"epu64\"],\n\t\t self.printf(\"_mm_slli_$3($1, $2)\", o.args :: [_epu_to_epi(sfx)]),\n\t\t sfx in [\"epi8\", \"epu8\"],\n\t\t Error(\"bin_shl is undefined for epi8 and epu8\"),\n\t\t sfx in [\"epi128\", \"epu128\"], # shift with byte granularity\n\t\t self.printf(\"_mm_slli_si128($1, $2)\", [o.args[1], idiv(o.args[2], 8)] ),\n\t\t # else, shift whole register with shift argument specified in bytes (legacy, fix using epi128 in ISAs first)\n\t\t self.printf(\"_mm_castsi128_$3(_mm_slli_si128(_mm_cast$3_si128($1), $2))\", o.args :: [sfx]))),\n [bin_shl, @TReal, @TInt], self.printf(\"(($1) << ($2))\", o.args),\n [bin_shl, @TInt, @TInt], self.printf(\"(($1) << ($2))\", o.args),\n [bin_shl, @, @], self.prefix(\"_mm_slli_\" :: self.ctype_suffix(o.t, _isa(self)), o.args)),\n\n bin_shr := (self, o, i, is) >> CondPat(o,\n [bin_shr, @TVect, @TInt], let(\n sfx := self.ctype_suffix(o.t, _isa(self)),\n\t Cond( _isa(self).isFixedPoint, # legacy\n\t\t self.printf(\"_mm_srli_si128($1, $2)\", o.args), # legacy\n\t\t sfx in [\"epi16\", \"epi32\", \"epi64\", \"epu16\", \"epu32\", \"epu64\"],\n\t\t self.printf(\"_mm_srli_$3($1, $2)\", o.args :: [_epu_to_epi(sfx)]),\n\t\t sfx in [\"epi8\", \"epu8\"],\n\t\t Error(\"bin_shr is undefined for epi8 and epu8\"),\n\t\t sfx in [\"epi128\", \"epu128\"], # shift with byte granularity\n\t\t self.printf(\"_mm_srli_si128($1, $2)\", [o.args[1], idiv(o.args[2], 8)] ),\n\t\t # else, shift whole register with shift argument specified in bytes (legacy, fix using epi128 in ISAs first)\n\t\t self.printf(\"_mm_castsi128_$3(_mm_srli_si128(_mm_cast$3_si128($1), $2))\", o.args :: [sfx]))),\n\t# default\n\t[bin_shr, @TReal, @TInt], self.printf(\"(($1) >> ($2))\", o.args),\n\t[bin_shr, @TInt, @TInt], self.printf(\"(($1) >> ($2))\", o.args),\n\t# what's this?\n\t[bin_shr, @, @], self.prefix(\"_mm_srli_\" :: self.ctype_suffix(o.t, _isa(self)), o.args)),\n\n # vector shifts\t\n vec_shr := (self, o, i, is) >> let(\n isa := _isa(self),\n sfx := self.ctype_suffix(o.t, isa),\n # making sure this is SSE data type\n t := Checked(IsVecT(o.t) and sfx<>\"\", o.t),\n a := o.args[1],\n s := o.args[2] * 16 / t.size,\n # may need typecasts to please compiler\n Cond( self.ctype(t, isa)=\"__m128i\",\n self.printf(\"_mm_srli_si128($1, $2)\", [a, s] ),\n self.printf(\"_mm_castsi128_$3(_mm_srli_si128(_mm_cast$3_si128($1), $2))\", [a, s, sfx])\n )),\n\n vec_shl := (self, o, i, is) >> let(\n isa := _isa(self),\n sfx := self.ctype_suffix(o.t, isa),\n # making sure this is SSE data type\n t := Checked(IsVecT(o.t) and sfx<>\"\", o.t),\n a := o.args[1],\n s := o.args[2] * 16 / t.size,\n # may need typecasts to please compiler\n Cond( self.ctype(t, isa)=\"__m128i\",\n self.printf(\"_mm_slli_si128($1, $2)\", [a, s] ),\n self.printf(\"_mm_castsi128_$3(_mm_slli_si128(_mm_cast$3_si128($1), $2))\", [a, s, sfx])\n )),\n\n # --------------------------------\n # comparison\n #\n eq := (self, o, i, is) >> let( ctype := self.ctype_suffix(o.args[1].t, _isa(self)),\n sfx := _epu_to_epi(ctype),\n Cond(IsVecT(o.t), self.prefix(\"_mm_cmpeq_\" :: sfx, o.args),\n Inherited(o, i, is))),\n\n lt := (self, o, i, is) >> Cond(IsVecT(o.t),\n self.prefix(\"_mm_cmplt_\" :: self.ctype_suffix(o.args[1].t, _isa(self)), o.args),\n Inherited(o, i, is)),\n\n gt := (self, o, i, is) >> Cond(ObjId(o.t)=TVect,\n self.prefix(\"_mm_cmpgt_\" :: self.ctype_suffix(o.args[1].t, _isa(self)), o.args),\n Inherited(o, i, is)),\n\n mask_eq := ~.eq,\n mask_lt := ~.lt,\n mask_gt := ~.gt,\n\n vparam := (self, o, i, is) >> iclshuffle(o.p),\n\n # --------------------------------\n # ISA specific : SSE_2x64f\n #\n vunpacklo_2x64f := (self, o, i, is) >> self.prefix(\"_mm_unpacklo_pd\", o.args),\n vunpackhi_2x64f := (self, o, i, is) >> self.prefix(\"_mm_unpackhi_pd\", o.args),\n vshuffle_2x64f := (self, o, i, is) >> self.prefix(\"_mm_shuffle_pd\", o.args),\n vushuffle_2x64f := (self, o, i, is) >> self(o.binop(o.args[1], o.args[1], o.args[2]), i, is),\n\n vload1sd_2x64f := (self, o, i, is) >> self.prefix(\"_mm_load_sd\", o.args),\n vload_1l_2x64f := (self, o, i, is) >> self.prefix(\"_mm_loadl_pd\", o.args),\n vload_1h_2x64f := (self, o, i, is) >> self.prefix(\"_mm_loadh_pd\", o.args),\n vloadu_2x64f := (self, o, i, is) >> self.prefix(\"_mm_loadu_pd\", o.args),\n\n vstore_1l_2x64f := (self, o, i, is) >> Print(Blanks(i), self.prefix(\"_mm_storel_pd\", o.args), \";\\n\"),\n vstore_1h_2x64f := (self, o, i, is) >> Print(Blanks(i), self.prefix(\"_mm_storeh_pd\", o.args), \";\\n\"),\n vstoreu_2x64f := (self, o, i, is) >> Print(Blanks(i), self.prefix(\"_mm_storeu_pd\", o.args), \";\\n\"),\n\n addsub_2x64f := (self, o, i, is) >> Checked(Length(o.args) = 2,\n CondPat(o,\n [addsub_2x64f, @TReal, @TVect], self(addsub_2x64f(vdup(o.args[1],o.t.size), o.args[2]), i, is),\n [addsub_2x64f, @TVect, @TReal], self(addsub_2x64f(o.args[1], vdup(o.args[2], o.t.size)), i, is),\n [addsub_2x64f, @TInt, @TVect], self(addsub_2x64f(vdup(_toReal(o.args[1]), o.t.size), o.args[2]), i, is),\n [addsub_2x64f, @TVect, @TInt], self(addsub_2x64f(o.args[1], vdup(_toReal(o.args[2]), o.t.size)), i, is),\n [addsub_2x64f, @TVect, @TVect], self.printf(\"_mm_addsub_pd($1, $2)\", o.args),\n Error(\"Don't know how to unparse <o>. Unrecognized type combination\")\n )),\n\n hadd_2x64f := (self, o, i, is) >> self.printf(\"_mm_hadd_pd($1, $2)\", [o.args[1], o.args[2]]),\n\n chslo_2x64f := (self, o, i, is) >> self.printf(\n\t\"_mm_castsi128_pd(_mm_xor_si128(_mm_castpd_si128($1), _mm_set_epi32(0, 0, 0x80000000, 0)))\", o.args),\n chshi_2x64f := (self, o, i, is) >> self.printf(\n\t\"_mm_castsi128_pd(_mm_xor_si128(_mm_castpd_si128($1), _mm_set_epi32(0x80000000, 0, 0, 0)))\", o.args),\n chshi_4x32f := (self, o, i, is) >> self.printf(\n\t\"_mm_castsi128_ps(_mm_xor_si128(_mm_castps_si128($1), _mm_set_epi32(0x80000000, 0, 0x80000000, 0)))\", o.args),\n chslo_4x32f := (self, o, i, is) >> self.printf(\n\t\"_mm_castsi128_ps(_mm_xor_si128(_mm_castps_si128($1), _mm_set_epi32(0, 0x80000000, 0, 0x80000000)))\", o.args),\n\n vcvt_64f32f := (self, o, i, is) >> self.prefix(\"_mm_cvtps_pd\", o.args),\n\n cmpge_2x64f := (self, o, i, is) >> self.prefix(\"_mm_cmpge_pd\", o.args),\n\n cmple_2x64f := (self, o, i, is) >> self.prefix(\"_mm_cmple_pd\", o.args),\n cmpeq_2x64f := (self, o, i, is) >> self.prefix(\"_mm_cmpeq_pd\", o.args),\n\n\n # --------------------------------\n # ISA specific : SSE_2x32f\n #\n vunpacklo_2x32f := (self, o, i, is) >> self.prefix(\"_mm_unpacklo_ps\", o.args),\n vunpackhi_2x32f := (self, o, i, is) >> self.prefix(\"_mm_unpackhi_ps\", o.args),\n vshuffle_2x32f := (self, o, i, is) >> self.prefix(\"_mm_shuffle_ps\", o.args),\n vushuffle_2x32f := (self, o, i, is) >> self(o.binop(o.args[1], o.args[1], o.args[2]), i, is),\n vload_2x32f := (self, o, i, is) >> self.prefix(\"_mm_loadl_pi\", o.args),\n vstore_2x32f := (self, o, i, is) >> Print(Blanks(i), self.prefix(\"_mm_storel_pi\", o.args), \";\\n\"),\n vstoreu_2x32f := (self, o, i, is) >> Print(Blanks(i), self.printf(\"_mm_storel_epi64($1, _mm_castps_si128($2));\\n\", o.args)),\n vloadu_2x32f := (self, o, i, is) >> self.printf(\"_mm_castsi128_ps(_mm_loadl_epi64($1))\", o.args),\n\n # --------------------------------\n # ISA specific : SSE_4x32f\n #\n prefix_cast := (self, prefix, t, o) >> Cond( self.ctype(t, _isa(self)) = self.ctype(o.t, _isa(self)), self.prefix(prefix, o.args),\n self(tcast(o.t, ApplyFunc(ObjId(o), List(o.args, a -> Cond(IsExp(a), tcast(t, a), a)))), 0, 1)),\n\n vunpacklo_4x32f := (self, o, i, is) >> self.prefix_cast(\"_mm_unpacklo_ps\", TVect(T_Real(32), 4), o),\n vunpackhi_4x32f := (self, o, i, is) >> self.prefix_cast(\"_mm_unpackhi_ps\", TVect(T_Real(32), 4), o),\n vshuffle_4x32f := (self, o, i, is) >> self.prefix_cast(\"_mm_shuffle_ps\", TVect(T_Real(32), 4), o),\n vushuffle_4x32f := (self, o, i, is) >> self(o.binop(o.args[1], o.args[1], o.args[2]), i, is),\n hadd_4x32f := (self, o, i, is) >> self.printf(\"_mm_hadd_ps($1, $2)\", [o.args[1], o.args[2]]),\n vldup_4x32f := (self, o, i, is) >> self.prefix(\"_mm_moveldup_ps\", o.args),\n vhdup_4x32f := (self, o, i, is) >> self.prefix(\"_mm_movehdup_ps\", o.args),\n\n vinsert_4x32f := (self, o, i, is) >> self.printf(\n\t\"_mm_castsi128_ps(_mm_insert_epi32(_mm_castps_si128($1), $2, $3))\", [o.args[1], o.args[2], o.args[3].p-1]),\n vextract_4x32f := (self, o, i, is) >> Print(Blanks(i),\n\tself.printf(\"$1 = _mm_extract_ps($2, $3)\", [deref(o.args[1]), o.args[2], o.args[3]-1]), \";\\n\"),\n\n vload1_4x32f := (self, o, i, is) >> self.prefix(\"_mm_load_ss\", o.args),\n vload_2l_4x32f := (self, o, i, is) >> self.prefix(\"_mm_loadl_pi\", o.args),\n vload_2h_4x32f := (self, o, i, is) >> self.prefix(\"_mm_loadh_pi\", o.args),\n vloadu_4x32f := (self, o, i, is) >> self.printf(\"_mm_loadu_ps($1)\", o.args),\n vloadu2_4x32f := (self, o, i, is) >> self.printf(\"_mm_castsi128_ps(_mm_loadl_epi64($1))\", o.args),\n\n vstore1_4x32f := (self, o, i, is) >> Print(Blanks(i), self.prefix(\"_mm_store_ss\", o.args), \";\\n\"),\n vstore_2l_4x32f := (self, o, i, is) >> Print(Blanks(i), self.prefix(\"_mm_storel_pi\", o.args), \";\\n\"),\n vstore_2h_4x32f := (self, o, i, is) >> Print(Blanks(i), self.prefix(\"_mm_storeh_pi\", o.args), \";\\n\"),\n vstoreu_4x32f := (self, o, i, is) >> Print(Blanks(i), self.prefix(\"_mm_storeu_ps\", o.args), \";\\n\"),\n vstoreu2_4x32f := (self, o, i, is) >> Print(Blanks(i), self.printf(\"_mm_storel_epi64($1, _mm_castps_si128($2));\\n\",\n o.args)),\n\n vstoremsk_4x32f := (self, o, i, is) >> Print(Blanks(i),\n\tself.printf(\"_mm_maskmoveu_si128(_mm_castps_si128($2), _mm_set_epi32($3, $4, $5, $6), $1);\\n\",\n [o.args[1], o.args[2]] :: List(Reversed(o.args[3].v), e->e.v))),\n\n alignr_4x32f := (self, o, i, is) >> self.printf(\n\t\"_mm_castsi128_ps(_mm_alignr_epi8(_mm_castps_si128($1), _mm_castps_si128($2), $3))\", [o.args[1], o.args[2], o.args[3].p]),\n\n # --------------------------------\n # ISA specific : SSE_8x16i\n #\n vzero_8x16i := (self, o, i, is) >> Print(\"_mm_setzero_si128()\"),\n\n vunpacklo_8x16i := (self, o, i, is) >> self.prefix(\"_mm_unpacklo_epi16\", o.args),\n vunpackhi_8x16i := (self, o, i, is) >> self.prefix(\"_mm_unpackhi_epi16\", o.args),\n vunpacklo2_8x16i := (self, o, i, is) >> self.prefix(\"_mm_unpacklo_epi32\", o.args),\n vunpackhi2_8x16i := (self, o, i, is) >> self.prefix(\"_mm_unpackhi_epi32\", o.args),\n vunpacklo4_8x16i := (self, o, i, is) >> self.prefix(\"_mm_unpacklo_epi64\", o.args),\n vunpackhi4_8x16i := (self, o, i, is) >> self.prefix(\"_mm_unpackhi_epi64\", o.args),\n\n vpacks_8x16i := (self, o, i, is) >> self.prefix(\"_mm_packs_epi16\", o.args),\n vpackus_8x16i := (self, o, i, is) >> self.prefix(\"_mm_packus_epi16\", o.args),\n\n vshuffle2_8x16i := (self, o, i, is) >> self.printf(\n\t\"_mm_castps_si128(_mm_shuffle_ps(_mm_castsi128_ps($1), _mm_castsi128_ps($2), $3))\", o.args),\n\n vshuffle4_8x16i := (self, o, i, is) >> self.printf(\n\t\"_mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd($1), _mm_castsi128_pd($2), $3))\", o.args),\n\n vload1_8x16i := (self, o, i, is) >> self.printf(\"_mm_insert_epi16($1, $2, $3)\", o.args),\n vload2_8x16i := (self, o, i, is) >> self.prefix(\"_mm_cvtsi32_si128\", o.args),\n vload4_8x16i := (self, o, i, is) >> self.prefix(\"_mm_loadl_epi64\", o.args),\n vloadu_8x16i := (self, o, i, is) >> self.prefix(\"_mm_loadu_si128\", o.args),\n\n vextract1_8x16i := (self, o, i, is) >> self.prefix(\"_mm_extract_epi16\", o.args),\n vextract2_8x16i := (self, o, i, is) >> self.prefix(\"_mm_cvtsi128_si32\", o.args),\n vstoreu_8x16i := (self, o, i, is) >> Print(Blanks(i), self.prefix(\"_mm_storeu_si128\", o.args), \";\\n\"),\n vstore4_8x16i := (self, o, i, is) >> Print(Blanks(i), self.prefix(\"_mm_storel_epi64\", o.args), \";\\n\"),\n vstoremsk_8x16i := (self, o, i, is) >> Print(Blanks(i),\n\tself.printf(\"_mm_maskmoveu_si128($2, _mm_set_epi16($3), $1);\\n\",\n [o.args[1], o.args[2], () -> PrintCS(Reversed(o.args[3]))])),\n\n vushuffle2_8x16i := (self, o, i, is) >> self(o.binop(o.args[1], o.args[1], o.args[2]), i, is),\n vushufflelo_8x16i := (self, o, i, is) >> self.prefix(\"_mm_shufflelo_epi16\", o.args),\n vushufflehi_8x16i := (self, o, i, is) >> self.prefix(\"_mm_shufflehi_epi16\", o.args),\n\n interleavedmask_8x16i := (self, o, i, is) >> self.printf(\n\t\"_mm_movemask_epi8(_mm_unpacklo_epi8(_mm_packs_epi16($1, _mm_setzero_si128()), _mm_packs_epi16($2, _mm_setzero_si128())))\",\n\to.args),\n\n alignr_8x16i := (self, o, i, is) >> self.printf(\"_mm_alignr_epi8($1, $2, $3)\", [o.args[1], o.args[2], o.args[3].p]),\n\n # FF: NOTE: couldnt figure out how to use the general case with type propagation etc...\n cmplt_8x16i := (self, o, i, is) >> self.printf(\"_mm_cmplt_epi16($1, $2)\", o.args),\n\n # SSSE3 8x16i instructions\n chs_8x16i := (self, o, i, is) >> self.prefix(\"_mm_sign_epi16\", o.args),\n vushuffle_8x16i := (self, o, i, is) >> self.prefix(\"_mm_shuffle_epi8\", o.args),\n\n # --------------------------------\n # ISA specific : SSE_16x8i\n #\n vloadu_16x8i := (self, o, i, is) >> self.prefix(\"_mm_loadu_si128\", o.args),\n vstoreu_16x8i := (self, o, i, is) >> Print(Blanks(i), self.prefix(\"_mm_storeu_si128\", o.args), \";\\n\"),\n\n vunpacklo_16x8i := (self, o, i, is) >> self.prefix(\"_mm_unpacklo_epi8\", o.args),\n vunpackhi_16x8i := (self, o, i, is) >> self.prefix(\"_mm_unpackhi_epi8\", o.args),\n vunpacklo2_16x8i := (self, o, i, is) >> self.prefix(\"_mm_unpacklo_epi16\", o.args),\n vunpackhi2_16x8i := (self, o, i, is) >> self.prefix(\"_mm_unpackhi_epi16\", o.args),\n vunpacklo4_16x8i := (self, o, i, is) >> self.prefix(\"_mm_unpacklo_epi32\", o.args),\n vunpackhi4_16x8i := (self, o, i, is) >> self.prefix(\"_mm_unpackhi_epi32\", o.args),\n vunpacklo8_16x8i := (self, o, i, is) >> self.prefix(\"_mm_unpacklo_epi64\", o.args),\n vunpackhi8_16x8i := (self, o, i, is) >> self.prefix(\"_mm_unpackhi_epi64\", o.args),\n\n vushufflelo2_16x8i := (self, o, i, is) >> self.prefix(\"_mm_shufflelo_epi16\", o.args),\n vushufflehi2_16x8i := (self, o, i, is) >> self.prefix(\"_mm_shufflehi_epi16\", o.args),\n vushuffle4_16x8i := (self, o, i, is) >> self.prefix(\"_mm_shuffle_epi32\", o.args),\n\n interleavedmasklo_16x8i := (self, o, i, is) >> Print(\"_mm_movemask_epi8(_mm_unpacklo_epi8(\",o.args[1],\",\",o.args[2],\"))\"),\n interleavedmaskhi_16x8i := (self, o, i, is) >> Print(\"_mm_movemask_epi8(_mm_unpackhi_epi8(\",o.args[1],\",\",o.args[2],\"))\"),\n average_16x8i := (self, o, i, is) >> Print(\"_mm_avg_epu8(\",o.args[1],\",\",o.args[2],\")\"),\n vmovemask_16x8i := (self, o, i, is) >> self.prefix(\"_mm_movemask_epi8\", o.args),\n\n # XXX NOTE XXXX\n # Also fix other vstoremsk's. The problem here is that after latest changes to Spiral\n # the last argument (list of strings) in vstoremsg gets wrapped into V, and strings too\n # this is super stupid+ugly\n vstoremsk_16x8i := (self, o, i, is) >> Print(Blanks(i), self.printf(\"_mm_maskmoveu_si128($2, _mm_set_epi8($3), $1);\\n\",\n [o.args[1], o.args[2], () -> PrintCS(Reversed(List(_unwrapV(o.args[3]), _unwrapV)))])),\n\n addsub_4x32f := (self, o, i, is) >> Checked(Length(o.args) = 2,\n CondPat(o,\n [addsub_4x32f, @TReal, @TVect], self(addsub_4x32f(vdup(o.args[1],o.t.size), o.args[2]), i, is),\n [addsub_4x32f, @TVect, @TReal], self(addsub_4x32f(o.args[1], vdup(o.args[2],o.t.size)), i, is),\n [addsub_4x32f, @TInt, @TVect], self(addsub_4x32f(vdup(_toReal(o.args[1]),o.t.size), o.args[2]), i, is),\n [addsub_4x32f, @TVect, @TInt], self(addsub_4x32f(o.args[1], vdup(_toReal(o.args[2]),o.t.size)), i, is),\n [addsub_4x32f, @TVect, @TVect], self.printf(\"_mm_addsub_ps($1, $2)\", [o.args[1], o.args[2]]),\n Error(\"Don't know how to unparse <o>. Unrecognized type combination\")\n )),\n\n hadd_4x32f := (self, o, i, is) >> self.printf(\"_mm_hadd_ps($1, $2)\", [o.args[1], o.args[2]]),\n\n vloadu_16x8i := (self, o, i, is) >> self.prefix(\"_mm_loadu_si128\", o.args),\n\n # --------------------------------\n # ISA specific : SSE_4x32i\n #\n vunpacklo_4x32i := (self, o, i, is) >> self.prefix(\"_mm_unpacklo_epi32\", o.args),\n vunpackhi_4x32i := (self, o, i, is) >> self.prefix(\"_mm_unpackhi_epi32\", o.args),\n vpacks_4x32i := (self, o, i, is) >> self.prefix(\"_mm_packs_epi32\", o.args),\n # 32 bit integer shuffles are *not* the same as 32 bit float, but similar to 16 bit integer shuffles\n vushuffle_4x32i := (self, o, i, is) >> self.prefix(\"_mm_shuffle_epi32\", o.args),\n vshuffle_4x32i := (self, o, i, is) >> self.printf(\n\t\"_mm_castps_si128(_mm_shuffle_ps(_mm_castsi128_ps($1), _mm_castsi128_ps($2), $3))\", o.args),\n\n # subvector unparsing not yet done...\n vload1_4x32i := (self, o, i, is) >> self.prefix(\"_mm_cvtsi32_si128\", o.args), #svpcprint guy\n vload2_4x32i := (self, o, i, is) >> self.prefix(\"_mm_loadl_epi64\", o.args),\n vload2_4x32i := (self, o, i, is) >> self.prefix(\"_mm_loadl_epi64\", o.args),\n vloadu_4x32i := (self, o, i, is) >> self.prefix(\"_mm_loadu_si128\", o.args),\n\n vextract_4x32i := (self, o, i, is) >> self.prefix(\"_mm_cvtsi128_si32\", o.args),\n vstoreu_4x32i := (self, o, i, is) >> Print(Blanks(i), self.prefix(\"_mm_storeu_si128\", o.args), \";\\n\"),\n vstore2_4x32i := (self, o, i, is) >> Print(Blanks(i), self.prefix(\"_mm_storel_epi64\", o.args), \";\\n\"),\n vstoremsk_4x32i := (self, o, i, is) >> Print(Blanks(i),\n\tself.printf(\"_mm_maskmoveu_si128($2, _mm_set_epi16($3), $1);\\n\", [o.args[1], o.args[2], ()->PrintCS(Reversed(o.args[3]))])),\n # complicated, buggy\n\n interleavedmask_4x32i := (self, o, i, is) >> self.printf(\n\t\"_mm_movemask_epi8(_mm_packs_epi16(_mm_unpacklo_epi16(_mm_packs_epi16($1, $3), _mm_packs_epi16($2, $3)), $3))\",\n\to.args :: [\"_mm_setzero_si128()\"]),\n\n vcvt_4x32_i2f := (self, o, i, is) >> self.prefix(\"_mm_cvtepi32_ps\", o.args),\n vcvt_4x32_f2i := (self, o, i, is) >> self.prefix(\"_mm_cvtps_epi32\", o.args),\n vcvtt_4x32_f2i := (self, o, i, is) >> self.prefix(\"_mm_cvttps_epi32\", o.args),\n\n testz_4x32i := (self, o, i, is) >> self.prefix(\"_mm_testz_si128\", o.args),\n testc_4x32i := (self, o, i, is) >> self.prefix(\"_mm_testc_si128\", o.args),\n testnzc_4x32i := (self, o, i, is) >> self.prefix(\"_mm_testnzc_si128\", o.args),\n\n # --------------------------------\n # ISA specific : SSE_2x64i\n #\n vunpacklo_2x64i := (self, o, i, is) >> self.prefix(\"_mm_unpacklo_epi64\", o.args),\n vunpackhi_2x64i := (self, o, i, is) >> self.prefix(\"_mm_unpackhi_epi64\", o.args),\n vshuffle_2x64i := (self, o, i, is) >> self.printf(\n\t\"_mm_castpd_si128(_mm_shuffle_pd(_mm_castsi128_pd($1), _mm_castsi128_pd($2), $3))\", o.args),\n vushuffle_2x64i := (self, o, i, is) >> self(o.binop(o.args[1], o.args[1], o.args[2]), i, is),\n\n # --------------------------------\n # tcast __m128 <-> __m128i\n\n tcast := (self, o, i, is) >> let(\n isa := _isa(self),\n i128 := @.cond(x-> let( t := When(IsType(x), x, x.t), IsVecT(t) and self.ctype(t, isa)=\"__m128i\")),\n f128 := @.cond(x-> let( t := When(IsType(x), x, x.t), IsVecT(t) and self.ctype(t, isa)=\"__m128\" )),\n d128 := @.cond(x-> let( t := When(IsType(x), x, x.t), IsVecT(t) and self.ctype(t, isa)=\"__m128d\" )),\n CondPat(o,\n [tcast, i128, f128], self.prefix(\"_mm_castps_si128\", [o.args[2]]),\n [tcast, i128, d128], self.prefix(\"_mm_castpd_si128\", [o.args[2]]),\n [tcast, f128, i128], self.prefix(\"_mm_castsi128_ps\", [o.args[2]]),\n [tcast, i128, i128], self(o.args[2], i, is),\n [tcast, f128, f128], self(o.args[2], i, is),\n Inherited(o, i, is))),\n\n tcvt := (self, o, i, is) >> self.printf(\"(($1)($2))\", [o.args[1], o.args[2]]),\n\n #NOTE: finish this, it should look at TVect.size and instruction set for figuring out exactly what to do\n vcastizxlo := (self, o, i, is) >> self(vunpacklo_16x8i(o.args[1], o.t.zero()), i, is),\n vcastizxhi := (self, o, i, is) >> self(vunpackhi_16x8i(o.args[1], o.t.zero()), i, is),\n vcastuzxlo := ~.vcastizxlo,\n vcastuzxhi := ~.vcastizxhi,\n\n average := (self, o, i, is) >> CondPat(o,\n [average, @TVect, @TVect], let(\n sfx := self.ctype_suffix(o.t, _isa(self)),\n Cond( sfx in [\"epu8\", \"epu16\"],\n self.printf(\"_mm_avg_$1($2, $3)\",[sfx, o.args[1],o.args[2]]),\n Error(\"finish SSE unparser\"))),\n Inherited(o, i, is)),\n));\n", "meta": {"hexsha": "e2d29f8cba955eb9ec22cd88d20979777954b4f8", "size": 39138, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/platforms/sse/unparse.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/platforms/sse/unparse.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/platforms/sse/unparse.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 50.5658914729, "max_line_length": 186, "alphanum_fraction": 0.5567734682, "num_tokens": 14356, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.45713670203584295, "lm_q2_score": 0.027585281427362537, "lm_q1q2_score": 0.0126102445764351}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\n#Class(MultiBufBB, RuleSet);\n#RewriteRules(MultiBufBB, rec(\n# remove_bbs := Rule(@(1, Compose, e->ForAll(e.children(), c->ObjId(c)=DistSum)),\n# e -> ComposeDists(@(1).val.children()) )\n#));\n\napplyCellInplace := function(sums, opts)\n SubstBottomUp(sums, GathDist, e->Inplace(e));\n SubstBottomUp(sums, GathRecv, e->Inplace(e));\n SubstBottomUp(sums, ScatDist, e->Inplace(e));\n\n SubstBottomUp(sums, ScatMem, e->Inplace(e));\n SubstBottomUp(sums, GathMem, e->Inplace(e));\n\n\n # BB(Inplace()) -> Inplace() (So that a copy operation need not take place)\n SubstBottomUp(sums, [BB, Inplace], e->e.rChildren()[1]);\n return(sums);\nend;\n\n\n#s := SubstBottomUp(s, ScatMem, e->Inplace(e));\n#s := SubstBottomUp(s, GathMem, e->Inplace(e));\n#s := SubstBottomUp(s, [BB, Inplace], e->e.rChildren()[1]);\n\n\n# DistSum(Scat__ * MultiBufISum() * Gath__) -> DistSumLoop(MultiBufISum(ScatMem * () * GathMem))\n\n# DistSum has to be converted to a DistSumLoop because DistSum expects its Scat\n# and Gath to span the entire expanse of the computation, and therefore assumes\n# an appropriate Scat/Gath. DistSumLoop does not.\n\n\ndoMultiBufBC := function(sums, opts)\n Error(\"doMultiBufBC: BP\");\n return(sums);\nend;\n\n#F Dist(MultiBuf) is for independent DFTs running on separate SPEs (or sets of\n#F SPEs), each multibuffered separately\nClass(DistMultiBuf, RuleSet);\n\nRewriteRules(DistMultiBuf, rec(\n # HACK: rule assumes we do only independent DFTs\n join_dist_multibuf_compose := Rule([@(1,DistSum), @, @(2,Compose, e->Length(Collect(e.rChildren()[1], MultiBufISum))=1) ],\n e -> let(\n dsum := @(1).val,\n Error(\"\"),\n msum := Collect(@(2).val, MultiBufISum)[1],\n sp := Collect(dsum, @(3,[ScatDist, ScatSend]))[1],\n sm := msum.scatmem,\n sdm := fCompose(sp.func, fTensor(sm.func, fId(sm.pkSize/sp.pkSize))),\n \n gp := Collect(dsum, @(3,[GathDist, GathRecv]))[1],\n gm := msum.gathmem,\n gdm := fCompose(gp.func, fTensor(gm.func, fId(gm.pkSize/gp.pkSize))),\n \n DistSumLoop(dsum.P, dsum.var, dsum.domain,\n MultiBufISum(msum.var, msum.domain,\n #ScatDirectMem(sdm, sp.pkSize, dsum.P, dsum.var),\n ScatMem(sdm, sp.pkSize),\n msum.rChildren()[2],\n #GathDirectMem(gdm, gp.pkSize, dsum.P, dsum.var)\n GathMem(gdm, gp.pkSize)\n ) \n )\n )\n ),\n\n join_dist_multibuf_separate := Rule(@(1, DistSum, e->Length(Collect(e.rChildren()[2], MultiBufISum))=1),\n e -> let(\n dsum := @(1).val,\n msum := Collect(@(1).val, MultiBufISum)[1],\n\n sp := Collect(dsum, @(3,[ScatDist, ScatSend]))[1],\n sm := msum.scatmem,\n spm := fCompose(fTensor(sp.func, fId(sp.pkSize/sm.pkSize)), sm.func),\n\n \n gp := Collect(dsum, @(3,[GathDist, GathRecv]))[1],\n gm := msum.gathmem,\n gpm := fCompose(fTensor(gp.func, fId(gp.pkSize/gm.pkSize)), gm.func),\n\n \n DistSumLoop(dsum.P, dsum.var, dsum.domain,\n MultiBufISum(msum.var, msum.domain,\n #ScatDirectMem(spm, sp.pkSize, dsum.P, dsum.var),\n ScatMem(spm, sm.pkSize),\n msum.rChildren()[2],\n #GathDirectMem(gpm, gp.pkSize, dsum.P, dsum.var)\n GathMem(gpm, gm.pkSize)\n ) \n )\n )\n )\n\n));\n\n#F MultiBuf(Dist) is for parallel DFTs that are multibuffered\n#F We pull out a parallel scat (gath) function into the multibufisum's scat (gath) function\n#F Sums becomes invalid (strictly speaking) because we now use loop vars outside of their definition.\nClass(MultiBufDist, RuleSet);\nRewriteRules(MultiBufDist, rec(\n # This has to be done exactly once, else will loop infinitely. Look at hack below\n #NOTE: The rule below doesn't seem to fire. Probably doesn't match becacuse of the # of @'s at the end in this line:\n join_multibuf_dist_compose := Rule([@(1,[MultiBufISum,MemISum]), @(2,[Compose,ComposeDists], e->Length(Collect(e.rChildren()[2], DistSum))=1), @, @ ],\n e -> let(\n\n #HACK: clean way of getting the right gath/scat is to ask for the Compose's leftmost Scat/Gath\n msum := @(1).val,\n dsums := Collect(@(2).val, DistSum),\n dsum1 := dsums[1],\n dsum2 := dsums[Length(dsums)],\n\n sd := Collect(dsum1, @(3,[ScatDist, ScatSend]))[1],\n sm := msum.scatmem,\n sdm := fCompose(fTensor(sm.func, fId(sm.pkSize/sd.pkSize)), sd.func),\n \n gd := Collect(dsum2, @(3,[GathDist, GathRecv]))[1],\n gm := msum.gathmem,\n gdm := fCompose(fTensor(gm.func, fId(gm.pkSize/gd.pkSize)), gd.func),\n\n isum := When(ObjId(@(1).val)=MultiBufISum, MultiBufISumFinal, MemISumFinal),\n\n # HACK: Converting to a MultiBufISumFinal so this rule won't match more than once\n isum(msum.var, msum.domain,\n ScatMem(sdm, sd.pkSize),\n msum.rChildren()[2], #NOTE: is this okay?\n GathMem(gdm, gd.pkSize)\n )\n )\n ),\n\n join_multibuf_dist_separate := Rule(@(1, MultiBufISum, e->Length(Collect(e.rChildren()[2], DistSum))=1),\n e -> let(\n\n msum := @(1).val,\n dsum := Collect(@(1).val, DistSum)[1],\n\n sd := Collect(dsum, @(3,[ScatDist, ScatSend]))[1],\n sm := msum.scatmem,\n sdm := fCompose(fTensor(sm.func, fId(sm.pkSize/sd.pkSize)), sd.func),\n \n gd := Collect(dsum, @(3,[GathDist, GathRecv]))[1],\n gm := msum.gathmem,\n gdm := fCompose(fTensor(gm.func, fId(gm.pkSize/gd.pkSize)), gd.func),\n\n # HACK: Converting to a MultiBufISumFinal so this rule won't match more than once\n MultiBufISumFinal(msum.var, msum.domain,\n ScatMem(sdm, sd.pkSize),\n msum.rChildren()[2], #NOTE: is this okay?\n GathMem(gdm, gd.pkSize)\n )\n )\n )\n));\n\n#F MultiBufDist_large is for large DFTs that must be multibuffered in parts.\n#F Since the multibuf loop is the outer loop, it assumes the \"chip\" can bring\n#F data from memory on to it. In reality, \"chips\" don't exist -- only cores do. So\n#F this rule distributed chip access across the core. It's different from the\n#F MultiBufDist rule in that it doesn't interact with the inside DistSum's\n#F Scatters or gathers. It does use the parallel loop var outside of its\n#F definition when done.\n\n\nClass(MultiBufDist_large, RuleSet);\n\nRewriteRules(MultiBufDist_large, rec(\n distribute_scatgathmems := Rule(@(1, MultiBufISum, e->Length(Collect(e.rChildren()[2], DistSum))>=1 ),\n e -> let(\n\n msum := @(1).val,\n dsum := Collect(@(1).val, DistSum)[1],\n sm := msum.scatmem,\n gm := msum.gathmem,\n\n sf := When(sm.func.domain()=1, dsum.P, 1),\n gf := When(gm.func.domain()=1, dsum.P, 1),\n\n sfunc := When(sf=1, sm.func, fTensor(sm.func, fId(sf))),\n gfunc := When(gf=1, gm.func, fTensor(gm.func, fId(gf))),\n\n\n Ns := sf*sm.func.range()/msum.domain,\n ns := sf*sm.func.domain()/dsum.P,\n bs := (dsum.var * ns),\n\n Ng := gf*gm.func.range()/msum.domain,\n ng := gf*gm.func.domain()/dsum.P,\n bg := (dsum.var * ng),\n\n smnew := ScatMem(fCompose(sfunc, H(Ns, ns, bs, 1)), sm.pkSize/sf),\n gmnew := GathMem(fCompose(gfunc, H(Ng, ng, bg, 1)), gm.pkSize/gf),\n\n #Error(\"BP\"),\n\n\n isum := When(ObjId(@(1).val)=MultiBufISum, MultiBufISumFinal, MemISumFinal),\n\n isum(msum.var, msum.domain,\n smnew,\n msum.rChildren()[2], #NOTE: is this okay?\n gmnew\n )\n )\n )\n));\n\n\n# HACK!!!\n# This is the way the system works: the above rules (RulesVRC) passes VRCL and\n# VRCR tags to the scat and gath of a multibufisum. BUT, these have\n# cannotchangedataformat set to true, AND, they're not exposed to the VRC\n# rules. So the VRC rules don't really touch these. So in some cases, they end\n# up with VRCL and VRCR, when in reality, they don't have either. The following\n# rule \"fixes\" this problem by simply assuming they're either VRCs or VRCLRs.\n# Hackity hack.\nRewriteRules(RulesVRC, rec(\n VRC_MultiBufISum := Rule([@(1, [VRC,VRCL,VRCR,VRCLR]), @(2, [MultiBufISum])],\n e->let(v := @(1).val,\n m := @(2).val,\n MultiBufISum(m.var, m.domain, \n ObjId(v)(m.scatmem, v.v),\n ObjId(v)(m._children[1], v.v), \n ObjId(v)(m.gathmem, v.v))\n )\n ),\n VRC_MemISum := Rule([@(1, [VRC,VRCL,VRCR,VRCLR]), @(2, [MemISum])],\n e->let(v := @(1).val,\n m := @(2).val,\n MemISum(m.var, m.domain, \n ObjId(v)(m.scatmem, v.v),\n ObjId(v)(m._children[1], v.v), \n ObjId(v)(m.gathmem, v.v))\n )\n )\n));\n\n\nRewriteRules(CellVRCTerm, rec(\n VRC_ScatMem_Term := Rule([@(1, [RC, VRCL, VRCR, VRC,VRCLR]), @(2, [ScatMem])], \n e->ScatMem(@(2).val.func, @(2).val.pkSize*2)),\n\n VRC_GathMem_Term := Rule([@(1, [RC, VRCL, VRCR, VRC,VRCLR]), @(2, [GathMem])], \n e->GathMem(@(2).val.func, @(2).val.pkSize*2)),\n));\n\n\n\nRewriteRules(RulesRC, rec(\n RC_MultiBufISum := Rule([RC, @(1, MultiBufISum)],\n e -> let(s:=@(1).val, MultiBufISum( s.var, s.domain, s.scatmem, RC(s.child(1)), s.gathmem ))\n ),\n));\n\n\n# To convert Compose(A, B) -> ComposeStreams(A, B) when A,B=MultiBufISum\n# ObjId(c)=DistSumLoop below is a hack. Obviously, DistSumLoop does not necessarily imply composing streams.\nClass(RulesComposeStreams, RuleSet);\nRewriteRules(RulesComposeStreams, rec(\n stream_compose := Rule(@(1, Compose, e->ForAll(e.children(), c->(ObjId(c)=MultiBufISum or ObjId(c)=MultiBufISumFinal or ObjId(c)=DistSumLoop) )),\n e -> ComposeStreams(@(1).val.children()) )\n));\n\n\n\n# Pull Diag into MultiBufISum. D*MBufISum(SAG) -> MBufISum(SDAG) and\n# MBufISum(SAG)*D -> MBufISum(SADG) Unlike the DistSum rules to do the same\n# thing, this combining has to be done in a single step because the Scat and\n# Gath of the MultiBufISum are not exposed.\n\nRewriteRules(RulesDiagStandalone, rec(\n # MBufISum(SAG)*D\n CellPullInCommuteGathDiag := ARule(Compose, [ @(1, MultiBufISum), @(2, [Prm, Gath, Diag, RCDiag]) ],\n e->let(msum := @(1).val,\n diag := @(2).val,\n gath := msum.gathmem,\n newdiag := Diag(fCompose(diag.element, fTensor(gath.func, fId(gath.pkSize)))).attrs(diag),\n [ MultiBufISum(msum.var, msum.domain, msum.scatmem, msum.child(1) * newdiag, msum.gathmem) ]\n )\n ),\n\n CellPullInCommuteScatDiag := ARule(Compose, [ @(1, [RCDiag, Diag, Prm, Scat]), @(2, MultiBufISum) ],\n e->let(msum := @(2).val,\n diag := @(1).val,\n scat := msum.scatmem,\n newdiag := Diag(fCompose(diag.element, fTensor(scat.func, fId(scat.pkSize)) )).attrs(diag),\n [ MultiBufISum(msum.var, msum.domain, msum.scatmem, newdiag * msums.child(1), msum.gathmem) ]\n )\n ),\n\n # NOTE\n ## Gath * RCDiag\n #CellCommuteGathRCDiag := ARule( Compose,\n # [ [@(1, [ GathDist, GathRecv ]), [@(0,fTensor), ..., [fId,@(2).cond(IsEvenInt)]]],\n # @(4, RCDiag) ],\n # e -> [ RCDiag(fCompose(@(4).val.element, @(0).val), @(4).val.post),\n # @(1).val ]),\n\n ## RCDiag * Scat\n #CellCommuteRCDiagScat := ARule( Compose,\n # [ @(4, RCDiag),\n # [@(1, [Scat, ScatDist, ScatSend]), [@(0,fTensor), ..., [fId,@(2).cond(IsEvenInt)]]] ],\n # e -> [ @(1).val,\n # RCDiag(fCompose(@(4).val.element, @(0).val), @(4).val.post) ]),\n\n));\n\n", "meta": {"hexsha": "a43f8211308cea71220c641ee338379ba24618cf", "size": 11716, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/paradigms/multibuffer/rewrite.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/paradigms/multibuffer/rewrite.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/paradigms/multibuffer/rewrite.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 37.1936507937, "max_line_length": 155, "alphanum_fraction": 0.5841584158, "num_tokens": 3740, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.33458944125318596, "lm_q2_score": 0.036769465020075824, "lm_q1q2_score": 0.012302674756245736}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\nRows := s -> Cond(\n IsMat(s), \n Length(s),\n\n IsBound(s.rng) and IsBound(s.dmn),\n s.dims()[1],\n\t\n IsValue(s) or IsSymbolic(s),\n Checked(IsArrayT(s.t), IsArrayT(s.t.t), \n\t s.t.size),\n\n s.dimensions[1]\n);\n\nCols := s -> Cond(\n IsMat(s), \n Length(s[1]),\n\n IsBound(s.rng) and IsBound(s.dmn),\n s.dims()[2],\n\t\n IsValue(s) or IsSymbolic(s),\n Checked(IsArrayT(s.t), IsArrayT(s.t.t), \n\t s.t.t.size),\n\n s.dimensions[2]\n);\n\nolRows := s -> Flat([Rows(s)]);\nolCols := s -> Flat([Cols(s)]);\n\n#F SPL(<rec>)\n#F Set operations field to SPLOps. This function should be called\n#F to initialize SPL instances.\nSPL := function(record)\n record.operations := SPLOps;\n return record;\nend;\n\nHashAsSPL := o -> Cond(\n IsList(o), \n List(o, HashAsSPL),\n not IsRec(o) or (not IsBound(o.hashAs) and not IsBound(o.from_rChildren)), \n o,\n IsBound(o.hashAs), \n o.hashAs(),\n IsValue(o),\n o.v,\n o.from_rChildren(List(o.rChildren(), HashAsSPL))\n);\n\n# ==========================================================================\n# ClassSPL\n#\n# Base class for all SPL constructs\n# ==========================================================================\nClass(ClassSPL, AttrMixin, rec(\n isSPL := true,\n transposed := false,\n\n#DD this allows objects which are not TaggedNonTerminals to drop tags automagically\n#DD and without error.\n withTags := (self, t) >> self,\n\n _short_print := false,\n _newline := i -> Print(\"\\n\", Blanks(i)),\n _indent := i -> Print(Blanks(i)),\n _indentStr := Blanks,\n\n\n __call__ := meth(arg)\n local self, params, nump, A,p,res,h,lkup;\n self := arg[1];\n params := arg{[2..Length(arg)]};\n nump := Length(params);\n\n if not IsBound(self.new) then\n Error(\"Constructor for this class is not implemented\");\n elif IsBound(self.abbrevs) and self.abbrevs <> [] then\n for A in self.abbrevs do\n if NumArgs(A) = -1 or NumArgs(A) = nump then\n params := ApplyFunc(A, params);\n fi;\n od;\n fi;\n\n if NumArgs(self.new)-1 <> Length(params) then\n Error(\"Constructor requires \", NumArgs(self.new)-1, \" parameters (\",\n Length(arg)-1, \" given): \",\n ParamsMeth(self.new));\n else\n h := self.hash;\n if h<>false then\n lkup := h.objLookup(self, params);\n if lkup[1] <> false then return lkup[1]; fi;\n fi;\n\n res := ApplyFunc(self.new, params);\n\n if h<>false then return h.objAdd(res, lkup[2]);\n else return res;\n fi;\n fi;\n end,\n\n hash := false,\n\n checkDims := self >> DimensionsMat(MatSPL(self)) = self.dimensions,\n\n #-----------------------------------------------------------------------\n # create a new object with .<name> field set to true\n setAttr := meth(self, name)\n local s;\n s:= Copy(self);\n s.(name) := true;\n return s;\n end,\n # ----------------------------------------------------------------------\n # create a new object with .<name> field set to <val>\n setAttrTo := meth(self, name, val)\n local s;\n s:= Copy(self);\n s.(name) := val;\n return s;\n end,\n\n #---------Backwards Compatibility for the new dimension system------\n setDims := meth(self) self.dimensions := self.dims(); return self; end,\n\n dims := self >> [ StripList(List(self.rng(), l -> l.size)), \n\t StripList(List(self.dmn(), l -> l.size)) ],\n\n advdims := (self) >> let(d := self.dims(), [ [[ d[1] ]], [[ d[2] ]] ]),\n arity := (self) >> List(self.dims(), e -> Length(Flat([e]))),\n\n TType:=TUnknown,\n\n rng := meth(self) local d;\n if IsBound(self.dims) then\n d := Flat([self.dims()[1]]);\n else \n d := [self.dimensions[1]];\n fi;\n if IsBound(self.a.t_out) then\n return List(TransposedMat([self.a.t_out, d]), e -> TArray(e[1], e[2]));\n else\n return List(d, e -> TArray(self.TType, e));\n fi;\n end,\n\n dmn := meth(self) local d;\n if IsBound(self.dims) then\n d := Flat([self.dims()[2]]);\n else \n d := [self.dimensions[2]];\n fi;\n if IsBound(self.a.t_in) then\n return List(TransposedMat([self.a.t_in, d]), e -> TArray(e[1], e[2]));\n else\n return List(d, e -> TArray(self.TType, e));\n fi;\n end,\n\n free := self >> Union(List(self.rChildren(), FreeVars)),\n\n equals := (self, o) >>\n ObjId(self) = ObjId(o) and self.rChildren() = o.rChildren() and self.a = o.a,\n\n lessThan := (self, o) >> Cond(\n ObjId(self) <> ObjId(o), ObjId(self) < ObjId(o),\n [ ObjId(self), self.rChildren(), self.a ] < [ ObjId(o), o.rChildren(), o.a ]\n ),\n\n from_rChildren := (self, rch) >> ApplyFunc(ObjId(self), rch).appendAobj(self),\n\n\n print := (self, i, is) >> self._print(self.rChildren(), i, is),\n\n _print := meth(self, ch, indent, indentStep)\n local s, first, newline;\n\n\tif self._short_print or ForAll(ch, x->not IsRec(x) or IsSPLSym(x) or IsSPLMat(x)) then\n\t newline := Ignore;\n\telse \n\t newline := self._newline;\n\tfi;\n\n\tfirst := true;\n Print(self.__name__, \"(\");\n\tfor s in ch do\n if(first) then first:=false;\n else Print(\", \"); fi;\n newline(indent + indentStep);\n When(IsSPL(s) or (IsRec(s) and IsBound(s.print) and NumGenArgs(s.print)=2),\n s.print(indent + indentStep, indentStep), \n\t\t Print(s));\n\tod;\n\tnewline(indent);\n\tPrint(\")\");\n self.printA();\n\n\tif IsBound(self._setDims) then\n Print(\".overrideDims(\", self._setDims, \")\");\n\tfi;\n end,\n\n printlatex := meth(self)\n local s, first, newline, i;\n\n\tfirst := true;\n Print(\"(\");\n i := Length(self.rChildren());\n for s in self.rChildren() do\n When(IsSPL(s) or (IsRec(s) and IsBound(s.printlatex) and NumGenArgs(s.printlatex)=0),\n s.printlatex(),\n\t\t Print(s));\n if i >=2 then \n Print(\" \", When(IsBound(self.latexSymbol), self.latexSymbol, \"\"), \" \");\n fi;\n i := i-1;\n\tod;\n\tPrint(\")\");\n end,\n\n\n\n overrideDims := (self, dims) >> CopyFields(self, rec(_setDims := dims, dimensions := dims)),\n\n terminate := self >> self.from_rChildren(List(self.rChildren(), x->When(IsSPL(x), x.terminate(), x))),\n\n # ------------------------- Required methods ---------------------------\\\n transposeSymmetric := True,\n dims := meth(self) Error(\"Not implemented\"); end,\n isPermutation := meth(self) Error(\"Not implemented\"); end,\n isTerminal := meth(self) Error(\"Not implemented\"); end,\n isReal := meth(self) Error(\"Not implemented\"); end,\n isInplace := self >> Rows(self)=Cols(self) and let(ch:=self.children(), Cond(Length(ch)=0, false, ForAll(ch, x->x.isInplace()))),\n children := meth(self) return []; end,\n numChildren := meth(self) return 0; end,\n child := meth(self,n) Error(\"Not implemented\"); end,\n setChild := meth(self,n,what) Error(\"Not implemented\"); end,\n toAMat := meth(self) Error(\"Not implemented\"); end,\n transpose := meth(self) Error(\"Not implemented\"); end,\n conjTranspose := meth(self) Error(\"Not implemented\"); end,\n));\n\n\n#F <SPL> * <SPL>\n#F <scalar> * <SPL>\n#F is equivalent to ComposeSPL and ScalarMultiple resp.\n#F\nSPLOps.\\* := (S1, S2) ->\n Cond(IsSPL(S1) and IsSPL(S2), Compose(S1, S2),\n IsSPL(S2), Scale(S1, S2),\n IsSPL(S1), Scale(S2, S1),\n Error(\"do not know how to compute <S1> * <S2>\"));\n\n#F <SPL> + <SPL>\n#F is equivalent to SUM(<S1>, <S2>)\n#F\nSPLOps.\\+ := (S1, S2) ->\n Cond(IsSPL(S1) and IsSPL(S2), SUM(S1, S2),\n Error(\"do not know how to compute <S1> + <S2>\"));\n\n#F S1 ^ S2\n#F is equivalent to ConjugateSPL(S1, S2).\n#F\nSPLOps.\\^ := (S1, S2) ->\n When(IsSPL(S1) and IsSPL(S2),\n Conjugate(S1, S2),\n Error(\"do not know how to compute S1 ^ S2\"));\n", "meta": {"hexsha": "3a232f837a2b60479fc76fca7ccc9b7bc6888292", "size": 8290, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/spl/SPL.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/spl/SPL.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/spl/SPL.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 29.9277978339, "max_line_length": 137, "alphanum_fraction": 0.5139927624, "num_tokens": 2265, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3960681520167196, "lm_q2_score": 0.029760095667014458, "lm_q1q2_score": 0.011787026094675199}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\n# helps translate VTensorInd(Scat(f), i) -> VScat_sv(f \\tensor_i fId(i.range))\n_fTensorInd := function(fnc, idx)\n local ds, irng, fdom, nidx, lambda;\n irng := idx.range;\n\n if not (idx in fnc.free()) then\n return fTensor(fnc, fId(irng));\n fi;\n\n fdom := fnc.domain();\n nidx := Ind(irng*fdom);\n\n lambda := Lambda(nidx, imod(nidx, irng)+V(irng)*Lambda(idx, fnc.at(idiv(nidx, irng))).at(imod(nidx, irng))).setRange(V(fnc.range())*V(irng));\n return lambda;\nend;\n\n#prevent VRC Rules from introducing VRCL/VRCR in the wrong spot\nDontNeedSpecialVRC := e->not ForAny(e.children(), f->IsBound(f.needSpecialVRC) and f.needSpecialVRC());\n\n# Test for VRCs that, for any construct, has a needSeparateVRC set\nanyNeedSeparateVRC := e->ForAny(e.children(), f->IsBound(f.needSeparateVRC) and f.needSeparateVRC());\n\n# Test for VRCs that for all constructs, cannot change data formats\nTotallyNonChangeable := function(e)\n if ObjId(e)=Compose or ObjId(e)=ComposeDists then\n return(ForAll(e.children(), f->IsBound(f.totallyCannotChangeDataFormat) and f.totallyCannotChangeDataFormat()));\n else\n return(IsBound(e.totallyCannotChangeDataFormat) and e.totallyCannotChangeDataFormat());\n fi;\nend;\n\n# Test for VRCs that have at least one construct that cannot change data formats\nHasNonchangeable := function(e)\n if ObjId(e)=Compose or ObjId(e)=ComposeDists then\n return(ForAny(e.children(), f->IsBound(f.cannotChangeDataFormat) and f.cannotChangeDataFormat()));\n else\n return(IsBound(e.cannotChangeDataFormat) and e.cannotChangeDataFormat());\n fi;\nend;\n\nNoSpecialOrNonchangeableVRC := e->(DontNeedSpecialVRC(e) and not HasNonchangeable(e));\nNoSpecialAndChangeableVRC := e->(DontNeedSpecialVRC(e) and HasNonchangeable(e));\n\nHandleCannotChangeDataFormatVRC := function(vrc, ch, v)\n local remch, ele, left, right, i, vrc1, vrc2;\n\n remch := Compose(Drop(ch, 1));\n #Error(\"BP: cannotChangeDataFormatVRC\");\n\n if vrc=VRC then\n # NOTE: How do we handle this?\n # If ALL children cannot change data format, simply distribute the VRC amongst them\n\n if TotallyNonChangeable(Compose(ch)) then\n return( Compose(VRC(ch[1], v), VRC(remch,v)) );\n fi;\n\n # if any of the children NOTE: this is inefficient: what we really\n # should to is to bunch together the children that needSeparateVRC, and\n # the children that are regular, and handle them separately. For now,\n # this hack works because we should have no cases where such children\n # will be mixed together.\n\n if anyNeedSeparateVRC(Compose(ch)) then\n return( Compose(VRC(ch[1], v), VRC(remch,v)) );\n fi;\n\n\n # If not, we must do a VRCR/VRCL split\n # Find the rightmost child that can change dataformats. That and\n # everything right of that becomes a VRCL. Everything left of that is a VRCR.\n\n # Bad (but good:)) HACK: for things of the form S*A*G, where S and G\n # cannot change data formats, stuff the VRC into A, and hope that A is\n # big enough to handle it.\n\n if Length(ch)=3 and TotallyNonChangeable(ch[1]) and TotallyNonChangeable(ch[3]) then\n return(Compose( VRC(ch[1], v), VRC(ch[2], v), VRC(ch[3], v) ));\n fi;\n\n for i in Reversed([1..Length(ch)]) do\n if not TotallyNonChangeable(ch[i]) then\n # We found the rightmost child\n #Error(\"VRC: BP\");\n left := Compose(List([1..(i-1)], e->ch[e]));\n right := Compose(List([i..Length(ch)], e->ch[e]));\n #Error(\"VRC: BP\");\n return( Compose( VRCR(left, v), VRCL(right, v) ) );\n fi;\n od;\n\n #Error(\"BP: cannotChangeDataformatVRC: VRC needs to be split into VRCL/VRCR\");\n fi;\n\n if vrc=VRCLR then\n # This should really be handled as if the cannotChangeDataformat doesn't exist.\n #Error(\"VRCLR: BP\");\n vrc1 := [[VRCL, VRCR], [VRCLR, VRCLR]];\n vrc2 := When(NeedInterleavedRight(ch[1]) or NeedInterleavedLeft(ch[2]), vrc1[1], vrc1[2]);\n #Error(\"VRCLR: BP\");\n return( Compose(vrc2[1](ch[1], v), vrc2[2](Compose(Drop(ch, 1)), v)) );\n fi;\n\n if vrc=VRCL then\n # Find the first child from the right that is capable of making a\n # format change. We then have 2 cases.\n\n # Note: we really have 3 cases to be general: VRCL -> (VRCLR, VRCL, VRC)\n # Sometimes, the LR won't exist, and sometimes, the VRC won't exist\n # But it's easier to code if we only always break down to 2 cases\n\n for i in Reversed([1..Length(ch)]) do\n if not TotallyNonChangeable(ch[i]) then\n # We found the child that will do the dataformat change (VRCL)\n # We now have 2 cases.\n # Case 1: VRCL -> (VRCL, VRC) (found child is not rightmost)\n # Case 2: VRCL -> (VRCLR, VRCL) (found child is rightmost)\n\n if i <> Length(ch) then # Case 1\n left := Compose(List([1..i], e->ch[e]));\n right := Compose(List([(i+1)..Length(ch)], e->ch[e]));\n #Error(\"BP:VRCL1\\n, ---------VRCL(left)---------\", left, \"\\n---------VRC(right)--------\", right);\n return( Compose( VRCL(left, v), VRC(right, v) ) );\n else # Case 2\n left := Compose(List([1..(i-1)], e->ch[e]));\n right := ch[i];\n #Error(\"BP:VRCL2\\n, ---------VRCLR(left)---------\", left, \"\\n---------VRCL(right)--------\", right);\n return( Compose( VRCLR(left, v), VRCL(right, v) ) );\n fi;\n fi;\n od;\n Error(\"cannotChangeDataFormatVRC/L: Didn't find an appropriate child\");\n fi;\n\n if vrc=VRCR then\n # Find the first child from the left that is capable of making a\n # format change. We then have 2 cases.\n\n for i in [1..Length(ch)] do\n if not TotallyNonChangeable(ch[i]) then\n # We found the child that will do the dataformat change (VRCR)\n # We now have 2 cases.\n # Case 1: VRCR -> (VRC, VRCR) (found child is not leftmost)\n # Case 2: VRCR -> (VRCR, VRCLR) (found child is leftmost)\n\n if i <> 1 then # Case 1\n left := Compose(List([1..(i-1)], e->ch[e]));\n right := Compose(List([i..Length(ch)], e->ch[e]));\n #Error(\"BP:VRCR1\\n, ---------VRC(left)---------\", left, \"\\n---------VRCR(right)--------\", right);\n return( Compose( VRC(left, v), VRCR(right, v) ) );\n else # Case 2\n left := ch[i];\n right := Compose(List([(i+1)..Length(ch)], e->ch[e]));\n #Error(\"BP:VRCR2\\n, ---------VRCR(left)---------\", left, \"\\n---------VRCLR(right)--------\", right);\n return( Compose( VRCR(left, v), VRCLR(right, v) ) );\n fi;\n fi;\n od;\n Error(\"cannotChangeDataFormatVRC/R: Didn't find an appropriate child\");\n\n fi;\n\n Error(\"cannotChangeDataFormat: I don't know what to do with this one. None of the cases matched.\");\n\n# vrc=VRCL and HasNonchangeable(ch1) and not HasNonchangeable(ch2), Compose(VRCLR(ch1, v), VRCL(remch, v) ),\n# vrc=VRCL and not HasNonchangeable(ch1) and HasNonchangeable(ch2), Compose(VRCL(ch1, v), VRC(remch,v) ),\n# vrc=VRCL and HasNonchangeable(ch1) and HasNonchangeable(ch2),\n# When(NeedInterleavedRight(ch1) or NeedInterleavedLeft(ch2), Compose(VRCL(I(ch1.dims()[1]),v), VRC(ch,v)),\n# ComposeVRCLR(ch,v), VRCL(I(ch1.dims()[1]),v)),\n#\n# vrc=VRCR and HasNonchangeable(ch1) and not HasNonchangeable(ch2), Compose(VRC(ch1, v), VRCR(remch, v) ),\n# vrc=VRCR and not HasNonchangeable(ch1) and HasNonchangeable(ch2), Compose(VRCR(ch1, v), VRCLR(remch,v) ),\n# vrc=VRCR and HasNonchangeable(ch1) and HasNonchangeable(ch2),\n# When(NeedInterleavedRight(ch1) or NeedInterleavedLeft(ch2), Compose(VRCL(I(ch1.dims()[1]),v), VRC(ch,v)),\n# ComposeVRCLR(ch,v), VRCL(I(ch1.dims()[1]),v))\n# )\n# )\n# ),\n\nend;\n\n\n\nScat.needInterleavedLeft:=False;\nScat.needInterleavedRight:=False;\n\n# NOTE: Why were these set to False???\nGath.needInterleavedLeft:=True;\nGath.needInterleavedRight:=True;\n\nVBlk.needInterleavedLeft:=False;\nVBlk.needInterleavedRight:=False;\n\n# NOTE: remove Diag here\nDiag.needInterleavedLeft:=False;\nDiag.needInterleavedRight:=False;\n\nInplace.needInterleavedRight := self >> self.child(1).needInterleavedRight();\nInplace.needInterleavedLeft := self >> self.child(1).needInterleavedLeft();\nInplace.cannotChangeDataFormat := self >> self.child(1).cannotChangeDataFormat();\nInplace.totallyCannotChangeDataFormat := self >> self.child(1).totallyCannotChangeDataFormat();\n\nBB.needInterleavedRight := self >> self.child(1).needInterleavedRight();\nBB.needInterleavedLeft := self >> self.child(1).needInterleavedLeft();\nBB.cannotChangeDataFormat := self >> self.child(1).cannotChangeDataFormat();\nBB.totallyCannotChangeDataFormat := self >> self.child(1).totallyCannotChangeDataFormat();\n\nVContainer.needInterleavedRight := self >> self.child(1).needInterleavedRight();\nVContainer.needInterleavedLeft := self >> self.child(1).needInterleavedLeft();\nVContainer.cannotChangeDataFormat := self >> self.child(1).cannotChangeDataFormat();\nVContainer.totallyCannotChangeDataFormat := self >> self.child(1).totallyCannotChangeDataFormat();\n\nNoDiagPullin.needInterleavedRight := self >> self.child(1).needInterleavedRight();\nNoDiagPullin.needInterleavedLeft := self >> self.child(1).needInterleavedLeft();\nNoDiagPullin.cannotChangeDataFormat := self >> self.child(1).cannotChangeDataFormat();\nNoDiagPullin.totallyCannotChangeDataFormat := self >> self.child(1).totallyCannotChangeDataFormat();\n\nNoDiagPullinLeft.needInterleavedRight := self >> self.child(1).needInterleavedRight();\nNoDiagPullinLeft.needInterleavedLeft := self >> self.child(1).needInterleavedLeft();\nNoDiagPullinLeft.cannotChangeDataFormat := self >> self.child(1).cannotChangeDataFormat();\nNoDiagPullinLeft.totallyCannotChangeDataFormat := self >> self.child(1).totallyCannotChangeDataFormat();\n\nNoDiagPullinRight.needInterleavedRight := self >> self.child(1).needInterleavedRight();\nNoDiagPullinRight.needInterleavedLeft := self >> self.child(1).needInterleavedLeft();\nNoDiagPullinRight.cannotChangeDataFormat := self >> self.child(1).cannotChangeDataFormat();\nNoDiagPullinRight.totallyCannotChangeDataFormat := self >> self.child(1).totallyCannotChangeDataFormat();\n\nSymSPL.needInterleavedRight := self >> self.child(1).needInterleavedRight();\nSymSPL.needInterleavedLeft := self >> self.child(1).needInterleavedLeft();\nSymSPL.cannotChangeDataFormat := self >> self.child(1).cannotChangeDataFormat();\nSymSPL.totallyCannotChangeDataFormat := self >> self.child(1).totallyCannotChangeDataFormat();\n\nVGath_sv.rcVariant := RCVGath_sv;\nVScat_sv.rcVariant := RCVScat_sv;\n\nRCVGath_sv.vecVariant := (f,v)->VGath(f,v);\nRCVScat_sv.vecVariant := (f,v)->VScat(f,v);\n\nScatGath.needInterleavedLeft:=True;\nScatGath.needInterleavedRight:=True;\n\nSMPBarrier.needInterleavedLeft := (self) >> self.child(1).needInterleavedLeft();\nSMPBarrier.needInterleavedRight := (self) >> self.child(1).needInterleavedRight();\n\n_VRCFamily := [VRC, VRCL, VRCR, VRCLR];\n\nClass(RulesVRC, RuleSet);\nRewriteRules(RulesVRC, rec(\n VRC_VContainer := Rule([@(1, _VRCFamily), @(2, VContainer)], \n\te -> let(cont := @(2).val, \n\t VContainer(ObjId(@(1).val)(cont.child(1), @(1).val.v), cont.isa))),\n\n VRC_ISum := Rule([@(1, _VRCFamily), @(2, [ISum, SMPSum, SMPBarrier, SUM])], e->let(s := @(2).val,\n CopyFields(s, rec(_children := List(s.children(), c->ObjId(@(1).val)(c, @(1).val.v)),\n dimensions := @(1).val.dimensions)))),\n\n VRC_Container := Rule([@(1, _VRCFamily), @(2, [BB,Buf,Inplace,RecursStep,NoDiagPullin, NoDiagPullinLeft, NoDiagPullinRight])],\n e -> ObjId(@(2).val)(ObjId(@(1).val)(@(2).val.child(1), @(1).val.v))),\n\n VRC_Data := Rule([@(1, _VRCFamily), @(2, Data)], \n\te -> Data(@(2).val.var, @(2).val.value, ObjId(e)(@(2).val.child(1)))),\n\n# VRC_SymSPL := Rule([@(1, _VRCFamily), @(2, SymSPL)],\n# e -> ObjId(@(1).val)(@(2).val.child(1), @(1).val.v)),\n\n VRC_Compose := Rule([@(1, _VRCFamily), @(2, [Compose,ComposeStreams]).cond(NoSpecialOrNonchangeableVRC)], # Use with VRC_ComposeNonchangeable below\n e->let(v := @(1).val.v, ch := @(2).val.children(), vrc := ObjId(@(1).val),\n vrc1 := Cond(\n vrc=VRC, [[VRC, VRC ], [VRCR, VRCL ]],\n vrc=VRCLR, [[VRCL, VRCR], [VRCLR, VRCLR]],\n vrc=VRCL, [[VRCL, VRC ], [VRCLR, VRCL ]],\n vrc=VRCR, [[VRC, VRCR], [VRCR, VRCLR]]),\n vrc2 := When(NeedInterleavedRight(ch[1]) or NeedInterleavedLeft(ch[2]), vrc1[1], vrc1[2]),\n Compose(vrc2[1](ch[1], v), vrc2[2](Compose(Drop(ch, 1)), v)))),\n\n # NOTE: When building the format-change I() below, ch1.dims()[1] is\n # always used. This is probably incorrect in some cases.\n VRC_ComposeNonchangeable := Rule([@(1, _VRCFamily), @(2, Compose).cond(NoSpecialAndChangeableVRC)],\n e->let(v := @(1).val.v,\n ch := @(2).val.children(),\n vrc := ObjId(@(1).val),\n HandleCannotChangeDataFormatVRC(vrc, ch, v)\n )\n ),\n\n #VRC_ComposeStreams := Rule([@(1, VRC), @(2, ComposeStreams)],\n # e->let(v := @(1).val.v, ch := @(2).val.children(),\n # ComposeStreams( VRC(ch[1], v), VRC(ComposeStreams(Drop(ch,1)), v) )\n # )\n #),\n\n VRCLR_VRCDiag:= Rule([@(1, _VRCFamily), @(2, VRCDiag)], e -> ObjId(@(1).val)(@(2).val.toloop().sums(), @(1).val.v)),\n\n VRCLR_VBlk:= Rule([@(1, VRCLR),@(2, VBlk)], e -> VBlk(RealVMatComplexVMat(@(2).val.element), @(2).val.v)),\n\n VRCLR_VGath_zero:= Rule([@(1, VRCLR),@(2, VGath_zero)], e -> let(g:=@(2).val,\n VRCLR(VGath(fAdd(g.N, g.n, 0), getV(g)), getV(g)))),\n\n VRCLR_VGathScat := Rule([@(1, VRCLR), @(2, [VGath, VScat, VScatAcc])],\n e -> ObjId(@(2).val)(fTensor(@(2).val.func, fId(2)), @(2).val.v)),\n\n VRCLR_GathScat := Rule([@(1, VRCLR), @(2, [Gath, Scat, ScatAcc])],\n e -> ObjId(@(2).val)(fTensor(@(2).val.func, fId(2)))),\n\n VRC_VGathVScat := Rule([@(1, VRC), @(2, [VGath, VScat, VScatAcc])],\n e -> ObjId(@(2).val)(fTensor(@(2).val.func, fId(2)), @(2).val.v)),\n\n VRCLR_VGathScat_sv := Rule([@(1, VRCLR), @(2, [VGath_sv, VScat_sv])], e-> # NOTE: acc variant missing\n @(2).val.rcVariant(@(2).val.func, @(2).val.v, @(2).val.sv, @(2).val.rem)),\n\n VRCLR_VTensor := Rule([@(1, VRCLR), @(2, VTensor)],\n e -> VTensor(RC(@(2).val.child(1)), @(2).val.vlen)),\n\n VRCLR_Diag := Rule([@(1, VRCLR), @(2, [Diag, VDiag])],\n e -> let(d := @(2).val.element, n := d.domain(), v := @(1).val.v,\n VRCDiag(VData(fCompose(RCData(d), fTensor(fId(n / v), L(2*v, 2))), v), v))),\n\n VRC_BlockVPerm := Rule([@(1, _VRCFamily), @(2, [BlockVPerm, BlockVPerm2])],\n e->let(bd := @(2).val.child(1), vrc := ObjId(@(1).val),\n BlockVPerm(@2.val.n, @2.val.vlen, vrc(bd, @(1).val.v),\n MatSPL(vrc(@2.val.perm, @1.val.v))))),\n\n fPrecompute_VData := Rule([VData, [fPrecompute, @(1)], @(2)], e -> fPrecompute(VData(@(1).val, @(2).val))),\n fPrecompute_VDup := Rule([VDup, [fPrecompute, @(1)], @(2)], e -> fPrecompute(VDup(@(1).val, @(2).val))),\n\n RCVScat_sv__fId := Rule(@(1,RCVScat_sv,e->IsInt(2*e.func.domain()/getV(e)) and ObjId(e.func) = fId),\n e->let(v:=getV(@(1).val), When(Cols(@(1).val)<>2*@(1).val.func.domain(),\n VGath_zero(Cols(@(1).val)/v, 2*@(1).val.func.domain()/v, v), VGath(fId(2*@(1).val.func.domain()/v), v))))\n));\n\nClass(RulesVRCTermDiag, RuleSet);\nRewriteRules(RulesVRCTermDiag, rec(\n VRCLR_VDiag_x_I := Rule([@(1, VRCLR), @(2, VDiag_x_I)], e->VTensor(RC(Diag(@(2).val.element)), @(2).val.v))\n));\n\nClass(RulesVRCTerm, RulesVRCTermDiag);\nRewriteRules(RulesVRCTerm, rec(\n VIxL := Rule(VIxL, (e, cx) -> e.implement(cx.opts.vector.isa)),\n VL := Rule(VL, (e, cx) -> e.implement(cx.opts.vector.isa)),\n#--\n### Rules for SAR -- to be moved and fixed...\n\n Term_VTensorInd_ScatGath := Rule([@(1, VTensorInd), @(2, ScatGath), @(3)],\n e->ScatGath(_fTensorInd(@(2).val.sfunc, @(3).val), _fTensorInd(@(2).val.gfunc, @(3).val))),\n\n RC_ScatGath := Rule([@@(1, RC), @(2, ScatGath)], (e,cx)->@(2).val.toloopRCVec(@(2).val.maxBkSize(), Last(cx.VContainer).isa.getV())),\n## VRCLR_ScatGath := Rule([@(1, VRCLR), @(2, ScatGath)], e->@(2).val.toloopRCVec(@(2).val.maxBkSize(), @(1).val.v)),\n\n RCVGathRCSVcat_sv_fTensor := Rule([@(1, [RCVGath_sv, RCVScat_sv]),\n [@(2,fTensor), ..., [fId, @(3).cond(e -> Gcd(@(1).val.v/@(1).val.sv, EvalScalar(e)) = @(1).val.v)]]],\n e -> let(v := @(1).val.v, sv := @(1).val.sv,\n n := EvalScalar(@(3).val), gcd := Gcd(v / sv, n),\n @(1).val.vecVariant(fTensor(DropLast(@(2).val.children(), 1), fId(2*n/gcd)), v))),\n\n# Id_RCV1 := Rule([@(1,[RCVScat_sv,RCVGath_sv]), @(2,fId,e->(IsValue(e.n) or IsInt(e.n)) and IsInt(EvalScalar(e.n/@(1).val.v)))], e->I(EvalScalar(@(2).val.n))),\n#\n# Term__VScat_ScatGath := ARule(Compose, [@(1, VScat), @@(2, ScatGath, (e,cx)->not ForAny(_VRCFamily, i->IsBound(cx.(i.name)) and cx.(i.name) <> []))],\n# e->[@(1).val * @@(2).val.toloopVec(@@(2).val.maxBkSize(), @(1).val.v)]),\n#\n# # in the precond of this rule there was a guard on VRCXX, but that was never matching due to an error. so I dont know if it was needed at all...\n# Term__ScatGath := Rule(@@(1, ScatGath, (e,cx)->not ForAny([VTensor, VTensorInd], i->IsBound(cx.(i.name)) and cx.(i.name) <> []) and\n# (IsBound(cx.VContainer) and cx.VContainer <> [])),\n# (e,cx)->@@(1).val.toloopVec(@@(1).val.maxBkSize(), Last(cx.VContainer).isa.getV())),\n#\n Term_NeedInterleavedComplex_VRC := Rule([@(1, VRC), @(2, NeedInterleavedComplex)], e->RC(@(2).val.child(1))),\n# Term_NeedInterleavedComplex_RC := Rule([@(1, RC), @(2, NeedInterleavedComplex)], e->DRC(@(2).val.child(1))),\n#\n# RC_GathScat_sv_fTensor := Rule([@(1, [VGath_sv, VScat_sv]), [@(2,fTensor), ..., [fId, 2]]],\n# e -> let(v := @(1).val.v, sv := @(1).val.sv,\n# @(1).val.rcVariant(fTensor(DropLast(@(2).val.children(), 1)), v, sv))),\n#\n RC_XXX := Rule([@(1, RC), @(2, [VGath, VScat, VScatAcc])], e->ObjId(@(2).val)(fTensor(@(2).val.func, fId(2)), @(2).val.v)),\n# RC_XXX_sv := Rule([@(1, RC), @(2, [VGath_sv, VScat_sv])], e->@(2).val.rcVariant(@(2).val.func, @(2).val.v, @(2).val.sv)),\n### end SAR\n#--\n# these rules are buggy, as Scat_sv does zero padding.\n# RCVScat_sv_toVScat := Rule(@(1, RCVScat_sv, e->e.sv=1 and e.v=2), e -> VScat(e.func, e.v)),\n# RCVGath_sv_toVGath := Rule(@(1, RCVGath_sv, e->e.sv=1 and e.v=2), e -> VGath(e.func, e.v)),\n\n#-- VPrm_x_I --\n\n #NOTE: Check if this rule is correct!\n #VRC_VPrm_x_I := Rule([@(1, VRC), @(2, VPrm_x_I)], e->let(p := @(2).val, v := p.v, b := p.dims()[1]/v,\n # Compose(\n # Tensor(I(2), VTensor(Prm(p.func), v)).sums().unroll()\n # ))),\n\n\n # YSV: we use NoDiagPullin to prevent diagonals from going into the loops resulting from Tensor(I(2),...)\n # because in some cases they can't be sucked in completely and one ends up with multiple Scat * Diag * Scat\n # sequences inside a SUM, which overlap, implying that it is a SUMAcc. However, Spiral does not know\n # that, and generates invalid code. I don't know of a better way to handle this at the moment.\n VRCLR_VPrm_x_I := Rule([@(1, [VRCLR, VRC]), @(2, VPrm_x_I)], e->let(p := @(2).val, v := p.v, b := p.dims()[1]/v,\n Compose(\n VTensor(Prm(L(2*b, b)), v),\n NoDiagPullin(Tensor(I(2), VTensor(Prm(p.func), v)).sums().unroll()),\n VTensor(Prm(L(2*b, 2)), v)\n ))),\n\n VRCL_VPrm_x_I := Rule([@(1, VRCL), @(2, VPrm_x_I)], e->let(p := @(2).val, v := p.v, b := p.dims()[1]/v,\n Compose(\n VIxL(b, 2, v),\n VTensor(Prm(L(2*b, b)), v),\n NoDiagPullin(Tensor(I(2), VTensor(Prm(p.func), v)).sums().unroll()),\n VTensor(Prm(L(2*b, 2)), v)\n ))),\n\n VRCR_VPrm_x_I := Rule([@(1, VRCR), @(2, VPrm_x_I)], e->let(p := @(2).val, v := p.v, b := p.dims()[1]/v,\n Compose(\n VTensor(Prm(L(2*b, b)), v),\n NoDiagPullin(Tensor(I(2), VTensor(Prm(p.func), v)).sums().unroll()),\n VTensor(Prm(L(2*b, 2)), v),\n VIxL(b, v, v)\n ))),\n\n#-- VGath ------------------\n VRCL_VGath := Rule([@(1, VRCL), @(2, VGath)], e->let(v := @(2).val.v,\n Compose(\n VIxL(@(2).val.func.domain(), 2, v),\n VGath(fTensor(@(2).val.func, fId(2)), v)\n ))),\n\n VRCL_VScat := Rule([@(1, VRCL), @(2, [VScat, VScatAcc])], e->let(v := @(2).val.v,\n Compose(\n ObjId(@(2).val)(fTensor(@(2).val.func, fId(2)), v),\n VIxL(@(2).val.func.domain(), 2, v)\n ))),\n\n VRCL_VGath_sv := Rule([@(1, VRCL), @(2, VGath_sv)], e->let(v := @(2).val.v, sv := @(2).val.sv,\n Compose(\n VIxL(Rows(@(2).val)/v, 2, v),\n RCVGath_sv(@(2).val.func, v, sv, @(2).val.rem)\n ))),\n\n VRCL_IxVGath_pc := Rule([@(1, VRCL), @(2, IxVGath_pc)], e -> let(\n\tg := @(2).val, v := g.v,\n Compose(\n VIxL(g.k * _roundup(g.n, g.v) / v, 2, v),\n IxRCVGath_pc(g.k, g.N, g.n, g.ofs, v)\n ))),\n\n VRCLR_IxVGath_pc := Rule([@(1, VRCLR), @(2, IxVGath_pc, x->x.N*x.k mod x.v=0)], e -> let(\n\tg := @(2).val, v := g.v,\n Compose(\n VIxL(g.k * _roundup(g.n, v) / v, 2, v),\n IxRCVGath_pc(g.k, g.N, g.n, g.ofs, v),\n VIxL(g.k * g.N / v, v, v)\n ))),\n\n VRCL_VStretchGath := Rule([@(1, VRCL), @(2, VStretchGath)], e -> let(\n\tg := @(2).val, \n\tv := g.v,\n\t#XXX Cond(???,\n Compose(\n\t\tVIxL(_roundup(Rows(g), v) / v, 2, v),\n\t\tRCVStretchGath(g.func, g.part, v))\n\n\t#XXX VStretchGath( \n\t#XXX\tfCompose(fTensor(fId(g.func.domain()/v), L(2*v, v)), fTensor(g.func, fId(2))),\n\t#XXX\t...,\n\t#XXX\t...)\n\n )),\n\n VRCR_VGath_zero:= Rule([@(1, VRCR),@(2, VGath_zero)], e -> let(g:=@(2).val,\n VGath_zero(2*g.N, 2*g.n, g.v) * VIxL(g.N, g.v, g.v))),\n\n#-- VScat ------------------\n VRCR_VScat := Rule([@(1, VRCR), @(2, [VScat, VScatAcc])], e->let(v := @(2).val.v,\n Compose(\n ObjId(@(2).val)(fTensor(@(2).val.func, fId(2)), v),\n VIxL(@(2).val.func.domain(), v, v)\n ))),\n\n VRCR_VScat_sv := Rule([@(1, VRCR), @(2, VScat_sv)], e->let(v := @(2).val.v, sv := @(2).val.sv, # NOTE: acc variant missing\n Compose(\n RCVScat_sv(@(2).val.func, v, sv, @(2).val.rem),\n VIxL(Cols(@(2).val)/v, v, v)\n ))),\n\n VRCR_IxVScat_pc := Rule([@(1, VRCR), @(2, IxVScat_pc)], e->let(s:=@(2).val, v := s.v, # NOTE: acc variant missing\n Compose(\n IxRCVScat_pc(s.k, s.N, s.n, s.ofs, v),\n VIxL(s.k*_roundup(s.n, v)/v, v, v)\n ))),\n\n VRCLR_IxVScat_pc := Rule([@(1, VRCLR), @(2, IxVScat_pc, x->x.N*x.k mod x.v=0)], e -> let(\n s := @(2).val, v := s.v,\n Compose(\n VIxL(s.k * s.N / v, 2, v),\n IxRCVScat_pc(s.k, s.N, s.n, s.ofs, v),\n VIxL(s.k*_roundup(s.n, v)/v, v, v)\n ))),\n\n VRCR_VStretchScat := Rule([@(1, VRCR), @(2, VStretchScat)], e->let(s:=@(2).val, v := s.v,\n Compose(\n RCVStretchScat(s.func, s.part, v),\n VIxL(_roundup(Cols(s), v)/v, v, v)\n ))),\n\n#----------------------------\n VRCLR_VPerm := Rule([@(1, VRCLR), @(2, VPerm)], e->let(p := @(2).val, v := p.vlen, b := p.dims()[1]/v,\n Compose(\n VTensor(Prm(L(2*b, b)), v),\n Tensor(I(2), p).sums().unroll(),\n VTensor(Prm(L(2*b, 2)), v)\n ))),\n\n VRCL_VPerm := Rule([@(1, VRCL), @(2, VPerm)], e->let(p := @(2).val, v := p.vlen, b := p.dims()[1]/v,\n Compose(\n VTensor(Prm(L(2*b, b)), v),\n Tensor(I(2), p).sums().unroll(),\n VTensor(Prm(L(2*b, 2)), v),\n VIxL(b, 2, v)\n ))),\n\n VRCR_VPerm := Rule([@(1, VRCR), @(2, VPerm)], e->let(p := @(2).val, v := p.vlen, b := p.dims()[1]/v,\n Compose(\n VIxL(b, v, v),\n VTensor(Prm(L(2*b, b)), v),\n Tensor(I(2), p).sums().unroll(),\n VTensor(Prm(L(2*b, 2)), v)\n ))),\n\n#----------------------------\n VRCLR_Perm := Rule([@(1, VRCLR), @(2, Prm)], e->let(p := @(2).val, v := getV(@1.val), b := p.dims()[1]/v, n := @(2).val.dims()[2]/v,\n Compose(\n VIxL(n, 2, v),\n RCVScat_sv(fId(p.func.domain()), v, 1),\n RCVGath_sv(p.func, v, 1),\n VIxL(n, v, v)\n ))),\n\n VRC_Perm := Rule([@(1, VRC), @(2, Prm)], e->let(p := @(2).val, v := getV(@1.val), b := p.dims()[1]/v, n := @(2).val.dims()[2]/v,\n Compose (RCVScat_sv(fId(p.func.domain()), v, 1),\n RCVGath_sv(p.func, v, 1))\n )),\n\n VRCL_Split := Rule([@(1, VRCL), @(2, [VDiag, VTensor])], e->let(v := getV(@(2).val),\n Compose(\n VRCLR(@(2).val, v),\n VIxL(@(2).val.dims()[2]/v, 2, v)\n ))),\n\n VRCR_Split := Rule([@(1, VRCR), @(2, [VDiag, VTensor])], e->let(v := getV(@(2).val),\n Compose(\n VIxL(@(2).val.dims()[1]/v, v, v),\n VRCLR(@(2).val, v)\n ))),\n\n VRC_VTensor := Rule([@(1, VRC), @(2, [VTensor])], e->let(v := getV(@(2).val),\n Compose(\n VIxL(@(2).val.dims()[1]/v, v, v),\n VRCLR(@(2).val, v),\n VIxL(@(2).val.dims()[2]/v, 2, v)\n ))),\n\n VRC_VDiag := Rule([@(1, VRC), @(2, [VDiag])], e->let(\n v := getV(@(2).val), d := @(2).val.dims()[1],\n Cond(@(2).val.element.isReal(),\n\t VDiag(diagTensor(@(2).val.element, fConst(TReal, 2, 1)), @(2).val.v),\n\t VIxL(d/v, v, v) * VRCLR(@(2).val, v) * VIxL(d/v, 2, v)))),\n\n VRC_Blk := Rule([@(1, VRC), @(2, Blk)], e->RC(@(2).val)),\n\n VRCLR_VScat_zero := Rule([@(1, VRCLR), @(2, VScat_zero)], e->let(s:=@(2).val, VScat_zero(2*s.N, 2*s.n, s.v))),\n\n VRC_Gath := Rule([@(1, VRC), @(2, Gath)], e->let(g := @(2).val, v := getV(@1.val), b := g.dims()[1]/v, n := @(2).val.dims()[2]/v,\n Compose (VRCLR(VScat_sv(fId(g.func.domain()), v, 1), v),\n VRCLR(VGath_sv(g.func, v, 1), v))\n )),\n\n FormatPrm_Term := Rule([FormatPrm, @(1)], e -> Prm(@(1).val)),\n));\n\nClass(RulesSplitComplex, RuleSet);\nRewriteRules(RulesSplitComplex, rec(\n VRCR_IxVScat_pc := ARule(Compose, [[@(1,[Prm, FormatPrm]), @(4,L,e->e.params[2]=2)], [@(2,VRCR), @(3,IxVScat_pc)]],\n e -> let(v:=@(2).val.v, c:=Cols(@(3).val), s:=@(3).val,\n [IxVScat_pc(2*s.k, s.N, s.n, s.ofs, v), VPrm_x_I(L(2*c/v, 2), v)])),\n\n VRCL_IxVGath_pc := ARule(Compose, [[@(2,VRCL), @(3,IxVGath_pc)], [@(1,[Prm, FormatPrm]), @(4,L,e->e.params[2]=e.params[1]/2)]],\n e -> let(v:=@(2).val.v, r:=Rows(@(3).val), g:=@(3).val,\n [VPrm_x_I(L(2*r/v, r/v), v), IxVGath_pc(2*g.k, g.N, g.n, g.ofs, v)])),\n\n VRCR_VStretchScat := ARule(Compose, [[@(1,[FormatPrm,Prm]), @(4,L,e->e.params[2]=2)], [@(2,VRCR), @(3,VStretchScat)]],\n e -> let(v:=@(2).val.v, c:=Cols(@(3).val), s:=@(3).val,\n [VStretchScat(fTensor(fId(2), s.func), 2*s.part, v), VPrm_x_I(L(2*c/v, 2), v)])),\n\n VRCL_VStretchGath := ARule(Compose, [[@(2,VRCL), @(3,VStretchGath)],[@(1,[FormatPrm,Prm]), @(4,L,e->e.params[2]=e.params[1]/2)]],\n e -> let(v:=@(2).val.v, r:=Rows(@(3).val), g:=@(3).val,\n [VPrm_x_I(L(2*r/v, r/v), v), VStretchGath(fTensor(fId(2), g.func), 2*g.part, v)])),\n\n VRCR_VScat_sv := ARule(Compose, [[@(1,[FormatPrm,Prm]), @(4,L,e->e.params[2]=2)], [@(2,VRCR), @(3,VScat_sv)]],\n e -> let(v:=@(2).val.v, c:=Cols(@(3).val), s:=@(3).val,\n [VStretchScat(fTensor(fId(2), s.func), 2, v), VPrm_x_I(L(2*c/v, 2), v)])),\n\n VRCL_VGath_sv := ARule(Compose, [[@(2,VRCL), @(3,VGath_sv)],[@(1,[FormatPrm,Prm]), @(4,L,e->e.params[2]=e.params[1]/2)]],\n e -> let(v:=@(2).val.v, r:=Rows(@(3).val), g:=@(3).val,\n [VPrm_x_I(L(2*r/v, r/v), v), VStretchGath(fTensor(fId(2), g.func), 2, v)])),\n\n VRCR_VScat := ARule(Compose, [[@(1,[Prm, FormatPrm]), @(4,L,e->e.params[2]=2)], [@(2,VRCR), @(3,[VScat, VScatAcc])]],\n e -> let(v:=@(2).val.v, c:=Cols(@(3).val), s:=@(3).val,\n [ObjId(@(3).val)(fTensor(fId(2), s.func), v), VPrm_x_I(L(2*c/v, 2), v)])),\n\n VRCL_VGath := ARule(Compose, [[@(2,VRCL), @(3,VGath)],[@(1,[Prm, FormatPrm]), @(4,L,e->e.params[2]=e.params[1]/2)]],\n e -> let(v:=@(2).val.v, r:=Rows(@(3).val), g:=@(3).val,\n [VPrm_x_I(L(2*r/v, r/v), v), VGath(fTensor(fId(2), g.func), v)])),\n\n VRCL_VScat := ARule(Compose, [[@(2,VRCL), @(3,[VScat, VScatAcc])],[@(1,Prm), @(4,L,e->e.params[2]=e.params[1]/2)]],\n e -> let(v:=@(2).val.v, r:=Rows(@(3).val), g:=@(3).val,\n [VPrm_x_I(L(2*r/v, r/v), v), ObjId(@(3).val)(fTensor(fId(2), g.func), v)])),\n\n VRCR_VTensor1 := ARule(Compose, [[@(1, [FormatPrm, Prm]), @(4,L,e->e.params[2]=2)], [@(2,VRCR), @(3,VTensor)]],\n e -> let(v:=@(2).val.v, c:=Cols(@(3).val), s:=@(3).val,\n [VPrm_x_I(L(2*c/v, 2), v), VRCLR(s, v)])),\n\n VRCR_VTensor1a := ARule(Compose, [[@(1, [FormatPrm, Prm]), @(4,L,e->e.params[2]=2)], [@(2,VRC), @(3,VTensor)]],\n e -> let(v:=@(2).val.v, c:=Cols(@(3).val), s:=@(3).val,\n [VPrm_x_I(L(2*c/v, 2), v), VRCL(s, v)])),\n\n VRCL_VTensor2 := ARule(Compose, [[@(2,VRCL), @(3,VTensor)],[@(1, [FormatPrm, Prm]), @(4,L,e->e.params[2]=e.params[1]/2)]],\n e -> let(v:=@(2).val.v, c:=Cols(@(3).val), g:=@(3).val,\n [VRCLR(g,v), VPrm_x_I(L(2*c/v, c/v), v)])),\n\n VRCL_VTensor2a := ARule(Compose, [[@(2,VRC), @(3,VTensor)],[@(1, [FormatPrm, Prm]), @(4,L,e->e.params[2]=e.params[1]/2)]],\n e -> let(v:=@(2).val.v, r:=Rows(@(3).val), g:=@(3).val,\n [VRCR(g,v), VPrm_x_I(L(2*r/v, r/v), v)])),\n\n# VRCLR_VGath_split := Rule([@(1, VRCLR), @(2, VGath_sv)],\n# e -> let(g := @(2).val, v:= g.v, func := g.func, n := func.domain(), N:= func.range(),\n# VGath_sv(fCompose(fTensor(L(2*N/v,2), fId(v)), fTensor(fId(2), func), fTensor(L(2*n/v,n/v), fId(v))), v, g.sv))),\n#\n# VRCLR_VScat_split := Rule([@(1, VRCLR), @(2, VScat_sv)],\n# e -> let(g := @(2).val, v:= g.v, func := g.func, n := func.domain(), N:= func.range(),\n# VScat_sv(fCompose(fTensor(L(2*N/v,2), fId(v)), fTensor(fId(2), func), fTensor(L(2*n/v,n/v), fId(v))), v, g.sv)))\n#\n VGath_FormatPrm := ARule(Compose, [[@(1, VGath), [fTensor, fBase, @(2, fId)]],\n [@(3, FormatPrm), [fTensor, fId, @(4, L, e->IsInt(@(2).val.domain()/e.domain()))]]],\n e->[FormatPrm(fTensor(fId(Rows(@(1).val)/@(4).val.domain()), @(4).val)), @(1).val]),\n\n FormatPrm_VScat := ARule(Compose, [[@(1, FormatPrm), [fTensor, fId, @(2, L)]],\n [@(3, [VScat, VScatAcc]), [fTensor, fBase, @(4, fId, e->IsInt(e.domain()/@(2).val.domain()))]]],\n e->[@(3).val, FormatPrm(fTensor(fId(Cols(@(3).val)/@(2).val.domain()), @(2).val))]),\n\n VRCL_VGath_fIdxL := ARule(Compose, [[@(2,VRCL), @(3,VGath)], [@(1,FormatPrm), [@(4,fTensor), fId, @(5, L, e->e.params[1]=2*e.params[2])]]],\n e -> let(v:=@(2).val.v, r:=Rows(@(3).val), g:=@(3).val, [VGath(fTensor(g.func, fId(2)), v)])),\n\n VRCR_VScat_fIdxL := ARule(Compose, [[@(1, FormatPrm), [@(4,fTensor), fId, @(5, L, e->e.params[2]=2)]], [@(2,VRCR), @(3,[VScat, VScatAcc])]],\n e -> let(v:=@(2).val.v, c:=Cols(@(3).val), s:=@(3).val, [ObjId(@(3).val)(fTensor(s.func, fId(2)), v)]))\n\n));\n\nClass(RulesVBlkInt, RuleSet);\nRewriteRules(RulesVBlkInt, rec(\n Merge_RulesVBlkInt_VRC_rt := ARule(Compose, [@(1, VBlkInt), @(2, VRC)],\n e -> let(v1 := @(1).val, v2 := @(2).val, v := v1.v, [ VIxL(Rows(v1)/(2*v), v, v), v1.child(1), VRCL(v2.child(1), v) ])),\n\n Merge_RulesVBlkInt_VRC_lft := ARule(Compose, [@(2, VRC), @(1, VBlkInt)],\n e -> let(v1 := @(1).val, v2 := @(2).val, v := v1.v, [ VRCR(v2.child(1), v), v1.child(1), VIxL(Rows(v1)/(2*v), 2, v) ])),\n\n Merge_RulesVBlkInt_vRC_rt := ARule(Compose, [@(1, VBlkInt), @(2, vRC)],\n e -> let(v1 := @(1).val, v := v1.v, [ VIxL(Rows(v1)/(2*v), v, v), v1.child(1), VIxL(Cols(v1)/(2*v), 2, v), @(2).val ])),\n\n Merge_RulesVBlkInt_vRC_lft := ARule(Compose, [@(2, vRC), @(1, VBlkInt)],\n e -> let(v1 := @(1).val, v := v1.v, [ @(2).val, VIxL(Rows(v1)/(2*v), v, v), v1.child(1), VIxL(Rows(v1)/(2*v), 2, v) ])),\n));\n", "meta": {"hexsha": "a9b6acf77d5340962e428e88229282579dd771bb", "size": 33032, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/paradigms/vector/rewrite/vrc.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/paradigms/vector/rewrite/vrc.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/paradigms/vector/rewrite/vrc.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 49.0817236256, "max_line_length": 163, "alphanum_fraction": 0.5428372487, "num_tokens": 11703, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.5, "lm_q2_score": 0.021287353500946907, "lm_q1q2_score": 0.010643676750473454}}
{"text": "\n# Copyright 2018-2019, Carnegie Mellon University\n# See LICENSE for details\n\nClass(cos, AutoFoldExp, rec(\n computeType := (self) >> TReal,\n \n));\n\nClass(sin, AutoFoldExp, rec(\n computeType := (self) >> TReal,\n));\n\nClass(tan, AutoFoldExp, rec(\n computeType := (self) >> TReal,\n));\n\n\n\nClass(TIVReal, AtomicTyp, rec(\n hash := (_val, size) -> let(val := When(IsList(_val), _val, [_val, _val]),\n h := DoubleRep64(val[1]) + DoubleRep64(val[2]),\n 1 + (h mod size)),\n check := v -> Cond(IsDouble(v) or IsList(v) and Length(v) = 2 and v[1] <= v[2], v, Error(\"<v> must be a Double or an ordered list of length 2\")),\n realType := self >> self,\n print := self >> Print(self.__name__, \"(\", self.t, \")\"),\n base_t := self >> self.t,\n zero := self >> self.value(0.0),\n one := self >> self.value(1.0),\n __call__ := (self, t) >>\n WithBases(self, rec(\n t := Checked(IsType(t), t),\n operations := TypOps))\n));\n\nClass(TIVBool, AtomicTyp, rec(\n hash := (val, size) -> 1 + (InternalHash(val) mod size),\n check := v -> Cond(IsInt(v) and v in [0, 1, -1], v, Error(\"<v> must be in [-1, 0, 1]\")),\n zero := self >> self.value(0),\n one := self >> self.value(1)\n));\n\nClass(ivenv, chain);\n\n\nClass(RulesHCOLIVArithType, RuleSet, rec(inType := \"iCode\", outType := \"iCode\"));\nRewriteRules(RulesHCOLIVArithType, rec( \n\tivenv_prop_types_bools := ARule(ivenv, [[@(1, assign), @(2,var).cond(e->e.t<>TInt), \n\t\t@(3).cond(e-> e.t<>@(2).val.t and e.t=TBool)], @(4)], \n e->let( \t\t\t\t\t\t\n\t\tnvar := var.fresh_t(\"n\", TInt), \n\t\t#Print(\"New Type 2: \", @(1).val,\"(\",@(2).val, \",\",@(3).val,\")\\n\", @(2).val.t, \" <> \", @(3).val.t, \"\\n New Var Type: \", nvar, \",\",nvar.t,\" \\n\"),\n\t [decl([nvar], SubstVars(chain(assign(nvar, @(3).val), @(4).val), rec((@(2).val.id) := nvar )))] ) ),\n\n ivenv_prop_types := ARule(ivenv, [[@(1, assign), @(2,var), \n\t\t@(3).cond(e-> e.t<>@(2).val.t and not (e.t in [TVect(T_Real(64), 2), TIVReal, TBool]))], @(4,...)], \n e->let( \t\t\t\t\t\t\n\t\tnvar := var.fresh_t(\"n\", @(3).val.t), \n\t\t#Print(\"New Type: \", @(1).val,\"(\",@(2).val, \",\",@(3).val,\")\", @(2).val.t, \" <> \", @(3).val.t, \" \", nvar, \"\\n\", @(4).val, \"\\n\"),\n\t [decl([nvar], SubstVars(chain(assign(nvar, @(3).val), @(4).val), rec((@(2).val.id) := nvar )))] ) ),\n\n));\n\nClass(RulesHCOLIVArith, RuleSet, rec(inType := \"iCode\", outType := \"iCode\"));\nRewriteRules(RulesHCOLIVArith, rec(\n ivenv_chain := Rule(@(1, ivenv, e->ForAny(e.cmds, f->ObjId(f) = chain)),\n e->ApplyFunc(ivenv, Flat(List(@(1).val.cmds, j->When(ObjId(j)=chain, j.cmds, j))))),\n ivenv_xyz_decl := ARule(ivenv, [@(1), @(2, decl)], \n e->[decl(@(2).val.vars, chain(@(1).val, @(2).val.cmd))]),\t\n ivenv_decl := Rule(@(1, ivenv, e->ObjId(e.cmds[1])=decl), \n e -> decl(@(1).val.cmds[1].vars, ivenv(Concat([@(1).val.cmds[1].cmd], Drop(@(1).val.cmds, 1))))),\n ivenv_drop_selfassign := ARule(ivenv, [@(1, assign, e->IsVar(e.loc) and IsVar(e.exp) and e.exp=e.loc), @(2)], \n e->[@(2).val]), \n ivenv_creturn := Rule(@(1, ivenv, e->ObjId(Last(e.cmds))=creturn),\n e->chain(ivenv(DropLast(@(1).val.cmds, 1)), Last(@(1).val.cmds))),\n loop_pull_const_array_tcast := Rule([@(1, loop), @(2), @(3), [@(4, chain), [@(5, assign), @(6,var), [@(7, tcast), @(8), @(9,nth, e->IsValue(e.idx))]],...]], \n e->let(#Print(e, \"\\n\"), \n\t\tchain(@(5).val, loop(@(1).val.var, @(1).val.range, chain(Drop(@(4).val.cmds,1)))))),\n ivenv_state := Rule([@(1, tcast), @(2), @@(3, nth, (e, cx)->IsBound(cx.opts.state) and e.loc.id=cx.opts.state.id)], \n (e, cx)->nth(cx.opts.ivstate, e.args[2].idx) )\n));\n\n\n\nRulesCodeUnrollHACMIVArth := CopyFields(MergedRuleSet( RulesHCOLIVArith, RulesUnrollHCOL, RulesStrengthReduce, RulesCodeHCOL), \n rec(inType:=\"iCode\", outType := \"iCode\"));\n\nRulesCodeHACMIVArth := CopyFields(MergedRuleSet(RulesStrengthReduce, RulesCodeHCOL, RulesHCOLIVArith), \n rec(inType:=\"iCode\", outType := \"iCode\"));\n\nRulesCodeUnrollHACMIVArthType := CopyFields(MergedRuleSet(RulesCodeUnrollHACMIVArth, RulesHCOLIVArithType), \n\trec(inType :=\"iCode\", outType:=\"iCode\"));\n\t\nClass(IVArithMixin, rec(\n precision := \"double\", \n TRealCtype := \"double\",\n IVRealType := TIVReal(T_Real(64)),\n IVBoolType := TInt,\n IVValueType := TIVReal(T_Real(64)),\n codeRuleSet := RulesCodeUnrollHACMIVArth\n));\n\nClass(ivExp, errExp);\n\nClass(RealEPS, errExp);\n\nClass(RealMPS, errExp);\n\n\nClass(IVArith, SumsBase, BaseContainer, rec(\n rng := meth(self) return self._children[1].rng(); end,\n dmn := meth(self) return self._children[1].dmn(); end,\n toOperator := self >> (vec -> self.child(1).toOperator()(vec))\n));\n\nClass(TIVArith, Tagged_tSPL_Container, rec(\n abbrevs := [ s -> Checked(IsSPL(s), [s]) ],\n transpose := self >> CopyFields(self, rec(transposed := not self.transposed)),\n dims := self >> [self.params[1].dims()[1], self.params[1].dims()[2]],\n isReal := True,\n toOperator := self >> (vec -> let(r := self.params[1].toOperator()(vec), List(r, i->ivExp(i))))\n));\n\nNewRulesFor(TIVArith, rec(\n TIVArith_Base := rec(\n applicable := True,\n forTransposition := false,\n children := nt -> [[nt.params[1]]],\n apply := (t, C, Nonterms) -> IVArith(C[1])\n ) \n));\n\nHCOLSumsGen.IVArith := (self, o, opts) >> IVArith(self(o.child(1), opts));\n\nClass(TypeUpdate, HierarchicalVisitor, rec(\n\t__call__ := meth(arg)\n local res;\n res := ApplyFunc(arg[1].visit, arg{[2..Length(arg)]});\n return res;\n end,\n\tfunc := (self, o, opts) >> let(func(o.ret, o.id, o.params, self(o.cmd, opts))), \n\tdecl := (self, o, opts) >> decl(o.vars, self(o.cmd, opts)),\n\tchain := (self, o, opts) >> chain(List(o.cmds, i-> self(i, opts))),\n ivenv := (self, o, opts) >> ivenv(List(o.cmds, i-> self(i, opts))),\n loop := (self, o, opts) >> loop(o.var, o.range, self(o.cmd, opts)),\n\t\n\tassign := (self, o, opts) >> assign(o.loc, self(o.exp, opts)),\n\tadd := (self, o, opts) >> add(self(o.args[1], opts), self(o.args[2], opts)),\t\n\tsub := (self, o, opts) >> sub(self(o.args[1], opts), self(o.args[2], opts)),\n\tmul := (self, o, opts) >> mul(self(o.args[1], opts), self(o.args[2], opts)),\n\tdiv := (self, o, opts) >> div(self(o.args[1], opts), self(o.args[2], opts)),\n\tcond := (self, o, opts) >> cond(o.args[1], self(o.args[2], opts), self(o.args[3], opts)),\n\tabs := (self, o, opts) >> abs(self(o.args[1], opts)),\t\t\n\tlogic_and := (self, o, opts) >> logic_and(self(o.args[1], opts), self(o.args[2], opts)),\n\tlogic_or := (self, o, opts) >> logic_or(self(o.args[1], opts), self(o.args[2], opts)),\n\tgt := (self, o, opts) >> gt(self(o.args[1], opts), self(o.args[2], opts)),\n\tlt := (self, o, opts) >> lt(self(o.args[1], opts), self(o.args[2], opts)),\n\tgeq := (self, o, opts) >> geq(self(o.args[1], opts), self(o.args[2], opts)),\n\tleq := (self, o, opts) >> leq(self(o.args[1], opts), self(o.args[2], opts)),\n\tmin := (self, o, opts) >> min(self(o.args[1], opts), self(o.args[2], opts)),\n\tmax := (self, o, opts) >> max(self(o.args[1], opts), self(o.args[2], opts)),\n\t\n\tnth := (self, o, opts) >> o,\n\tValue := (self, o, opts) >> o,\t\t \n\tvar := (self, o, opts) >> o, \n\t\n\tskip := (self, o, opts) >> o,\t\n\ttcast := (self, o, opts) >> o,\n\t\n\tcreturn := (self, o, opts) >> o,\n\tcreturnCond := (self, o, opts) >> o,\n\t\n\teq := (self, o, opts) >> eq(self(o.args[1], opts), self(o.args[2], opts)),\n));\n\nHCOLCodegen.IVArith := (self, o, y, x, opts) >> let( \n\t#Generate non interval code\n cc := opts.codegen.OLCompose(o.child(1), y, x, opts),\n\t\n\t#Collect array of bools and make them into arrays of ints\n\tba_vars := Filtered(FoldL(Collect(cc, var), (a,b)->When(not b.id in List(a, i->i.id), Concat([b],a), a), []), \n \t e->ObjId(e.t) = TArray and e.t.base_t()=TBool),\n ba_nvars := List(ba_vars, c-> [c, var.fresh_t(\"U\", TArray(TInt, c.t.size))] ),\n ba_svars := FoldL(ba_nvars, (b, a)->CopyFields(rec((a[1].id):= a[2]), b), rec()),\n ba_cc1 := decl(List(ba_nvars, c->c[2]), SubstVars(cc, ba_svars)),\n\t\n\t#Cast bools variables into ints but make sure that they are not part of the input parameters\n\tb_vars :=Unique(Collect(ba_cc1, @(1,var).cond(e->e.t = TBool))),\n\tb_local_vars := Difference(b_vars, opts.params),\n\tb_global_vars := Difference(b_vars, b_local_vars),\t\n\tb_no_global := SubstBottomUp(ba_cc1, @(1,var).cond(e->e.t=TBool), f->let(Print(@(1).val.id, \"\\n\"), \n\t\t\t\t\t\t\ttcast(TInt, @(1).val))),\n\t\n\t#Cast pointers to bools into pointers to ints\n\tb_cc2 := b_no_global,\n\t\n\t#Convert boolean constants into ints\n\tb_cc3 := SubstBottomUp(b_cc2, @(1,Value).cond(e->e.t=TBool), \n f->let(#Print(@(1).val, \"\\n\"), \n\t\t\tCond(@(1).val=V_true, V(1), \n\t\t\t @(1).val=V_false, V(0),\n\t\t\t\t\t\t @(1).val))),\n\t\n\t#Collect array variables make them into arrays of intervals\n vars := Filtered(FoldL(Collect(b_cc3, var), (a,b)->When(not b.id in List(a, i->i.id), Concat([b],a), a), []), \n \t e->ObjId(e.t) = TArray and e.t.base_t() in [TReal, TDouble, T_Real(32), T_Real(64)]),\n nvars := List(vars, c-> [c, var.fresh_t(\"U\", TArray(TIVReal(c.t.base_t()), c.t.size))] ),\n svars := FoldL(nvars, (b, a)->CopyFields(rec((a[1].id):= a[2]), b), rec()),\n cc1 := decl(List(nvars, c->c[2]), SubstVars( cc, svars)),\n\n\t#Cast doubles and reals variables into intervals\n cc11 := SubstBottomUp(cc1, @(1,var).cond(e->e.t in [TReal, TDouble, T_Real(32), T_Real(64)]), f->tcast(opts.IVRealType, @(1).val)),\n\n\t#Cast pointers to doubles and reals into intervals\n cc2 := SubstBottomUp(cc11, [@(1,nth), @(2, var, e->ObjId(e.t) = TPtr and e.t.base_t() in [TReal, TDouble, T_Real(32), T_Real(64)]), @(3)], f->tcast(opts.IVRealType, @(1).val)),\n\t\n\t#Cast constants into intervals\n cc3 := SubstBottomUp(cc2, @(1,Value).cond(e->e.t in [TReal, TDouble, T_Real(32), T_Real(64)]), \n f->let(tcast(opts.IVValueType, @(1).val))),\n\n\tresult := ivenv(cc3),\n\t\n\tresult2 := TypeUpdate(result, opts),\n\t\n\tresult2\n);\n\nHCOLUnparser.RealEPS := (self,o,i,is) >> Print(Cond(o.args[1] = T_Real(64), \"DBL_MIN\", o.args[1] = T_Real(32), \"FLT_MIN\", \"UNKNOWN_MIN\"));\nHCOLUnparser.RealMPS := (self,o,i,is) >> Print(Cond(o.args[1] = T_Real(64), \"DBL_MAX\", o.args[1] = T_Real(32), \"FLT_MAX\", \"UNKNOWN_MAX\"));\nHCOLUnparser.ivenv := (self,o,i,is) >> self(chain(o.cmds), i, is);\n\nHCOLUnparser.TIVReal := (self, t, vars, i, is) >> \t\n\t\tPrint(\"interval_t \", self.infix(vars, \", \", i + is));\nHCOLUnparser.TVect := (self, t, vars, i, is) >> Print(\"abc_interval_t \", self.infix(vars, \", \", i + is));\n\n\n\n\n\nHCOLSSEUnparser.ivenv := (self,o,i,is) >> Print(Blanks(i), \"{\\n\",\n Blanks(i+is), \"unsigned _xm = _mm_getcsr();\\n\",\n Blanks(i+is), \"_mm_setcsr(_xm & 0xffff0000 | 0x0000dfc0);\\n\",\n self(chain(o.cmds),i+is,is),\n Blanks(i+is), \n Cond(IsBound(self.opts.compiler) and self.opts.compiler = \"IntelC\", \"__asm nop;\\n\", \n IsBound(self.opts.compiler) and self.opts.compiler = \"GnuC\", \"asm volatile(\\\"\\\":::\\\"memory\\\");\\n\",\n \"// BASIC BLOCK BARRIER\\n\"\n ),\n Blanks(i+is), \"if (_mm_getcsr() & 0x0d) {\\n\",\n Blanks(i+2*is), \"_mm_setcsr(_xm);\\n\",\n\tBlanks(i+2*is),\n Cond(self.opts.useCReturn, \"return -1;\\n\", \"Y[0] = -1;\\n\"),\n Blanks(i+is), \"}\\n\",\n Blanks(i+is), \"_mm_setcsr(_xm);\\n\",\n Blanks(i), \"}\\n\");\n\t\nHCOLSSEUnparser.RealEPS := HCOLUnparser.RealEPS;\nHCOLSSEUnparser.RealMPS := HCOLUnparser.RealMPS;\n\n\nDeclare(ToIVArithBasic);\n\nClass(ToIVArithBasic_Base, HierarchicalVisitor, rec(\n __call__ := meth(arg)\n local res;\n res := ApplyFunc(arg[1].visit, arg{[2..Length(arg)]});\n trace_log.addConversion(ObjId(arg[2]), arg[2], res, var);\n return res;\n end,\n func := (self, o, opts) >> let(Print(\"CONVERSION\\n\\n\"), \n\t\tfunc(o.ret, o.id, FoldL(o.params, (a, b)->Concat(a, When(IsBound(opts.state) and b=opts.state, [opts.ivstate], [b])), []), self(o.cmd, opts))),\n creturn := (self, o, opts) >> o,\n\tcreturnCond := (self, o, opts) >> o,\n decl := (self, o, opts) >> let(\n ovars := Filtered(o.vars, e->ObjId(e.t) = TIVReal),\n svars := FoldR(ovars, (b,a)->CopyFields(rec((a.id):=var.fresh_t(\"u\", TVect(T_Real(64), 2))), b), rec()),\n vars := Filtered(o.vars, e->ObjId(e.t) <> TIVReal)::List(Filtered(RecFields(svars), i->not i in SystemRecFields), i->svars.(i)),\n cmd := SubstVars(o.cmd, svars),\n decl(vars, self(cmd, opts))),\n chain := (self, o, opts) >> chain(List(o.cmds, i-> self(i, opts))),\n ivenv := (self, o, opts) >> ivenv(List(o.cmds, i-> ToIVArithBasic(i, opts))),\n loop := (self, o, opts) >> loop(o.var, o.range, self(o.cmd, opts)),\n nth := (self, o, opts) >> o,\n\t\n Value := (self, o, opts) >> let(\n When(ObjId(o.t) = TIVReal, \n TVect(T_Real(64), 2).value([-o.v, o.v]), \n o)),\n\t\t \n\tskip := (self, o, opts) >> o,\n\t\n\ttcast := (self, o, opts) >> o,\n\tlogic_and := (self, o, opts) >> o,\n\tlogic_or := (self, o, opts) >> o,\n\tassign := (self, o, opts) >> o, \n));\n\nClass(ToIVArithBasic, HierarchicalVisitor, rec(\n __call__ := meth(arg)\n local res;\n res := ApplyFunc(arg[1].visit, arg{[2..Length(arg)]});\n trace_log.addConversion(ObjId(arg[2]), arg[2], res, var);\n return res;\n end,\n func := (self, o, opts) >> let(Print(\"CONVERSION\\n\\n\"), \n\t\tfunc(o.ret, o.id, FoldL(o.params, (a, b)->Concat(a, When(IsBound(opts.state) and b=opts.state, [opts.ivstate], [b])), []), self(o.cmd, opts))),\n creturn := (self, o, opts) >> o,\n\tcreturnCond := (self, o, opts) >> o,\n decl := (self, o, opts) >> let(\n ovars := Filtered(o.vars, e->ObjId(e.t) = TIVReal),\n svars := FoldR(ovars, (b,a)->CopyFields(rec((a.id):=var.fresh_t(\"u\", TVect(T_Real(64), 2))), b), rec()),\n vars := Filtered(o.vars, e->ObjId(e.t) <> TIVReal)::List(Filtered(RecFields(svars), i->not i in SystemRecFields), i->svars.(i)),\n cmd := SubstVars(o.cmd, svars),\n decl(vars, self(cmd, opts))),\n chain := (self, o, opts) >> chain(List(o.cmds, i-> self(i, opts))),\n ivenv := (self, o, opts) >> ivenv(List(o.cmds, i-> self(i, opts))),\n loop := (self, o, opts) >> loop(o.var, o.range, self(o.cmd, opts)),\n nth := (self, o, opts) >> o,\n\t\n Value := (self, o, opts) >> let(\n When(ObjId(o.t) = TIVReal, \n TVect(T_Real(64), 2).value([-o.v, o.v]), \n o)),\n\t\t \n\tskip := (self, o, opts) >> o,\n\t\n\ttcast := (self, o, opts) >> o,\n \t\t\n\tlogic_and := (self, o, opts) >> cond(eq(o.args[1],o.args[2]), o.args[1], mul(o.args[1], o.args[2])),\n\tlogic_or := (self, o, opts) >> cond(logic_or(eq(o.args[1], 1), eq(o.args[2],1)), 1, min(o.args[1], o.args[2])),\n\n assign := (self, o, opts) >> let( \t \n\t Cond(\n\t ObjId(o.exp) = var, \n\t\t\tlet(\n\t\t\t\tchain(\n\t\t\t\t\tassign(o.loc[1], tcast(o.loc[1].t,o.exp)),\n\t\t\t\t\tassign(o.loc[2], tcast(o.loc[2].t,o.exp))\n\t\t\t\t)\t\t\t\t\n\t\t\t),\t\t\t\n\t ObjId(o.exp) = tcast and (o.exp.args[1] = TIVReal or o.exp.args[1] = TVect(T_Real(64), 2)),\n\t\t\t\tCond(\t\t\t\t\t\n\t\t\t\t\to.exp.args[2].t = T_Real(32), \n\t\t\t\t\t\tlet(\n\t\t\t\t\t\t\tx0 := var.fresh_t(\"x\", T_Real(64)), \n\t\t\t\t\t\t\tx1 := var.fresh_t(\"x\", T_Real(64)), \t\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\tdecl([x0, x1], chain(\n\t\t\t\t\t\t\t\tself(assign([x0,x1], o.exp.args[2]), opts), \t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\tassign(o.loc[1], x0+RealEPS(T_Real(32))),\n\t\t\t\t\t\t\t\tassign(o.loc[2], x1-RealEPS(T_Real(32)))\n\t\t\t\t\t\t\t))\n\t\t\t\t\t\t),\n\t\t\t\t\tIsDouble(o.exp.args[2]), \n\t\t\t\t\t\tlet(\n\t\t\t\t\t\t\tx0 := var.fresh_t(\"x\", T_Real(64)), \n\t\t\t\t\t\t\tx1 := var.fresh_t(\"x\", T_Real(64)), \t\t\n\t\t\t\t\t\t\tdecl([x0, x1], chain(\n\t\t\t\t\t\t\t\tself(assign([x0,x1], o.exp.args[2]), opts), \t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\tassign(o.loc[1], x0),\n\t\t\t\t\t\t\t\tassign(o.loc[2], -x1)\n\t\t\t\t\t\t\t))\n\t\t\t\t\t\t),\n\t\t\t\t\tError(\"Don't know how to convert <o.args[2]> to an interval.\")),\n\t\tObjId(o.exp) = lt and ForAll(o.exp.args, i->i.t = TIVReal or i.t = TVect(T_Real(64), 2)),\n let(\n\t\t\t\tx10 := var.fresh_t(\"x\", T_Real(64)), \n\t\t\t\tx11 := var.fresh_t(\"x\", T_Real(64)), \n\t\t\t\tx20 := var.fresh_t(\"x\", T_Real(64)), \n\t\t\t\tx21 := var.fresh_t(\"x\", T_Real(64)), \t\t\t\t\n decl([x10, x11, x20, x21], chain(\n\t\t\t\t\tself(assign([x10, x11], o.exp.args[1]), opts),\n\t\t\t\t\tself(assign([x20, x21], o.exp.args[2]), opts),\t\t\t\t\t\n\t\t\t\t\tassign(o.loc, tcast(TInt, cond(lt(x10, x21), V(1), cond(lt(x20,x11), V(0),V(-1)))))\n ))\n ),\n\t\tObjId(o.exp) = gt and ForAll(o.exp.args, i->i.t = TIVReal or i.t = TVect(T_Real(64), 2)),\n let(x10 := var.fresh_t(\"x\", T_Real(64)), \n\t\t\t\tx11 := var.fresh_t(\"x\", T_Real(64)), \n\t\t\t\tx20 := var.fresh_t(\"x\", T_Real(64)), \n\t\t\t\tx21 := var.fresh_t(\"x\", T_Real(64)), \t\t\t\t\n decl([x10, x11, x20, x21], chain(\n\t\t\t\t\tself(assign([x10, x11], o.exp.args[1]), opts),\n\t\t\t\t\tself(assign([x20, x21], o.exp.args[2]), opts),\t\t\t\t\t\n\t\t\t\t\tassign(o.loc, tcast(TInt, cond(gt(x11, x20), V(1), cond(gt(x21, x10), V(0), V(-1)))))\n ))\n ),\n\t\n\t\tObjId(o.exp) = add and ForAll(o.exp.args, i->i.t = TIVReal or i.t = TVect(T_Real(64), 2)),\n\t\t\tlet(x10 := var.fresh_t(\"x\", T_Real(64)), \n\t\t\t\tx11 := var.fresh_t(\"x\", T_Real(64)), \n\t\t\t\tx20 := var.fresh_t(\"x\", T_Real(64)), \n\t\t\t\tx21 := var.fresh_t(\"x\", T_Real(64)), \t\t\t\t\n\t\t\t\tdecl([x10, x11, x20, x21], chain(\n\t\t\t\t\tself(assign([x10, x11], o.exp.args[1]), opts),\n\t\t\t\t\tself(assign([x20, x21], o.exp.args[2]), opts),\t\t\t\t\t\n\t\t\t\t\tassign(o.loc[1], add(x11, x21)),\n\t\t\t\t\tassign(o.loc[2], add(x10, x20)) \n\t\t\t\t)) \n\t\t ),\n\t\tObjId(o.exp) = sub and ForAll(o.exp.args, i->i.t = TIVReal or i.t = TVect(T_Real(64), 2)),\n\t\t\tlet(x10 := var.fresh_t(\"x\", T_Real(64)), \n\t\t\t\tx11 := var.fresh_t(\"x\", T_Real(64)), \n\t\t\t\tx20 := var.fresh_t(\"x\", T_Real(64)), \n\t\t\t\tx21 := var.fresh_t(\"x\", T_Real(64)), \t\t\t\t\n\t\t\t\tdecl([x10, x11, x20, x21], chain(\n\t\t\t\t\tself(assign([x10, x11], o.exp.args[1]), opts),\n\t\t\t\t\tself(assign([x20, x21], o.exp.args[2]), opts),\n\t\t\t\t\tassign(o.loc[1], sub(x11, x20)), \n\t\t\t\t\tassign(o.loc[2], sub(x10, x21))\n\t\t\t\t)) \n\t\t\t),\n\t\tObjId(o.exp) = abs and ForAll(o.exp.args, i->i.t = TIVReal or i.t = TVect(T_Real(64), 2)),\n let(\t\t\t\t\n\t\t\t\tx10 := var.fresh_t(\"x\", T_Real(64)), \n\t\t\t\tx11 := var.fresh_t(\"x\", T_Real(64)),\n\t\t\t\tx2 := var.fresh_t(\"x\", T_Real(64)), \n\t\t\t\tx3 := var.fresh_t(\"x\", T_Real(64)),\n decl([x10, x11, x2, x3], chain(\n\t\t\t\t\tself(assign([x10, x11], o.exp.args[1]), opts),\n\t\t\t\t\tassign(x2, abs(x10)),\n\t\t\t\t\tassign(x3, abs(x11)),\n\t\t\t\t\tassign(o.loc[1], max(x2, x3)),\n\t\t\t\t\tassign(o.loc[2], min(x2, x3))\n ))\n ),\t\t\n\t\tassign(o.loc, self(o.exp, opts)) \n )),\t\t\n));\n\n\nClass(ToIVArithSSE, HierarchicalVisitor, rec(\n __call__ := meth(arg)\n local res;\n res := ApplyFunc(arg[1].visit, arg{[2..Length(arg)]});\n trace_log.addConversion(ObjId(arg[2]), arg[2], res, var);\n return res;\n end,\n func := (self, o, opts) >> let(#Print(\"CONVERSION\\n\\n\"), \n\t\tfunc(o.ret, o.id, FoldL(o.params, (a, b)->Concat(a, When(IsBound(opts.state) and b=opts.state, [opts.ivstate], [b])), []), self(o.cmd, opts))),\n creturn := (self, o, opts) >> o,\n\tcreturnCond := (self, o, opts) >> o,\n decl := (self, o, opts) >> let(\n ovars := Filtered(o.vars, e->ObjId(e.t) = TIVReal),\n svars := FoldR(ovars, (b,a)->CopyFields(rec((a.id):=var.fresh_t(\"u\", TVect(T_Real(64), 2))), b), rec()),\n vars := Filtered(o.vars, e->ObjId(e.t) <> TIVReal)::List(Filtered(RecFields(svars), i->not i in SystemRecFields), i->svars.(i)),\n cmd := SubstVars(o.cmd, svars),\n decl(vars, self(cmd, opts))),\n chain := (self, o, opts) >> chain(List(o.cmds, i-> self(i, opts))),\n ivenv := (self, o, opts) >> ivenv(List(o.cmds, i-> self(i, opts))),\n loop := (self, o, opts) >> loop(o.var, o.range, self(o.cmd, opts)),\n nth := (self, o, opts) >> o,\n Value := (self, o, opts) >> let(\n When(ObjId(o.t) = TIVReal, \n TVect(T_Real(64), 2).value([-o.v, o.v]), \n o)),\n var := (self, o, opts) >> o,\n\tskip := (self, o, opts) >> o,\n tcast := (self, o, opts) >> Cond(\n IsDouble(o.args[2]), vpack(-o.args[2], o.args[2]),\t\n\tIsValue(o.args[2]), TVect(T_Real(64), 2).value([-o.args[2].v, o.args[2].v]),\n o.args[2].t = T_Real(32), addsub_2x64f(vcvt_64f32f(vdup(RealEPS(T_Real(32)), 4)), vcvt_64f32f(vdup(o.args[2], 4))),\n o.args[2].t = T_Real(64), addsub_2x64f(vdup(RealEPS(T_Real(64))+RealEPS(T_Real(64)), 2), vdup(o.args[2], 2)),\n\to.args[2].t = TIVReal(T_Real(64)), TVect(T_Real(64),2).value(o.args[2]),\n Error(\"Don't know how to convert <o.args[2]> to an interval.\")),\n\t\t\n\tlogic_and := (self, o, opts) >> cond(eq(o.args[1],o.args[2]), o.args[1], mul(o.args[1], o.args[2])),\n\tlogic_or := (self, o, opts) >> cond(logic_or(eq(o.args[1], 1), eq(o.args[2],1)), 1, min(o.args[1], o.args[2])),\n\n testc_4x32i:= (self, o, opts) >> o, \n\n assign := (self, o, opts) >> Cond(\n\t ObjId(o.exp) = add and (o.loc.t = TIVReal or o.loc.t = TVect(T_Real(64), 2)),\n\t\t let(\n\t\t\tx1 := var.fresh_t(\"x\", TVect(T_Real(64), 2)), x2 := var.fresh_t(\"x\", TVect(T_Real(64), 2)),\n\t\t\tdecl([x1, x2], chain(\n\t\t\t\tcomment(\"addition\"),\n\t\t\t\tself(assign(x1, o.exp.args[1]), opts), \n\t\t\t\tself(assign(x2, o.exp.args[2]), opts), \n\t\t\t\tassign(o.loc, add(x1, x2)) ) ) \n\t\t ),\n\t\tObjId(o.exp) = sub and (o.loc.t = TIVReal or o.loc.t = TVect(T_Real(64), 2)),\n\t\t let(\n\t\t\tx1 := var.fresh_t(\"x\", TVect(T_Real(64), 2)), x2 := var.fresh_t(\"x\", TVect(T_Real(64), 2)),\n\t\t\tdecl([x1, x2], chain(\n\t\t\t\tcomment(\"sub\"),\n\t\t\t\tself(assign(x1, o.exp.args[1]), opts), \n\t\t\t\tself(assign(x2, o.exp.args[2]), opts), \n\t\t\t\tassign(o.loc, add(x1, vushuffle_2x64f(x2, vparam([2,1])))) ) ) \n\t\t ),\n ObjId(o.exp) = mul and (o.loc.t = TIVReal or o.loc.t = TVect(T_Real(64), 2)),\n let(u := var.fresh_t(\"x\", TVect(T_Real(64), 2)), a := var.fresh_t(\"x\", TVect(T_Real(64), 2)), \n b := var.fresh_t(\"x\", TVect(T_Real(64), 2)), c := var.fresh_t(\"x\", TVect(T_Real(64), 2)),\n x1 := var.fresh_t(\"x\", TVect(T_Real(64), 2)), x2 := var.fresh_t(\"x\", TVect(T_Real(64), 2)),\n decl([u, a, b, c, x1, x2], chain(\n\t\t\t\t\tcomment(\"mul\"),\n\t\t\t\t\tself(assign(x1, o.exp.args[1]), opts),\n\t\t\t\t\tself(assign(x2, o.exp.args[2]), opts),\n assign(u, addsub_2x64f(TVect(T_Real(64), 2).zero(), x1)),\n assign(a, mul(u, x2)),\n assign(b, mul(vushuffle_2x64f(u, vparam([2,1])), x2)),\n assign(c, neg(min(a, b))),\n assign(o.loc, add(max(max(a, b), vushuffle_2x64f(c, vparam([2,1]))), vdup(RealEPS(T_Real(64)), 2)))\n ))\n ),\n ObjId(o.exp) = abs and (o.loc.t = TIVReal or o.loc.t = TVect(T_Real(64), 2)),\n let(u := var.fresh_t(\"x\", TVect(T_Real(64), 2)), x1 := var.fresh_t(\"x\", TVect(T_Real(64), 2)),\n decl([u, x1], chain(\n\t\t\t\t\tcomment(\"abs\"),\t\n self(assign(x1, o.exp.args[1]), opts),\n assign(u, vushuffle_2x64f(x1, vparam([2,1]))),\n assign(o.loc, vshuffle_2x64f(min(x1, u), max(x1, u), vparam([1,2])))\n ))\n ),\n\t\tObjId(o.exp) = pow and (o.loc.t = TIVReal or o.loc.t = TVect(T_Real(64), 2)) and IsValue(o.exp.args[2]) and o.exp.args[2].v = 2, \n\t\t\tlet( x1 := var.fresh_t(\"x\", TVect(T_Real(64), 2)),\n\t\t\t\tdecl([x1], chain(\n\t\t\t\t\tself(assign(x1, mul(o.exp.args[1],o.exp.args[1])), opts),\n\t\t\t\t\tassign(o.loc, x1)\n\t\t\t\t))\n\t\t\t),\n\t\tObjId(o.exp) = pow and (o.loc.t = TIVReal or o.loc.t = TVect(T_Real(64), 2)) and IsValue(o.exp.args[2]) and IsInt(o.exp.args[2].v) and o.exp.args[2] > 2, \n\t\t\tlet( x1 := var.fresh_t(\"x\", TVect(T_Real(64), 2)),\n\t\t\t\tdecl([x1], chain(\n\t\t\t\t\tself(assign(x1, mul(o.exp.args[1], pow(o.exp.args[1],o.exp.args[2].v-1))), opts),\n\t\t\t\t\tassign(o.loc, x1)\n\t\t\t\t))\n\t\t\t),\t\t\t\t\t\t\t\n\t\t\t\n\t\tObjId(o.exp) = div and (o.loc.t = TIVReal or o.loc.t = TVect(T_Real(64), 2)) and not IsValue(o.exp.args[1]),\t\t\n\t\t\tlet( \n\t\t\tPrint(\"DIVISION - PART 1\\n\"),\n\t\t\t x1 := var.fresh_t(\"x\", TVect(T_Real(64), 2)),\t\t\t \n\t\t\t decl([x1], chain(\n\t\t\t\tself(assign(x1, mul(o.exp.args[1], 1.0/o.exp.args[2])), opts),\n\t\t\t\tassign(o.loc, x1)\n\t\t\t ))\n\t\t\t),\n\t\t\t\n\t\tObjId(o.exp) = div and <#o.loc.t = TIVReal or o.loc.t = TVect(T_Real(64), 2)) and #>IsValue(o.exp.args[1]),\n\t\t\tlet( \t\t\t\n\t\t\t\tx1 := var.fresh_t(\"x\", TVect(T_Real(64), 2)),\t\t\t \n\t\t\t\tdecl([x1], chain(\t\t\t\t\n\t\t\t\t\tassign(x1, vdiv_2x64f(TVect(T_Real(64), 2).value([-o.exp.args[1].v,o.exp.args[1].v]), o.exp.args[2])),\n\t\t\t\t\tassign(o.loc, vshuffle_2x64f(x1, x1, vparam([2,1])))\n\t\t\t\t))\n\t\t\t),\n\t\tObjId(o.exp) = neg and (o.loc.t = TIVReal or o.loc.t = TVect(T_Real(64), 2)),\n\t\t let(x1 := var.fresh_t(\"x\", TVect(T_Real(64), 2)),x2 := var.fresh_t(\"x\", TVect(T_Real(64), 2)),\n\t\t\t\tdecl([x1], chain(\n\t\t\t\t\tself(assign(x1, TVect(T_Real(64), 2).value([0,0]), opts)),\n\t\t\t\t\tself(assign(x2, sub(x1, o.exp.args[1])), opts),\n\t\t\t\t\tassign(o.loc, x2)\n\t\t\t\t))\n\t\t\t),\t\t\t\n ObjId(o.exp) = max and (o.loc.t = TIVReal or o.loc.t = TVect(T_Real(64), 2)),\n let(x1 := var.fresh_t(\"x\", TVect(T_Real(64), 2)), x2 := var.fresh_t(\"x\", TVect(T_Real(64), 2)),\n decl([x1, x2], chain(\t\t\t\t\t\n self(assign(x1, o.exp.args[1]), opts),\n self(assign(x2, o.exp.args[2]), opts),\n assign(o.loc, vshuffle_2x64f(min(x1, x2), max(x1, x2), vparam([1, 2])))\n ))\n ),\t\t \n ObjId(o.exp) = min and (o.loc.t = TIVReal or o.loc.t = TVect(T_Real(64), 2)),\n let(x1 := var.fresh_t(\"x\", TVect(T_Real(64), 2)), x2 := var.fresh_t(\"x\", TVect(T_Real(64), 2)),\n decl([x1, x2], chain(\n self(assign(x1, o.exp.args[1]), opts),\n self(assign(x2, o.exp.args[2]), opts),\n assign(o.loc, vshuffle_2x64f(max(x1, x2), min(x1, x2), vparam([1, 2])))\n ))\n ),\t\t\n ObjId(o.exp) = geq <#and (o.loc.t = TBool or o.loc.t = TInt)#> and ForAll(o.exp.args, i->i.t = TIVReal or i.t = TVect(T_Real(64), 2)),\n let(x1 := var.fresh_t(\"x\", TVect(T_Real(64), 2)), x2 := var.fresh_t(\"x\", TVect(T_Real(64), 2)), u := var.fresh_t(\"x\", TVect(T_Real(64), 2)), \n decl([x1, x2, u], chain(\n\t\t\t\t\tcomment(\"geq\"),\t\n assign(x1, addsub_2x64f(TVect(T_Real(64), 2).zero(), self(o.exp.args[1], opts))),\n assign(x2, addsub_2x64f(TVect(T_Real(64), 2).zero(), self(o.exp.args[2], opts))),\n assign(u, cmpge_2x64f(x1, vushuffle_2x64f(x2, vparam([2, 1])))),\n assign(o.loc, sub(\n testc_4x32i(tcast(TVect(T_Int(32), 4), u), vhex(Replicate(4, \"0xffffffff\"))), \n testnzc_4x32i(tcast(TVect(T_Int(32), 4), u), vhex(Replicate(4, \"0xffffffff\")))))\n ))\n ),\n ObjId(o.exp) = leq <#and o.loc.t = TBool#> and ForAll(o.exp.args, i->i.t = TIVReal or i.t = TVect(T_Real(64), 2)),\n let(x1 := var.fresh_t(\"x\", TVect(T_Real(64), 2)), x2 := var.fresh_t(\"x\", TVect(T_Real(64), 2)), u := var.fresh_t(\"x\", TVect(T_Real(64), 2)),\n decl([x1, x2, u], chain(\n assign(x1, addsub_2x64f(TVect(T_Real(64), 2).zero(), self(o.exp.args[1], opts))),\n assign(x2, addsub_2x64f(TVect(T_Real(64), 2).zero(), self(o.exp.args[2], opts))),\n assign(u, cmple_2x64f(x1, vushuffle_2x64f(x2, vparam([2, 1])))),\n assign(o.loc, sub(\n testc_4x32i(tcast(TVect(T_Int(32), 4), u), vhex(Replicate(4, \"0xffffffff\"))), \n testnzc_4x32i(tcast(TVect(T_Int(32), 4), u), vhex(Replicate(4, \"0xffffffff\")))))\n ))\n ),\n\t\tObjId(o.exp) = gt <#and (o.loc.t = TBool or o.loc.t = TInt)#> and ForAll(o.exp.args, i->i.t = TIVReal or i.t = TVect(T_Real(64), 2)),\n let(x1 := var.fresh_t(\"x\", TVect(T_Real(64), 2)), x2 := var.fresh_t(\"x\", TVect(T_Real(64), 2)), u := var.fresh_t(\"x\", TVect(T_Real(64), 2)), \n decl([x1, x2, u], chain(\n assign(x1, addsub_2x64f(TVect(T_Real(64), 2).zero(), self(o.exp.args[1], opts))),\n assign(x2, addsub_2x64f(TVect(T_Real(64), 2).zero(), self(o.exp.args[2], opts))),\n assign(u, cmpgt_2x64f(x1, vushuffle_2x64f(x2, vparam([2, 1])))),\n assign(o.loc, sub(\n testc_4x32i(tcast(TVect(T_Int(32), 4), u), vhex(Replicate(4, \"0xffffffff\"))), \n testnzc_4x32i(tcast(TVect(T_Int(32), 4), u), vhex(Replicate(4, \"0xffffffff\")))))\n ))\n ),\n ObjId(o.exp) = lt <#and o.loc.t = TBool#> and ForAll(o.exp.args, i->i.t = TIVReal or i.t = TVect(T_Real(64), 2)),\n let(x1 := var.fresh_t(\"x\", TVect(T_Real(64), 2)), x2 := var.fresh_t(\"x\", TVect(T_Real(64), 2)), u := var.fresh_t(\"x\", TVect(T_Real(64), 2)),\n decl([x1, x2, u], chain(\n assign(x1, addsub_2x64f(TVect(T_Real(64), 2).zero(), self(o.exp.args[1], opts))),\n assign(x2, addsub_2x64f(TVect(T_Real(64), 2).zero(), self(o.exp.args[2], opts))),\n assign(u, cmplt_2x64f(x1, vushuffle_2x64f(x2, vparam([2, 1])))),\n assign(o.loc, sub(\n testc_4x32i(tcast(TVect(T_Int(32), 4), u), vhex(Replicate(4, \"0xffffffff\"))), \n testnzc_4x32i(tcast(TVect(T_Int(32), 4), u), vhex(Replicate(4, \"0xffffffff\")))))\n ))\n ),\t\t\t\t\n\t\tObjId(o.exp) = eq,\n\t\t\tlet(Error(\"Eq not implemented for interval arithmetic.\")),\n\t\tObjId(o.exp) = neq,\n\t\t\tlet(Error(\"Neq not implemented for interval arithmetic.\")),\n\t\t\t\n assign(o.loc, self(o.exp, opts))\n ),\t\t\t\t\t\t\t\t \t\n mul := (self, o, opts) >> ApplyFunc(ObjId(o), List(o.args, i-> self(i, opts))),\n abs := (self, o, opts) >> ApplyFunc(ObjId(o), List(o.args, i-> self(i, opts))),\n max := (self, o, opts) >> ApplyFunc(ObjId(o), List(o.args, i-> self(i, opts))),\n\tadd := (self, o, opts) >> ApplyFunc(ObjId(o), List(o.args, i-> self(i, opts))),\n\tsub := (self, o, opts) >> ApplyFunc(ObjId(o), List(o.args, i-> self(i, opts))),\n geq := (self, o, opts) >> ApplyFunc(ObjId(o), List(o.args, i-> self(i, opts))),\n leq := (self, o, opts) >> ApplyFunc(ObjId(o), List(o.args, i-> self(i, opts))),\n\tgt := (self, o, opts) >> ApplyFunc(ObjId(o), List(o.args, i-> self(i, opts))),\n lt := (self, o, opts) >> ApplyFunc(ObjId(o), List(o.args, i-> self(i, opts))),\n\tpow := (self, o, opts) >> ApplyFunc(ObjId(o), List(o.args, i-> self(i, opts))),\n\tdiv := (self, o, opts) >> ApplyFunc(ObjId(o), List(o.args, i-> self(i, opts))),\n));\n\nHCOLSSEUnparser.TIVReal := (self, t, vars, i, is) >> Print(\"__m128d \", self.infix(vars, \", \", i + is));\n\nCoSynthesizeStrategies.IVArithSSE := [ (t, opts) -> RandomRuleTree(t, opts), \n (rt, opts) -> SPLRuleTree(rt),\n (s, opts) -> SumsSPL(s, opts),\n (s, opts) -> Rewrite(s, [RulesSumsHCOLv2a, RulesTerminateReductionHCOL, RulesSumsHCOLv2b], opts),\n (s, opts) -> HCOLProof_Codegen(s, opts),\n (c, opts) -> Rewrite(c, RulesCodeUnrollHACMIVArth, opts),\n (c, opts) -> HCOLProof_CodeConversion(c, ToIVArithSSE, opts),\n (c, opts) -> Rewrite(c, RulesCodeUnrollHACMIVArthType, opts) ];\n\n\t\t\nCoSynthesizeStrategies.IVArithBasic := [ (t, opts) -> RandomRuleTree(t, opts), \n (rt, opts) -> SPLRuleTree(rt),\n (s, opts) -> SumsSPL(s, opts),\n (s, opts) -> Rewrite(s, [RulesSumsHCOLv2a, RulesTerminateReductionHCOL, RulesSumsHCOLv2b], opts),\n (s, opts) -> HCOLProof_Codegen(s, opts),\n (c, opts) -> Rewrite(c, RulesCodeUnrollHACMIVArth, opts),\n (c, opts) -> HCOLProof_CodeConversion(c, ToIVArithBasic_Base, opts),\n (c, opts) -> Rewrite(c, RulesCodeUnrollHACMIVArth, opts) ];\t\t\n\t\t\nHCOLSSEUnparser.addsub_2x64f := (self, o, i, is) >> Checked(Length(o.args) = 2,\n CondPat(o,\n [addsub_2x64f, @TReal, @TVect], self(addsub_2x64f(vdup(o.args[1],o.t.size), o.args[2]), i, is),\n [addsub_2x64f, @TVect, @TReal], self(addsub_2x64f(o.args[1], vdup(o.args[2], o.t.size)), i, is),\n [addsub_2x64f, @TInt, @TVect], self(addsub_2x64f(vdup(_toReal(o.args[1]), o.t.size), o.args[2]), i, is),\n [addsub_2x64f, @TVect, @TInt], self(addsub_2x64f(o.args[1], vdup(_toReal(o.args[2]), o.t.size)), i, is),\n [addsub_2x64f, @TVect, @TVect], self.printf(\"_mm_addsub_pd($1, $2)\", o.args),\n [addsub_2x64f, @TVect, @(1).cond(e->e.t=TIVReal)], self.printf(\"_mm_addsub_pd($1, $2)\", o.args),\n [addsub_2x64f, @(1).cond(e->e.t=TIVReal), @TVect], self.printf(\"_mm_addsub_pd($1, $2)\", o.args),\n Error(\"Don't know how to unparse <o>. Unrecognized type combination\")\n ));\n\nHCOLSSEUnparser.max := (self, o, i, is) >> let(n := Length(o.args), When(\n\tIsVecT(o.t) and n >2, self.printf(\"_mm_max_$1($2, $3)\", [self.ctype_suffix(o.t, _isa(self)), o.args[1],\n\t\tApplyFunc(max, Drop(o.args, 1))]), \n\tCondPat(o, \n\t\t[max, @TVect, @TVect], self.prefix(\"_mm_max_\" :: self.ctype_suffix(o.t, _isa(self)),o.args),\n\t [max, @TVect, @(1).cond(e->e.t=TIVReal)], self.printf(\"_mm_max_pd($1, $2)\", o.args),\n [max, @(1).cond(e->e.t=TIVReal), @TVect], self.printf(\"_mm_max_pd($1, $2)\", o.args),\n\t\tInherited(o, i, is))\n));\n\nHCOLSSEUnparser.min := (self, o, i, is) >> let(\n\tCondPat(o, \n\t\t[min, @TVect, @TVect], self.prefix(\"_mm_min_\" :: self.ctype_suffix(o.t, _isa(self)),o.args),\n\t [min, @TVect, @(1).cond(e->e.t=TIVReal)], self.printf(\"_mm_min_pd($1, $2)\", o.args),\n [min, @(1).cond(e->e.t=TIVReal), @TVect], self.printf(\"_mm_min_pd($1, $2)\", o.args),\n\t\tInherited(o, i, is))\n);\n\n\ngeq.computeType := self >> TBool;\nleq.computeType := self >> TBool;\t\neq.computeType := self >> TBool;\npow.computeType := (self) >> self.args[1].t;\nneq.computeType := (self) >> TBool;\n\t\t\t\nmin.computeType := self >> let(\n\t\ttypes := List(self.args, e->e.t),\n\t\tWhen(Length(Collect(types, TIVReal))>0, \n\t\t\tTIVReal(UnifyTypes(List(Collect(types, TIVReal), i->i.t))), <# TVect(T_Real(64),2), #>\n\t\t\tUnifyTypes(List(self.args, x->x.t)))\n\t);\nmax.computeType := self >> let(\n\t\ttypes := List(self.args, e->e.t),\n\t\tWhen(Length(Collect(types, TIVReal))>0, \n\t\t\tTIVReal(UnifyTypes(List(Collect(types, TIVReal), i->i.t))), <# TVect(T_Real(64),2), #>\n\t\t\tUnifyTypes(List(self.args, x->x.t)))\n\t);\n\n\t\nVecExp.computeType := self >> let(\n t := self.args[1].t,\n deref_t := When(IsPtrT(t), t.t, t),\n el_t := Cond(IsVecT(deref_t), deref_t.t, deref_t),\n\ttest := Cond(el_t = TIVReal, el_t.t, el_t),\n TVect(test, self.v));\n\nadd.computeType := meth(self)\n\t local len, t, ptr_args, other_args, sum;\n\t len := Length(self.args);\n\t if len=0 then return TInt;\n\t elif len=1 then return self.args[1].t;\n\t else\n [ptr_args, other_args] := SplitBy(self.args, x->IsPtrT(x.t) or IsArrayT(x.t));\n if Length(ptr_args)=0 then\n\t if (self.args[1].t = TIVReal or self.args[2].t = TIVReal) then\n\t return TIVReal(T_Real(64));\n\t else\n\t return UnifyTypesL(self.args);\n fi;\n elif Length(ptr_args)=1 then\n sum := Sum(other_args);\n if other_args<>[] and not IsIntT(sum.t) then Error(\"Can't add non-integer to a pointer\"); fi;\n\t\t return self._ptrPlusOfs(ptr_args[1].t, sum);\n elif Length(other_args)=0 then\n return self._addPtrT(ptr_args);\n else\n return Error(\"Addition of more than one pointer and integers is not defined\");\n fi;\n\t fi;\n end;\n\t\nsub.computeType := meth(self)\n\t local len, t, ptr_args, other_args, sum;\n\t len := Length(self.args);\n\t if len=0 then return TInt;\n\t elif len=1 then return self.args[1].t;\n\t else\n [ptr_args, other_args] := SplitBy(self.args, x->IsPtrT(x.t) or IsArrayT(x.t));\n if Length(ptr_args)=0 then\n\t if (self.args[1].t = TIVReal or self.args[2].t = TIVReal) then\n\t return TIVReal(T_Real(64));\n\t else\n\t return UnifyTypesL(self.args);\n fi;\n elif Length(ptr_args)=1 then\n sum := Sum(other_args);\n if other_args<>[] and not IsIntT(sum.t) then Error(\"Can't add non-integer to a pointer\"); fi;\n\t\t return self._ptrPlusOfs(ptr_args[1].t, sum);\n elif Length(other_args)=0 then\n return self._addPtrT(ptr_args);\n else\n return Error(\"Addition of more than one pointer and integers is not defined\");\n fi;\n\t fi;\n end;\n\n\nmul.computeType := meth(self)\n local len, t, ptr_t, ptr_args, other_args, prod, args;\n\targs := self.args;\n\n\tlen := Length(args);\n\tif len=0 then return TInt;\n\telif len=1 then return args[1].t;\n\telse\n\t [ptr_args, other_args] := SplitBy(args, x->IsPtrT(x.t));\n\t if Length(ptr_args)=0 then\n\t if (self.args[1].t = TIVReal or self.args[2].t = TIVReal) then\n \t\t return TIVReal(T_Real(64));\n\t\telse\n\t\t return UnifyTypesL(args);\n\t\tfi;\n\t elif Length(ptr_args) > 1 then Error(\"Can't multiply pointers\");\n\t else\n\t\tprod := Product(other_args);\n\t\tif other_args<>[] and not IsIntT(prod.t) then Error(\"Can't multiply a pointer by a non-integer\"); fi;\n\t\treturn self._ptrMul(ptr_args[1].t, prod);\n\t fi;\n\tfi;\n end;\n\t\ndiv.computeType := self >> When(self.args[1].t = TIVReal or self.args[2].t = TIVReal, TIVReal(T_Real(64)), UnifyTypes(List(self.args, x->x.t)));\n\t\nTempArrayType := (child, y, x, index) ->\nlet(When(IsBound(child.a.t_in), child.a.t_in[index], \n\t\tlet( X := Flat([x])[1], Y:= Flat([y])[1],\n\t\t\tCond(\n\t\t\t\tIsBound(X.t.t) and X.t.t = TComplex, \t\tTComplex,\n\t\t\t\tIsBound(Y.t.t) and Y.t.t = TComplex, \t\tTComplex,\n\t\t\t\tObjId(child) = ISumReduction, \t\t\t\tWhen(IsRec(child.idval), child.idval.t, TReal),\n\t\t\t\tObjId(child) = PointWise, \t\t\t\t\tchild.op.expr.t,\n\t\t\t\tX.t.t))));\nTempArray := (y, x, child) -> let(cols := Flat([ Cols(child) ]),\n\tnewType := TempArrayType(child, y, x, 1),\n StripList(\n List([ 1 .. Length(cols) ], (i) -> TempVec(TArray(TempArrayType(child,\n y, x, i), cols[i])))) );\t\n\t\n\t\n\n\t\t\t\t\n", "meta": {"hexsha": "1f40dc1b010332d6b97728baa604487b14850fb7", "size": 37679, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "ivarith.gi", "max_stars_repo_name": "spiral-software/spiral-package-hcol", "max_stars_repo_head_hexsha": "b4a0118382e3bba91ecd82a6c667f2cdb6389ceb", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "ivarith.gi", "max_issues_repo_name": "spiral-software/spiral-package-hcol", "max_issues_repo_head_hexsha": "b4a0118382e3bba91ecd82a6c667f2cdb6389ceb", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ivarith.gi", "max_forks_repo_name": "spiral-software/spiral-package-hcol", "max_forks_repo_head_hexsha": "b4a0118382e3bba91ecd82a6c667f2cdb6389ceb", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-11-26T05:21:02.000Z", "max_forks_repo_forks_event_max_datetime": "2019-11-26T05:21:02.000Z", "avg_line_length": 46.5172839506, "max_line_length": 180, "alphanum_fraction": 0.5504392367, "num_tokens": 13194, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48047867804790706, "lm_q2_score": 0.02161533028098803, "lm_q1q2_score": 0.010385705318978025}}
|