passagemath-gap-pkg-normalizinterface 10.6.32__cp310-cp310-musllinux_1_2_aarch64.whl

gap/pkg/normalizinterface/lib/cone_property_wrappers.gi

@@ -0,0 +1,132 @@
+# WARNING: This file was generated by etc/generate_cone_property_wrappers.g,
+# DO NOT EDIT IT BY HAND!
+
+InstallGlobalFunction( NmzAffineDim, cone -> NmzConeProperty( cone, "AffineDim" ) );
+InstallGlobalFunction( NmzAllGeneratorsTriangulation, cone -> NmzConeProperty( cone, "AllGeneratorsTriangulation" ) );
+InstallGlobalFunction( NmzAmbientAutomorphisms, cone -> NmzConeProperty( cone, "AmbientAutomorphisms" ) );
+InstallGlobalFunction( NmzApproximate, cone -> NmzConeProperty( cone, "Approximate" ) );
+InstallGlobalFunction( NmzAutomorphisms, cone -> NmzConeProperty( cone, "Automorphisms" ) );
+InstallGlobalFunction( NmzAxesScaling, cone -> NmzConeProperty( cone, "AxesScaling" ) );
+InstallGlobalFunction( NmzBasicStanleyDec, cone -> NmzConeProperty( cone, "BasicStanleyDec" ) );
+InstallGlobalFunction( NmzBasicTriangulation, cone -> NmzConeProperty( cone, "BasicTriangulation" ) );
+InstallGlobalFunction( NmzBigInt, cone -> NmzConeProperty( cone, "BigInt" ) );
+InstallGlobalFunction( NmzBottomDecomposition, cone -> NmzConeProperty( cone, "BottomDecomposition" ) );
+InstallGlobalFunction( NmzClassGroup, cone -> NmzConeProperty( cone, "ClassGroup" ) );
+InstallGlobalFunction( NmzCombinatorialAutomorphisms, cone -> NmzConeProperty( cone, "CombinatorialAutomorphisms" ) );
+InstallGlobalFunction( NmzConeDecomposition, cone -> NmzConeProperty( cone, "ConeDecomposition" ) );
+InstallGlobalFunction( NmzCongruences, cone -> NmzConeProperty( cone, "Congruences" ) );
+InstallGlobalFunction( NmzCoveringFace, cone -> NmzConeProperty( cone, "CoveringFace" ) );
+InstallGlobalFunction( NmzDefaultMode, cone -> NmzConeProperty( cone, "DefaultMode" ) );
+InstallGlobalFunction( NmzDeg1Elements, cone -> NmzConeProperty( cone, "Deg1Elements" ) );
+InstallGlobalFunction( NmzDehomogenization, cone -> NmzConeProperty( cone, "Dehomogenization" ) );
+InstallGlobalFunction( NmzDescent, cone -> NmzConeProperty( cone, "Descent" ) );
+InstallGlobalFunction( NmzDistributedComp, cone -> NmzConeProperty( cone, "DistributedComp" ) );
+InstallGlobalFunction( NmzDualFVector, cone -> NmzConeProperty( cone, "DualFVector" ) );
+InstallGlobalFunction( NmzDualFaceLattice, cone -> NmzConeProperty( cone, "DualFaceLattice" ) );
+InstallGlobalFunction( NmzDualIncidence, cone -> NmzConeProperty( cone, "DualIncidence" ) );
+InstallGlobalFunction( NmzDualMode, cone -> NmzConeProperty( cone, "DualMode" ) );
+InstallGlobalFunction( NmzDynamic, cone -> NmzConeProperty( cone, "Dynamic" ) );
+InstallGlobalFunction( NmzEhrhartQuasiPolynomial, cone -> NmzConeProperty( cone, "EhrhartQuasiPolynomial" ) );
+InstallGlobalFunction( NmzEhrhartSeries, cone -> NmzConeProperty( cone, "EhrhartSeries" ) );
+InstallGlobalFunction( NmzEmbeddingDimension, cone -> NmzConeProperty( cone, "EmbeddingDim" ) );
+InstallGlobalFunction( NmzEquations, cone -> NmzConeProperty( cone, "Equations" ) );
+InstallGlobalFunction( NmzEuclideanAutomorphisms, cone -> NmzConeProperty( cone, "EuclideanAutomorphisms" ) );
+InstallGlobalFunction( NmzEuclideanIntegral, cone -> NmzConeProperty( cone, "EuclideanIntegral" ) );
+InstallGlobalFunction( NmzEuclideanVolume, cone -> NmzConeProperty( cone, "EuclideanVolume" ) );
+InstallGlobalFunction( NmzExcludedFaces, cone -> NmzConeProperty( cone, "ExcludedFaces" ) );
+InstallGlobalFunction( NmzExploitAutomsVectors, cone -> NmzConeProperty( cone, "ExploitAutomsVectors" ) );
+InstallGlobalFunction( NmzExploitIsosMult, cone -> NmzConeProperty( cone, "ExploitIsosMult" ) );
+InstallGlobalFunction( NmzExternalIndex, cone -> NmzConeProperty( cone, "ExternalIndex" ) );
+InstallGlobalFunction( NmzExtremeRays, cone -> NmzConeProperty( cone, "ExtremeRays" ) );
+InstallGlobalFunction( NmzExtremeRaysFloat, cone -> NmzConeProperty( cone, "ExtremeRaysFloat" ) );
+InstallGlobalFunction( NmzFVector, cone -> NmzConeProperty( cone, "FVector" ) );
+InstallGlobalFunction( NmzFaceLattice, cone -> NmzConeProperty( cone, "FaceLattice" ) );
+InstallGlobalFunction( NmzFixedPrecision, cone -> NmzConeProperty( cone, "FixedPrecision" ) );
+InstallGlobalFunction( NmzFullConeDynamic, cone -> NmzConeProperty( cone, "FullConeDynamic" ) );
+InstallGlobalFunction( NmzGeneratorOfInterior, cone -> NmzConeProperty( cone, "GeneratorOfInterior" ) );
+InstallGlobalFunction( NmzGenerators, cone -> NmzConeProperty( cone, "Generators" ) );
+InstallGlobalFunction( NmzGrading, cone -> NmzConeProperty( cone, "Grading" ) );
+InstallGlobalFunction( NmzGradingDenom, cone -> NmzConeProperty( cone, "GradingDenom" ) );
+InstallGlobalFunction( NmzGradingIsPositive, cone -> NmzConeProperty( cone, "GradingIsPositive" ) );
+InstallGlobalFunction( NmzHSOP, cone -> NmzConeProperty( cone, "HSOP" ) );
+InstallGlobalFunction( NmzHilbertBasis, cone -> NmzConeProperty( cone, "HilbertBasis" ) );
+InstallGlobalFunction( NmzHilbertQuasiPolynomial, cone -> NmzConeProperty( cone, "HilbertQuasiPolynomial" ) );
+InstallGlobalFunction( NmzHilbertSeries, cone -> NmzConeProperty( cone, "HilbertSeries" ) );
+InstallGlobalFunction( NmzIncidence, cone -> NmzConeProperty( cone, "Incidence" ) );
+InstallGlobalFunction( NmzInclusionExclusionData, cone -> NmzConeProperty( cone, "InclusionExclusionData" ) );
+InstallGlobalFunction( NmzInputAutomorphisms, cone -> NmzConeProperty( cone, "InputAutomorphisms" ) );
+InstallGlobalFunction( NmzIntegerHull, cone -> NmzConeProperty( cone, "IntegerHull" ) );
+InstallGlobalFunction( NmzIntegral, cone -> NmzConeProperty( cone, "Integral" ) );
+InstallGlobalFunction( NmzInternalIndex, cone -> NmzConeProperty( cone, "InternalIndex" ) );
+InstallGlobalFunction( NmzIsDeg1ExtremeRays, cone -> NmzConeProperty( cone, "IsDeg1ExtremeRays" ) );
+InstallGlobalFunction( NmzIsDeg1HilbertBasis, cone -> NmzConeProperty( cone, "IsDeg1HilbertBasis" ) );
+InstallGlobalFunction( NmzIsEmptySemiOpen, cone -> NmzConeProperty( cone, "IsEmptySemiOpen" ) );
+InstallGlobalFunction( NmzIsGorenstein, cone -> NmzConeProperty( cone, "IsGorenstein" ) );
+InstallGlobalFunction( NmzIsInhomogeneous, cone -> NmzConeProperty( cone, "IsInhomogeneous" ) );
+InstallGlobalFunction( NmzIsIntegrallyClosed, cone -> NmzConeProperty( cone, "IsIntegrallyClosed" ) );
+InstallGlobalFunction( NmzIsPointed, cone -> NmzConeProperty( cone, "IsPointed" ) );
+InstallGlobalFunction( NmzIsReesPrimary, cone -> NmzConeProperty( cone, "IsReesPrimary" ) );
+InstallGlobalFunction( NmzIsTriangulationNested, cone -> NmzConeProperty( cone, "IsTriangulationNested" ) );
+InstallGlobalFunction( NmzIsTriangulationPartial, cone -> NmzConeProperty( cone, "IsTriangulationPartial" ) );
+InstallGlobalFunction( NmzKeepOrder, cone -> NmzConeProperty( cone, "KeepOrder" ) );
+InstallGlobalFunction( NmzLatticePointTriangulation, cone -> NmzConeProperty( cone, "LatticePointTriangulation" ) );
+InstallGlobalFunction( NmzLatticePoints, cone -> NmzConeProperty( cone, "LatticePoints" ) );
+InstallGlobalFunction( NmzMaximalSubspace, cone -> NmzConeProperty( cone, "MaximalSubspace" ) );
+InstallGlobalFunction( NmzModuleGenerators, cone -> NmzConeProperty( cone, "ModuleGenerators" ) );
+InstallGlobalFunction( NmzModuleGeneratorsOverOriginalMonoid, cone -> NmzConeProperty( cone, "ModuleGeneratorsOverOriginalMonoid" ) );
+InstallGlobalFunction( NmzModuleRank, cone -> NmzConeProperty( cone, "ModuleRank" ) );
+InstallGlobalFunction( NmzMultiplicity, cone -> NmzConeProperty( cone, "Multiplicity" ) );
+InstallGlobalFunction( NmzNoBottomDec, cone -> NmzConeProperty( cone, "NoBottomDec" ) );
+InstallGlobalFunction( NmzNoDescent, cone -> NmzConeProperty( cone, "NoDescent" ) );
+InstallGlobalFunction( NmzNoGradingDenom, cone -> NmzConeProperty( cone, "NoGradingDenom" ) );
+InstallGlobalFunction( NmzNoLLL, cone -> NmzConeProperty( cone, "NoLLL" ) );
+InstallGlobalFunction( NmzNoNestedTri, cone -> NmzConeProperty( cone, "NoNestedTri" ) );
+InstallGlobalFunction( NmzNoPeriodBound, cone -> NmzConeProperty( cone, "NoPeriodBound" ) );
+InstallGlobalFunction( NmzNoProjection, cone -> NmzConeProperty( cone, "NoProjection" ) );
+InstallGlobalFunction( NmzNoRelax, cone -> NmzConeProperty( cone, "NoRelax" ) );
+InstallGlobalFunction( NmzNoSignedDec, cone -> NmzConeProperty( cone, "NoSignedDec" ) );
+InstallGlobalFunction( NmzNoSubdivision, cone -> NmzConeProperty( cone, "NoSubdivision" ) );
+InstallGlobalFunction( NmzNoSymmetrization, cone -> NmzConeProperty( cone, "NoSymmetrization" ) );
+InstallGlobalFunction( NmzNumberLatticePoints, cone -> NmzConeProperty( cone, "NumberLatticePoints" ) );
+InstallGlobalFunction( NmzOriginalMonoidGenerators, cone -> NmzConeProperty( cone, "OriginalMonoidGenerators" ) );
+InstallGlobalFunction( NmzPlacingTriangulation, cone -> NmzConeProperty( cone, "PlacingTriangulation" ) );
+InstallGlobalFunction( NmzPrimalMode, cone -> NmzConeProperty( cone, "PrimalMode" ) );
+InstallGlobalFunction( NmzProjectCone, cone -> NmzConeProperty( cone, "ProjectCone" ) );
+InstallGlobalFunction( NmzProjection, cone -> NmzConeProperty( cone, "Projection" ) );
+InstallGlobalFunction( NmzProjectionFloat, cone -> NmzConeProperty( cone, "ProjectionFloat" ) );
+InstallGlobalFunction( NmzPullingTriangulation, cone -> NmzConeProperty( cone, "PullingTriangulation" ) );
+InstallGlobalFunction( NmzPullingTriangulationInternal, cone -> NmzConeProperty( cone, "PullingTriangulationInternal" ) );
+InstallGlobalFunction( NmzRank, cone -> NmzConeProperty( cone, "Rank" ) );
+InstallGlobalFunction( NmzRationalAutomorphisms, cone -> NmzConeProperty( cone, "RationalAutomorphisms" ) );
+InstallGlobalFunction( NmzRecessionRank, cone -> NmzConeProperty( cone, "RecessionRank" ) );
+InstallGlobalFunction( NmzReesPrimaryMultiplicity, cone -> NmzConeProperty( cone, "ReesPrimaryMultiplicity" ) );
+InstallGlobalFunction( NmzRenfVolume, cone -> NmzConeProperty( cone, "RenfVolume" ) );
+InstallGlobalFunction( NmzSignedDec, cone -> NmzConeProperty( cone, "SignedDec" ) );
+InstallGlobalFunction( NmzStanleyDec, cone -> NmzConeProperty( cone, "StanleyDec" ) );
+InstallGlobalFunction( NmzStatic, cone -> NmzConeProperty( cone, "Static" ) );
+InstallGlobalFunction( NmzStrictIsoTypeCheck, cone -> NmzConeProperty( cone, "StrictIsoTypeCheck" ) );
+InstallGlobalFunction( NmzSublattice, cone -> NmzConeProperty( cone, "Sublattice" ) );
+InstallGlobalFunction( NmzSuppHypsFloat, cone -> NmzConeProperty( cone, "SuppHypsFloat" ) );
+InstallGlobalFunction( NmzSupportHyperplanes, cone -> NmzConeProperty( cone, "SupportHyperplanes" ) );
+InstallGlobalFunction( NmzSymmetrize, cone -> NmzConeProperty( cone, "Symmetrize" ) );
+InstallGlobalFunction( NmzTestArithOverflowDescent, cone -> NmzConeProperty( cone, "TestArithOverflowDescent" ) );
+InstallGlobalFunction( NmzTestArithOverflowDualMode, cone -> NmzConeProperty( cone, "TestArithOverflowDualMode" ) );
+InstallGlobalFunction( NmzTestArithOverflowFullCone, cone -> NmzConeProperty( cone, "TestArithOverflowFullCone" ) );
+InstallGlobalFunction( NmzTestArithOverflowProjAndLift, cone -> NmzConeProperty( cone, "TestArithOverflowProjAndLift" ) );
+InstallGlobalFunction( NmzTestLargePyramids, cone -> NmzConeProperty( cone, "TestLargePyramids" ) );
+InstallGlobalFunction( NmzTestLibNormaliz, cone -> NmzConeProperty( cone, "TestLibNormaliz" ) );
+InstallGlobalFunction( NmzTestLinearAlgebraGMP, cone -> NmzConeProperty( cone, "TestLinearAlgebraGMP" ) );
+InstallGlobalFunction( NmzTestSimplexParallel, cone -> NmzConeProperty( cone, "TestSimplexParallel" ) );
+InstallGlobalFunction( NmzTestSmallPyramids, cone -> NmzConeProperty( cone, "TestSmallPyramids" ) );
+InstallGlobalFunction( NmzTriangulation, cone -> NmzConeProperty( cone, "Triangulation" ) );
+InstallGlobalFunction( NmzTriangulationDetSum, cone -> NmzConeProperty( cone, "TriangulationDetSum" ) );
+InstallGlobalFunction( NmzTriangulationSize, cone -> NmzConeProperty( cone, "TriangulationSize" ) );
+InstallGlobalFunction( NmzUnimodularTriangulation, cone -> NmzConeProperty( cone, "UnimodularTriangulation" ) );
+InstallGlobalFunction( NmzUnitGroupIndex, cone -> NmzConeProperty( cone, "UnitGroupIndex" ) );
+InstallGlobalFunction( NmzVerticesFloat, cone -> NmzConeProperty( cone, "VerticesFloat" ) );
+InstallGlobalFunction( NmzVerticesOfPolyhedron, cone -> NmzConeProperty( cone, "VerticesOfPolyhedron" ) );
+InstallGlobalFunction( NmzVirtualMultiplicity, cone -> NmzConeProperty( cone, "VirtualMultiplicity" ) );
+InstallGlobalFunction( NmzVolume, cone -> NmzConeProperty( cone, "Volume" ) );
+InstallGlobalFunction( NmzWeightedEhrhartQuasiPolynomial, cone -> NmzConeProperty( cone, "WeightedEhrhartQuasiPolynomial" ) );
+InstallGlobalFunction( NmzWeightedEhrhartSeries, cone -> NmzConeProperty( cone, "WeightedEhrhartSeries" ) );
+InstallGlobalFunction( NmzWitnessNotIntegrallyClosed, cone -> NmzConeProperty( cone, "WitnessNotIntegrallyClosed" ) );

