{"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( ) . . . . . . . . . . . . report illegal parameter\n##\nInstallGlobalFunction( ANUPQSPerror, function( param )\n Error(\n \"Valid Options:\\n\",\n \" \\\"ClassBound\\\", \\n\",\n \" \\\"PcgsAutomorphisms\\\"\\n\",\n \" \\\"Exponent\\\", \\n\",\n \" \\\"Metabelian\\\"\\n\",\n \" \\\"OutputLevel\\\", \\n\",\n \" \\\"SetupFile\\\", \\n\",\n \"Illegal Parameter: \\\"\", param, \"\\\"\" );\nend );\n\n#############################################################################\n##\n#F ANUPQSPextractArgs( ) . . . . . . . . . . . . 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\", \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\", \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\", \n elif match( act, \"SetupFile\" ) then\n i := i + 1;\n CR.SetupFile := args[i];\n\n \t# \"TmpDir\", \n \telif match( act, \"TmpDir\" ) then\n \t i := i + 1;\n \t CR.TmpDir := args[i];\n\n # \"Output\", \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( ) . . . . . . corresponding fp group of a pc group\n##\nInstallGlobalFunction( PqFpGroupPcGroup, \n G -> Image( IsomorphismFpGroup( G ) )\n);\n\n#############################################################################\n##\n#M FpGroupPcGroup( ) . . . . . . . corresponding fp group of a pc group\n##\nInstallMethod( FpGroupPcGroup, \"pc group\", [IsPcGroup], 0, PqFpGroupPcGroup );\n\n#############################################################################\n##\n#F PQ_EPIMORPHISM_STANDARD_PRESENTATION( ) . (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 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( ) . . . 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( : ) . . . . . . . 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( ) . . . . . epi. onto SP for p-group\n#M EpimorphismStandardPresentation( [] )\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( ) . . . . . . . . . . . . . . . SP for p-group\n#M StandardPresentation( [] )\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( , ) . . . . . . . . . . . isomorphism test\n##\nInstallGlobalFunction( IsPqIsomorphicPGroup, function( G, H )\n local p, class, SG, SH, Ggens, Hgens;\n \n # and must both be pc groups and p-groups\n if not IsPcGroup(G) then\n Error( \" must be a pc group\" );\n fi;\n if not IsPcGroup(H) then\n Error( \" 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( \" 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( , )\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 = \n# v = <.>\n#\n# Types:\n# TReal \n# TComplex\n# TInt\n# TArray(, )\n# TVect(, )\n#\n# Value(, <.>)\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(, , ): data type range\n#F smallest value, largest value, 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 .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(\".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(\" 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(, ) -- fixed point data type\n#F\n#F -- total # of bits (including sign bit)\n#F -- 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(, ) -- 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(\" 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(\" 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(\" 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(\" 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(\" 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(\" 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__(, ) - array type of elements of \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(, ) - array type of elements of \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 \"));\n\n# IsArrayT() - checks whether is an array type object\nIsArrayT := x -> IsType(x) and IsBound(x.isArrayT) and x.isArrayT;\n\n# IsListT() - checks whether is a list type object\nIsListT := x -> IsType(x) and IsBound(x.isListT) and x.isListT;\n\n# IsVecT() - checks whether is an vector type object\nIsVecT := x -> IsType(x) and IsBound(x.isVecT) and x.isVecT;\n\n# IsPtrT() - checks whether is a pointer type object\nIsPtrT := x-> IsType(x) and IsBound(x.isPtrT) and x.isPtrT;\n\n# IsUnalignedPtrT() - checks whether 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 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 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(\" 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\", [, , ... , ])\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 := () -> [\"\"] :: _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 := () -> [\"\"],\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()\n##\nInstallMethod(SelfSimilarGroup, \"for [IsList]\", [IsList],\nfunction(list)\n return SelfSimilarGroup(list, false);\nend);\n\n\n###############################################################################\n##\n#M SelfSimilarGroup(, )\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(, )\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(, , )\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()\n#M SelfSimilarGroup(, )\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()\n#M SelfSimilarGroup(, )\n##\nInstallMethod(SelfSimilarGroup, \"for [IsMealyAutomaton]\", [IsMealyAutomaton],\nfunction(A)\n if not IsInvertible(A) then\n Error(\"Automaton 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 is not invertible\");\n fi;\n return SelfSimilarGroup(AutomatonList(A), A!.states, bind_vars);\nend);\n\n\n\n###############################################################################\n##\n#M GroupOfSelfSimFamily()\n##\nInstallMethod(GroupOfSelfSimFamily, \"for [IsSelfSimGroup]\",\n [IsSelfSimGroup],\nfunction(G)\n return GroupOfSelfSimFamily(UnderlyingSelfSimFamily(G));\nend);\n\n\n###############################################################################\n##\n#M IsGroupOfSelfSimFamily()\n##\nInstallMethod(IsGroupOfSelfSimFamily, \"for [IsSelfSimGroup]\",\n [IsSelfSimGroup],\nfunction(G)\n return G = GroupOfSelfSimFamily(G);\nend);\n\n\n###############################################################################\n##\n#M UseSubsetRelation()\n##\nInstallMethod(UseSubsetRelation,\n \"for [IsSelfSimGroup, IsSelfSimGroup]\",\n [IsSelfSimGroup, IsSelfSimGroup],\nfunction(super, sub)\n ## the full group is self similar, so if 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(, , )\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()\n##\nInstallMethod(PrintObj, \"for [IsSelfSimilarGroup]\",\n [IsSelfSimilarGroup],\nfunction(G)\n Print(\"SelfSimilarGroup(\\\"\", String(G), \"\\\")\");\nend);\n\n\n###############################################################################\n##\n#M Display()\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()\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()\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() or\\n\",\n \" FindElementOfInfiniteOrder( , , ) 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)\n#O IsomorphismPermGroup (, )\n##\n## For a given finite group generated by initial automata or by elements defined by\n## wreath recursion\n## computes an isomorphism from into a finite permutational group.\n## If is not known to be self-similar (see \"IsSelfSimilar\") the isomorphism is based on the\n## regular representation, which works generally much slower. If is self-similar\n## there is a level of the tree (see \"LevelOfFaithfulAction\"), where acts faithfully.\n## The corresponding representation is returned in this case. If is given\n## it finds only the first quotients by stabilizers and if all of them have\n## different size it returns `fail'.\n## If is infinite and 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, \" 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(, )\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(, )\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 \\= (, )\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 (, )\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 in \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()\n##\n## Returns a random element of a group (semigroup) . 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()\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()\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()\n##\nInstallMethod(TrivialSubmagmaWithOne, \"for [IsSelfSimGroup]\",\n [IsSelfSimGroup],\nfunction(G)\n return Subgroup(G, [One(G)]);\nend);\n\n\n###############################################################################\n##\n#M IsSelfSimilarGroup()\n##\n## Returns `true' if generators of 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()\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 is not necessarily self-similar\");\n fi;\nend);\n\n\n###############################################################################\n##\n#M IsSelfSimilar()\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()\n##\nInstallMethod(UnderlyingSelfSimFamily, \"for [IsSelfSimGroup]\",\n [IsSelfSimGroup],\nfunction(G)\n return FamilyObj(GeneratorsOfGroup(G)[1]);\nend);\n\n\n###############################################################################\n##\n#M IsFiniteState()\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( )\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( )\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( )\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( )\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( )\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 is not finite-state\");\n fi;\n\n if not IsContracting(G) then\n Error(\"Group 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( )\n##\nInstallMethod(UseContraction, \"for [IsSelfSimGroup]\", true,\n [IsSelfSimGroup],\nfunction(G)\n if not IsSelfSimilarGroup(G) then\n Print(\"Error in UseContraction(): 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(): It is not known whether the group is contracting\\n\");\n return fail;\n elif not IsContracting(G) then\n Print(\"Error in UseContraction(): The group 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( )\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( )\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 is not finite-state\");\n fi;\n\n if HasIsContracting(G) and not IsContracting(G) then\n Error(\"Group 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 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(\" 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(, , , ) - and and temp arrays propagation through \n # identity/inplace operators and creating intermediate arrays using which\n # has (c) -> ... signature ( is child operator). There is no assumption made on what is , \n # and 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(, , ) - type conversion on 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() - 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()\n#F RecursStep(, , ) - 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(\" 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(\" 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() - 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() - 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() - 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(, , ) - introduces a data constant bound in \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(\" 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() - gather (read) matrix\n#F NOTE: implements affine transformations via funcExp hack.\n\n#F as of Dec '2010, 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(\" 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() - permutation, semantically same as Gath(), 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() - 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(, )\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(, , ...) - 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(, , ...) - 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(, , ) - 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(, , ) - 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(\" must be in [1..3]\");\n# fi;\n# end\n));\n\n\n# ==========================================================================\n# ISumAcc(, , ) - overlapping iterative matrix sum\n# ==========================================================================\nClass(ISumAcc, ISum);\n\n# ==========================================================================\n# IParSeq(, , , ) \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( , ) . check opts belong to f'n\n##\n## checks the `OptionsStack' only has recognised options for (generic)\n## function and if not and if `ANUPQWarnOfOtherOptions = true'\n## (see~\"ANUPQWarnOfOtherOptions\") `Info's the non- options at\n## `InfoANUPQ' level 1.\n##\n## The argument 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( ) . . . . . . . . . enhancement of ValueOption\n#F VALUE_PQ_OPTION( , ) \n#F VALUE_PQ_OPTION( , ) \n#F VALUE_PQ_OPTION( , , ) \n##\n## If the value of is not `fail' and it is an ok value\n## for then is returned; if is not an ok value\n## an error is signalled. If is `fail' and is given and\n## .() is already bound then that value is returned;\n## otherwise, if is `fail' and a default value \n## different from `fail' is supplied then is returned.\n## Supplying a of `fail' is special; it indicates that option\n## must have a value i.e. is not allowed to be `fail' and\n## if it is an error is signalled. If a 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 `.(