gap/pkg/normalizinterface/lib/normaliz.gd

@@ -0,0 +1,130 @@
+#! @Chapter Functions
+#! @Section YOU FORGOT TO SET A SECTION
+
+NormalizObjectFamily := NewFamily( "NormalizObjectFamily" );
+
+DeclareCategory( "IsNormalizCone", IsObject );
+
+BindGlobal("TheTypeNormalizCone", NewType( NormalizObjectFamily, IsNormalizCone ));
+
+
+#
+#! @Section Use a NmzCone
+#
+
+#! @Section Use a NmzCone
+#! @Arguments cone[, propnames]
+#! @Returns a boolean indicating success
+#! @Description
+#! Start computing properties of the given cone.
+#! The first parameter indicates a cone object, the second parameter
+#! is either a single string, or a list of strings, which indicate
+#! what should be computed.
+#! <P/>
+#!
+#! The single parameter version is equivalent to
+#! <C>NmzCone(cone, ["DefaultMode"])</C>.
+#! See <Ref Func="NmzConeProperty"/> for a list of recognized properties.
+#! @InsertChunk NmzCompute_example
+DeclareGlobalFunction( "NmzCompute" );
+
+#! @Arguments cone, property
+#! @Returns the result of the computation, type depends on the property
+#! @Description
+#! Triggers the computation of the property of the cone and returns the result.
+#! If the property was already known, it is not recomputed.
+#! Currently the following strings are recognized as properties:
+#! <List>
+#! <Item><C>Generators</C> see <Ref Func="NmzGenerators"/>,</Item>
+#! <Item><C>ExtremeRays</C> see <Ref Func="NmzExtremeRays"/>,</Item>
+#! <Item><C>VerticesOfPolyhedron</C> see <Ref Func="NmzVerticesOfPolyhedron"/>,</Item>
+#! <Item><C>SupportHyperplanes</C> see <Ref Func="NmzSupportHyperplanes"/>,</Item>
+#! <Item><C>TriangulationSize</C> see <Ref Func="NmzTriangulationSize"/>,</Item>
+#! <Item><C>TriangulationDetSum</C> see <Ref Func="NmzTriangulationDetSum"/>,</Item>
+#! <Item><C>Triangulation</C> see <Ref Func="NmzTriangulation"/>,</Item>
+#! <Item><C>Multiplicity</C> see <Ref Func="NmzMultiplicity"/>,</Item>
+#! <Item><C>RecessionRank</C> see <Ref Func="NmzRecessionRank"/>,</Item>
+#! <Item><C>AffineDim</C> see <Ref Func="NmzAffineDim"/>,</Item>
+#! <Item><C>ModuleRank</C> see <Ref Func="NmzModuleRank"/>,</Item>
+#! <Item><C>HilbertBasis</C> see <Ref Func="NmzHilbertBasis"/>,</Item>
+#! <Item><C>ModuleGenerators</C> see <Ref Func="NmzModuleGenerators"/>,</Item>
+#! <Item><C>Deg1Elements</C> see <Ref Func="NmzDeg1Elements"/>,</Item>
+#! <Item><C>HilbertSeries</C> see <Ref Func="NmzHilbertSeries"/>,</Item>
+#! <Item><C>HilbertQuasiPolynomial</C> see <Ref Func="NmzHilbertQuasiPolynomial"/>,</Item>
+#! <Item><C>Grading</C> see <Ref Func="NmzGrading"/>,</Item>
+#! <Item><C>IsPointed</C> see <Ref Func="NmzIsPointed"/>,</Item>
+#! <Item><C>IsDeg1ExtremeRays</C> see <Ref Func="NmzIsDeg1ExtremeRays"/>,</Item>
+#! <Item><C>IsDeg1HilbertBasis</C> see <Ref Func="NmzIsDeg1HilbertBasis"/>,</Item>
+#! <Item><C>IsIntegrallyClosed</C> see <Ref Func="NmzIsIntegrallyClosed"/>,</Item>
+#! <Item><C>OriginalMonoidGenerators</C> see <Ref Func="NmzOriginalMonoidGenerators"/>,</Item>
+#! <Item><C>IsReesPrimary</C> see <Ref Func="NmzIsReesPrimary"/>,</Item>
+#! <Item><C>ReesPrimaryMultiplicity</C> see <Ref Func="NmzReesPrimaryMultiplicity"/>,</Item>
+#! <Item><C>ExcludedFaces</C> see <Ref Func="NmzExcludedFaces"/>,</Item>
+#! <Item><C>Dehomogenization</C> see <Ref Func="NmzDehomogenization"/>,</Item>
+#! <Item><C>InclusionExclusionData</C> see <Ref Func="NmzInclusionExclusionData"/>,</Item>
+#! <Item><C>ClassGroup</C> see <Ref Func="NmzClassGroup"/>,</Item>
+#! <Item><C>ModuleGeneratorsOverOriginalMonoid</C> see <Ref Func="NmzModuleGeneratorsOverOriginalMonoid"/>,</Item>
+#! <Item><C>Sublattice</C> computes the efficient sublattice and returns a bool signaling
+#! whether the computation was successful. Actual data connected to
+#! it can be accessed by <Ref Func="NmzRank"/>, <Ref Func="NmzEquations"/>,
+#! <Ref Func="NmzCongruences"/>, and <Ref Func="NmzBasisChange"/>.</Item>
+#! </List>
+#!
+#! Additionally also the following compute options are accepted as property. They modify what and how should be computed, and return True after a successful computation.
+#! <List>
+#! <Item><C>Approximate</C> approximate the rational polytope by an integral polytope, currently only useful in combination with <C>Deg1Elements</C>.</Item>
+#! <Item><C>BottomDecomposition</C> use the best possible triangulation (with respect to the sum of determinants) using the given generators.</Item>
+#! <Item><C>DefaultMode</C> try to compute what is possible and do not throw an exception when something cannot be computed.</Item>
+#! <Item><C>DualMode</C>activates the dual algorithm for the computation of the Hilbert basis and degree
+#! 1 elements. Includes <C>HilbertBasis</C>, unless <C>Deg1Elements</C> is set. Often a good choice if you start from constraints.</Item>
+#! <Item><C>KeepOrder</C> forbids to reorder the generators. Blocks <C>BottomDecomposition</C>.</Item>
+#! </List>
+#!
+#! All the properties above can be given to <Ref Func="NmzCompute"/>. There you can
+#! combine different properties, e.g. give some properties that you would like to know and add some compute options.
+#! <P/>
+#! See the Normaliz manual for a detailed description.
+#!
+DeclareGlobalFunction( "NmzConeProperty" );
+
+#! @Arguments cone
+#! @Description
+#! Print an overview of all known properties of the given cone,
+#! as well as their values.
+DeclareGlobalFunction( "NmzPrintConeProperties" );
+
+#
+#! @Section Cone properties
+#
+
+#! @Arguments cone
+#! @Returns a record describing the basis change
+#! @Description
+#! The result record <C>r</C> has three components:
+#! <C>r.Embedding</C>, <C>r.Projection</C>, and <C>r.Annihilator</C>,
+#! where the embedding <C>A</C> and the projection <C>B</C>
+#! are matrices, and the annihilator <C>c</C> is an integer.
+#! They represent the mapping into the effective lattice
+#! <M>\mathbb{Z}^n \to \mathbb{Z}^r, u \mapsto (uB)/c</M>
+#! and the inverse operation
+#! <M>\mathbb{Z}^r \to \mathbb{Z}^n, v \mapsto vA</M>.
+#! <P/>
+#! This is part of the cone property <Q>Sublattice</Q>.
+DeclareGlobalFunction( "NmzBasisChange" );
+
+
+#! @Section Create a NmzCone
+#! @Arguments list
+#! @Returns NmzCone
+#! @Description
+#! Creates a NmzCone. The <A>list</A> argument should contain an even number of
+#! elements, alternating between a string and a integer matrix. The string has to
+#! correspond to a Normaliz input type string and the following matrix will be
+#! interpreted as input of that type.
+#!
+#! See the Normaliz manual for the Normaliz version loaded by your version
+#! of NormalizInterface for a detailed description of which input type strings
+#! are supported and what arguments they take.
+#!
+#! @InsertChunk NmzCone_example
+DeclareGlobalFunction( "NmzCone" );

gap/pkg/normalizinterface/lib/normaliz.gi

@@ -0,0 +1,153 @@
+##
+InstallMethod( ViewString,
+               "for a Normaliz cone",
+               [ IsNormalizCone ],
+function( r )
+    # TODO: May print more information when present
+    return "<a Normaliz cone>";
+end );
+
+BindGlobal("_NmzRecordOfConeProperties", _NmzConePropertiesNamesRecord());
+
+InstallGlobalFunction("NmzConeProperty",
+function(cone, prop)
+    local result, t, poly, tmp, denom;
+    result := _NmzConeProperty(cone, prop);
+    if prop = _NmzRecordOfConeProperties.Grading or prop = "Grading" then
+        denom := NmzConeProperty(cone, _NmzRecordOfConeProperties.GradingDenom);;
+        return result / denom;
+    fi;
+    if prop = _NmzRecordOfConeProperties.HilbertSeries or prop = "HilbertSeries" then
+        t := Indeterminate(Integers, "t");
+        poly := UnivariatePolynomial(Integers, result[1], t);
+        poly := poly * t^result[3];
+        tmp := Collected(result[2]);
+        return [poly, tmp];
+    fi;
+    if prop = _NmzRecordOfConeProperties.HilbertQuasiPolynomial or prop = "HilbertQuasiPolynomial" then
+        t := Indeterminate(Rationals, "t");
+        denom := Remove(result);
+        poly := List(result, coeffs -> UnivariatePolynomial(Rationals, coeffs, t));
+        return poly / denom;
+    fi;
+    return result;
+end);
+
+InstallGlobalFunction("NmzPrintConeProperties",
+function(cone)
+    local prop, val;
+    if not IsNormalizCone(cone) then
+        Error("First argument must be a Normaliz cone object");
+        return;
+    fi;
+    for prop in NmzKnownConeProperties(cone) do
+        val := NmzConeProperty(cone, prop);
+        Print(prop," = ");
+        if IsMatrix(val) then
+            Print("\n");
+        fi;
+        Display(val);
+    od;
+end);
+
+BindGlobal("_NmzPrintSomeConeProperties",
+function(cone, excluded)
+    local prop, val;
+    if not IsNormalizCone(cone) then
+        Error("First argument must be a Normaliz cone object");
+        return;
+    fi;
+    excluded := Union(excluded, [ "ExplicitHilbertSeries", "Triangulation" ]);
+    # iterate over properties in alphabetical order, to reduce
+    # fluctuations between Normaliz versions
+    for prop in NmzKnownConeProperties(cone) do
+        if prop in excluded then
+            continue;
+        fi;
+        val := NmzConeProperty(cone, prop);
+        Print(prop," = ");
+        if IsMatrix(val) then
+            Print("\n");
+        fi;
+        Display(val);
+    od;
+end);
+
+InstallGlobalFunction("NmzBasisChange",
+function(cone)
+    local result;
+    result := NmzConeProperty( cone, "Sublattice" );
+    return rec(
+        Embedding := result[1],
+        Projection := result[2],
+        Annihilator := result[3],
+        );
+end);
+
+
+#
+#
+#
+InstallGlobalFunction("NmzCone",
+function(arg)
+    local func, opts_rec, opts_list, cone;
+    if Length(arg) = 1 then
+        if IsList(arg[1]) then
+            opts_list := arg[1];
+        elif IsRecord(arg[1]) then
+            opts_list := [];
+            for opts_rec in RecNames(arg[1]) do
+              Add(opts_list, opts_rec);
+              Add(opts_list, arg[1].(opts_rec));
+            od;
+        else
+            # TODO: better error message
+            Error("Unsupported input");
+        fi;
+    else
+        opts_list := arg;
+    fi;
+
+    cone := _NmzCone(opts_list);
+    return cone;
+end);
+
+# TODO: extend NmzCone to allow this syntax:
+##cone := NmzCone(rec(integral_closure := M, grading := [ 0, 0, 1 ]));;
+
+
+
+#
+#
+#
+InstallGlobalFunction("NmzCompute",
+function(arg)
+    local cone, propsToCompute;
+    if not Length(arg) in [1,2] then
+        Error("Wrong number of arguments, expected 1 or 2");
+        return fail;
+    fi;
+    cone := arg[1];
+    if not IsNormalizCone(cone) then
+        Error("First argument must be a Normaliz cone object");
+        return fail;
+    fi;
+    if Length(arg) = 1 then
+        propsToCompute := [];
+        if ValueOption("dual") = true then Add(propsToCompute, "DualMode"); fi;
+        if ValueOption("DualMode") = true then Add(propsToCompute, "DualMode"); fi;
+        if ValueOption("HilbertBasis") = true then Add(propsToCompute, "HilbertBasis"); fi;
+        # TODO: add more option names? or just support arbitrary ones, by using
+        # iterating over the (undocumented!) OptionsStack???
+        if Length(propsToCompute) = 0 then
+            propsToCompute := [ "DefaultMode" ];
+        fi;
+    else
+        if IsString(arg[2]) then
+            propsToCompute := [arg[2]];
+        else
+            propsToCompute := arg[2];
+        fi;
+    fi;
+    return _NmzCompute(cone, propsToCompute);
+end);

gap/pkg/normalizinterface/makedoc.g

@@ -0,0 +1,13 @@
+#
+# Generate the manual using AutoDoc
+#
+if fail = LoadPackage("AutoDoc", ">= 2019.04.10") then
+    Error("AutoDoc 2019.04.10 or newer is required");
+fi;
+
+AutoDoc(rec(
+    extract_examples := true,
+    scaffold := rec( bib := "NormalizInterface-bib.xml" ),
+    autodoc := rec( files := [ "doc/intro.autodoc", "src/normaliz.cc" ] ),
+));
+QUIT;

gap/pkg/normalizinterface/read.g

@@ -0,0 +1,3 @@
+ReadPackage("NormalizInterface", "lib/normaliz.gi");
+
+ReadPackage("NormalizInterface", "lib/cone_property_wrappers.gi" );

gap/pkg/normalizinterface/tst/InhomIneq.tst

@@ -0,0 +1,20 @@
+gap> START_TEST("InhomIneq.tst");
+
+#
+# Test a Hilbert series with negative shift
+#
+gap> M := [
+> [0,  2,  1],
+> [0, -2,  3],
+> [2, -2,  3]
+> ];
+[ [ 0, 2, 1 ], [ 0, -2, 3 ], [ 2, -2, 3 ] ]
+gap> InhomIneq := NmzCone(["inhom_inequalities", M, "grading", [[1,0]] ]);
+<a Normaliz cone>
+gap> NmzHilbertSeries(InhomIneq);
+[ 1+t^-1, [ [ 1, 1 ] ] ]
+gap> NmzHilbertQuasiPolynomial(InhomIneq);
+[ 2 ]
+
+#
+gap> STOP_TEST("InhomIneq.tst", 0);

gap/pkg/normalizinterface/tst/bugfix.tst

@@ -0,0 +1,37 @@
+gap> START_TEST("bugfix.tst");
+
+#
+# We used to incorrectly convert integer value "0" (zero) from type mpz_t
+# to GAP integers, leading to bogus outputs in e.g. the following example.
+# Fixed by adding a special case for zero to MpzToGAP.
+#
+gap> C := NmzCone(["integral_closure",[[1,2],[3,1]],"grading",[[1,1]]]);
+<a Normaliz cone>
+gap> _NmzConeProperty(C,"HilbertSeries");
+[ [ 1, -1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1 ], [ 1, 12 ], 0 ]
+gap> NmzHilbertSeries(C);
+[ t^11+t^8+t^6+t^3+t^2-t+1, [ [ 1, 1 ], [ 12, 1 ] ] ]
+
+#
+# The following returns a bad result with Normaliz 3.4.0.
+# See https://github.com/gap-packages/NormalizInterface/issues/58
+#
+gap> C := NmzCone( "integral_closure", [ [0,0,1], [0,2,1], [1,0,1], [1,1,1] ] );;
+gap> NmzDeg1Elements(C);
+[ [ 0, 0, 1 ], [ 0, 1, 1 ], [ 0, 2, 1 ], [ 1, 0, 1 ], [ 1, 1, 1 ] ]
+
+#
+# The following produces a segfault with Normaliz 3.4.0 and 3.5.1, but
+# seems to work fine with 3.5.4 and newer.
+# See https://github.com/gap-packages/NormalizInterface/issues/61
+#
+gap> L := [ [ -1, -1, 0, 0, 0, 0 ], [ -1, 0, 0, 0, 0, 0 ], [ 0, 0, -1, -1, -1, 0 ],
+>          [ 0, 0, -1, 0, 0, 0 ], [ 0, 0, 0, -1, 0, 0 ],  [ 1, 1, 0, 0, 0, 0 ],
+>          [ 1, 0, 0, 0, 0, 0 ], [ 0, 0, 1, 1, 1, 0 ], [ 0, 0, 1, 0, 0, 0 ],
+>          [ 0, 0, 0, 1, 0, 0 ] ];;
+gap> C := NmzCone( "inhom_inequalities", L );;
+gap> NmzModuleGenerators(C);
+[ [ 0, 0, 0, 0, 0, 1 ] ]
+
+#
+gap> STOP_TEST("bugfix.tst", 0);

gap/pkg/normalizinterface/tst/conversion.tst

@@ -0,0 +1,87 @@
+gap> START_TEST("conversion.tst");
+
+## Check the multiplicity for some powers of 2:
+gap> n := 28;; 2^n = NmzMultiplicity( NmzCone("polytope", 2 * IdentityMat(n+1)) );
+true
+gap> n := 31;; 2^n = NmzMultiplicity( NmzCone("polytope", 2 * IdentityMat(n+1)) );
+true
+gap> n := 32;; 2^n = NmzMultiplicity( NmzCone("polytope", 2 * IdentityMat(n+1)) );
+true
+gap> n := 33;; 2^n = NmzMultiplicity( NmzCone("polytope", 2 * IdentityMat(n+1)) );
+true
+gap> n := 60;; 2^n = NmzMultiplicity( NmzCone("polytope", 2 * IdentityMat(n+1)) );
+true
+gap> n := 63;; 2^n = NmzMultiplicity( NmzCone("polytope", 2 * IdentityMat(n+1)) );
+true
+gap> n := 64;; 2^n = NmzMultiplicity( NmzCone("polytope", 2 * IdentityMat(n+1)) );
+true
+gap> n := 65;; 2^n = NmzMultiplicity( NmzCone("polytope", 2 * IdentityMat(n+1)) );
+true
+
+## Check conversion for a matrix which entries contain
+## e*2^n + d, where e is 1 or -1, d is -1, 0, 1, and n is, say, 28, 31,32, 60, 63, 64
+gap> start := 25;;
+gap> n := 40;; ## should be divisible by 4
+gap> M := NullMat(n,2*n);;
+gap> 
+gap> for i in [1 .. n] do
+>   M[i][n-i+1] := 1;  # antidiagonal element
+>   entry := 2^(start+i) - n/4;
+>   for j in [n+1 .. 2*n] do
+>     M[i][j] := entry;
+>     if j mod 2 <> 0 then
+>       entry := -entry;
+>     else
+>       entry := -entry + 1;
+>     fi;
+>   od;
+> od;
+gap> 
+gap> C := NmzCone("cone", M);
+<a Normaliz cone>
+gap> NmzMultiplicity(C);
+1
+gap> rays := NmzExtremeRays(C);;
+
+#
+gap> i := 1;;
+gap> Print(i+start," ", M[i] = rays[i], "\n"); i := i + 1;;
+26 true
+gap> Print(i+start," ", M[i] = rays[i], "\n"); i := i + 1;;
+27 true
+gap> Print(i+start," ", M[i] = rays[i], "\n"); i := i + 1;;
+28 true
+gap> Print(i+start," ", M[i] = rays[i], "\n"); i := i + 1;;
+29 true
+gap> Print(i+start," ", M[i] = rays[i], "\n"); i := i + 1;;
+30 true
+gap> Print(i+start," ", M[i] = rays[i], "\n"); i := i + 1;;
+31 true
+gap> Print(i+start," ", M[i] = rays[i], "\n"); i := i + 1;;
+32 true
+gap> Print(i+start," ", M[i] = rays[i], "\n"); i := i + 1;;
+33 true
+gap> Print(i+start," ", M[i] = rays[i], "\n"); i := i + 1;;
+34 true
+
+#
+gap> i := 58 - start;;
+gap> Print(i+start," ", M[i] = rays[i], "\n"); i := i + 1;;
+58 true
+gap> Print(i+start," ", M[i] = rays[i], "\n"); i := i + 1;;
+59 true
+gap> Print(i+start," ", M[i] = rays[i], "\n"); i := i + 1;;
+60 true
+gap> Print(i+start," ", M[i] = rays[i], "\n"); i := i + 1;;
+61 true
+gap> Print(i+start," ", M[i] = rays[i], "\n"); i := i + 1;;
+62 true
+gap> Print(i+start," ", M[i] = rays[i], "\n"); i := i + 1;;
+63 true
+gap> Print(i+start," ", M[i] = rays[i], "\n"); i := i + 1;;
+64 true
+gap> Print(i+start," ", M[i] = rays[i], "\n"); i := i + 1;;
+65 true
+
+#
+gap> STOP_TEST("conversion.tst", 0);

gap/pkg/normalizinterface/tst/cube-incidence.tst

@@ -0,0 +1,62 @@
+#
+gap> START_TEST("cube-incidence.tst");
+
+# enter cube inequalities (TODO: make this more convenient)
+gap> d:=5;;
+gap> cube:=function(d)
+>   local M;
+>   M:=NullMat(2*d,d+1);;
+>   M{[1..d]}{[1..d]}:=IdentityMat(d);;
+>   M{[1..d]+d}{[1..d]}:=-IdentityMat(d);;
+>   M{[1..d]+d}[1+d] := ListWithIdenticalEntries(d,1);;
+>   return NmzCone(["inhom_inequalities", M]);
+> end;;
+gap> printIncidence:=function(cone)
+>   local tmp;
+>   tmp := NmzIncidence(cone);
+>   tmp := List(tmp,r->List(r,function(x) if x then return '1'; fi; return '0'; end));
+>   Display(JoinStringsWithSeparator(tmp, "\n"));
+> end;;
+
+#
+gap> cone := cube(5);
+<a Normaliz cone>
+gap> Length(NmzVerticesOfPolyhedron(cone)) = 32;
+true
+gap> NmzVolume(cone);
+120
+gap> printIncidence(cone);
+00000000000000001111111111111111
+00000000111111110000000011111111
+00001111000011110000111100001111
+00110011001100110011001100110011
+01010101010101010101010101010101
+10101010101010101010101010101010
+11001100110011001100110011001100
+11110000111100001111000011110000
+11111111000000001111111100000000
+11111111111111110000000000000000
+
+#
+gap> cone := cube(6);
+<a Normaliz cone>
+gap> Length(NmzVerticesOfPolyhedron(cone)) = 64;
+true
+gap> NmzVolume(cone);
+720
+gap> printIncidence(cone);
+0000000000000000000000000000000011111111111111111111111111111111
+0000000000000000111111111111111100000000000000001111111111111111
+0000000011111111000000001111111100000000111111110000000011111111
+0000111100001111000011110000111100001111000011110000111100001111
+0011001100110011001100110011001100110011001100110011001100110011
+0101010101010101010101010101010101010101010101010101010101010101
+1010101010101010101010101010101010101010101010101010101010101010
+1100110011001100110011001100110011001100110011001100110011001100
+1111000011110000111100001111000011110000111100001111000011110000
+1111111100000000111111110000000011111111000000001111111100000000
+1111111111111111000000000000000011111111111111110000000000000000
+1111111111111111111111111111111100000000000000000000000000000000
+
+#
+gap> STOP_TEST("cube-incidence.tst", 0);