ExpVector
edu.jas.poly

Class ExpVector

  • All Implemented Interfaces:
    AbelianGroupElem<ExpVector>, Element<ExpVector>, Serializable, Comparable<ExpVector>
    Direct Known Subclasses:
    ExpVectorByte, ExpVectorInteger, ExpVectorLong, ExpVectorShort


    public abstract class ExpVectorextends Objectimplements AbelianGroupElem<ExpVector>
    ExpVector implements exponent vectors for polynomials. Exponent vectors are implemented as arrays of Java elementary types, like long, int, short and byte. ExpVector provides also the familiar MAS static method names. The implementation is only tested for nonnegative exponents but should work also for negative exponents. Objects of this class are intended to be immutable, but exponents can be set (during construction); also the hash code is only computed once, when needed. The different storage unit implementations are ExpVectorLong ExpVectorInteger, ExpVectorShort and ExpVectorByte. The static factory methods create() of ExpVector select the respective storage unit. The selection of the desired storage unit is internally done via the static variable storunit. This varaible should not be changed dynamically.
    See Also:
    Serialized Form
    • Field Detail

      • storunit

        public static final ExpVector.StorUnit storunit
        Used storage representation of exponent arrays. Note: Set this only statically and not dynamically.
    • Constructor Detail

      • ExpVector

        public ExpVector()
        Constructor for ExpVector.
    • Method Detail

      • create

        public static ExpVector create(int n)
        Factory constructor for ExpVector.
        Parameters:
        n - length of exponent vector.
      • create

        public static ExpVector create(int n,               int i,               long e)
        Factory constructor for ExpVector. Sets exponent i to e.
        Parameters:
        n - length of exponent vector.
        i - index of exponent to be set.
        e - exponent to be set.
      • create

        public static ExpVector create(long[] v)
        Internal factory constructor for ExpVector. Sets val.
        Parameters:
        v - internal representation array.
      • create

        public static ExpVector create(String s)
        Factory constructor for ExpVector. Converts a String representation to an ExpVector. Accepted format = (1,2,3,4,5,6,7).
        Parameters:
        s - String representation.
      • create

        public static ExpVector create(Collection<Long> v)
        Factory constructor for ExpVector. Sets val.
        Parameters:
        v - collection of exponents.
      • getVal

        public abstract long getVal(int i)
        Get the exponent at position i.
        Parameters:
        i - position.
        Returns:
        val[i].
      • length

        public abstract int length()
        Get the length of this exponent vector.
        Returns:
        val.length.
      • extend

        public abstract ExpVector extend(int i,               int j,               long e)
        Extend variables. Used e.g. in module embedding. Extend this by i elements and set val[j] to e.
        Parameters:
        i - number of elements to extend.
        j - index of element to be set.
        e - new exponent for val[j].
        Returns:
        extended exponent vector.
      • extendLower

        public abstract ExpVector extendLower(int i,                    int j,                    long e)
        Extend lower variables. Extend this by i lower elements and set val[j] to e.
        Parameters:
        i - number of elements to extend.
        j - index of element to be set.
        e - new exponent for val[j].
        Returns:
        extended exponent vector.
      • contract

        public abstract ExpVector contract(int i,                 int len)
        Contract variables. Used e.g. in module embedding. Contract this to len elements.
        Parameters:
        i - position of first element to be copied.
        len - new length.
        Returns:
        contracted exponent vector.
      • reverse

        public abstract ExpVector reverse()
        Reverse variables. Used e.g. in opposite rings.
        Returns:
        reversed exponent vector.
      • reverse

        public abstract ExpVector reverse(int j)
        Reverse j variables. Used e.g. in opposite rings. Reverses the first j-1 variables, the rest is unchanged.
        Parameters:
        j - index of first variable not reversed.
        Returns:
        reversed exponent vector.
      • combine

        public abstract ExpVector combine(ExpVector V)
        Combine with ExpVector. Combine this with the other ExpVector V.
        Parameters:
        V - the other exponent vector.
        Returns:
        combined exponent vector.
      • toString

        public String toString(String[] vars)
        Get the string representation with variable names.
        Parameters:
        vars - names of variables.
        See Also:
        Object.toString()
      • varsToString

        public static String varsToString(String[] vars)
        Get the string representation of the variables.
        Parameters:
        vars - names of variables.
        Returns:
        string representation of the variables.
        See Also:
        Object.toString()
      • toScript

        public String toScript(String[] vars)
        Get a scripting compatible string representation.
        Returns:
        script compatible representation for this Element.
        See Also:
        Element.toScript()
      • indexVarName

        public String indexVarName(int idx,                  String... vars)
        Get the variable name at index.
        Parameters:
        idx - index of the variable
        vars - array of names of variables
        Returns:
        name of variable at the given index.
      • varIndex

        public int varIndex(int idx)
        Get the array index of a variable at index.
        Parameters:
        idx - index of the variable
        Returns:
        array index of the variable.
      • indexVar

        public int indexVar(String x,           String... vars)
        Get the index of a variable.
        Parameters:
        x - variable name to be searched.
        vars - array of names of variables
        Returns:
        index of x in vars.
      • evaluate

        public <C extends RingElem<C>> C evaluate(RingFactory<C> cf,                                 List<C> a)
        Evaluate.
        Parameters:
        cf - ring factory for elements of a.
        a - list of values.
        Returns:
        a_1^{e_1} * ... * a_n^{e_n}.
      • isZERO

        public boolean isZERO()
        Is ExpVector zero.
        Specified by:
        isZERO in interface AbelianGroupElem<ExpVector>
        Returns:
        If this has all elements 0 then true is returned, else false.
      • stdVars

        public String[] stdVars()
        Standard variable names. Generate standard names for variables, i.e. x0 to x(n-1).
        Returns:
        standard names.
      • stdVars

        public String[] stdVars(String prefix)
        Generate variable names. Generate names for variables, i.e. prefix0 to prefix(n-1).
        Parameters:
        prefix - name prefix.
        Returns:
        standard names.
      • STDVARS

        public static String[] STDVARS(int n)
        Standard variable names. Generate standard names for variables, i.e. x0 to x(n-1).
        Parameters:
        n - size of names array
        Returns:
        standard names.
      • STDVARS

        public static String[] STDVARS(String prefix,               int n)
        Generate variable names. Generate names for variables from given prefix. i.e. prefix0 to prefix(n-1).
        Parameters:
        n - size of names array.
        prefix - name prefix.
        Returns:
        vatiable names.
      • EVABS

        public static ExpVector EVABS(ExpVector U)
        ExpVector absolute value.
        Parameters:
        U -
        Returns:
        abs(U).
      • EVNEG

        public static ExpVector EVNEG(ExpVector U)
        ExpVector negate.
        Parameters:
        U -
        Returns:
        -U.
      • EVDIF

        public static ExpVector EVDIF(ExpVector U,              ExpVector V)
        ExpVector difference. Result may have negative entries.
        Parameters:
        U -
        V -
        Returns:
        U-V.
      • EVSU

        public static ExpVector EVSU(ExpVector U,             int i,             long d)
        ExpVector substitution. Clone and set exponent to d at position i.
        Parameters:
        U -
        i - position.
        d - new exponent.
        Returns:
        substituted ExpVector.
      • subst

        public ExpVector subst(int i,              long d)
        ExpVector substitution. Clone and set exponent to d at position i.
        Parameters:
        i - position.
        d - new exponent.
        Returns:
        substituted ExpVector.
      • EVRAND

        public static ExpVector EVRAND(int r,               long k,               float q)
        Generate a random ExpVector.
        Parameters:
        r - length of new ExpVector.
        k - maximal degree in each exponent.
        q - density of nozero exponents.
        Returns:
        random ExpVector.
      • EVRAND

        public static ExpVector EVRAND(int r,               long k,               float q,               Random rnd)
        Generate a random ExpVector.
        Parameters:
        r - length of new ExpVector.
        k - maximal degree in each exponent.
        q - density of nozero exponents.
        rnd - is a source for random bits.
        Returns:
        random ExpVector.
      • random

        public static ExpVector random(int r,               long k,               float q)
        Generate a random ExpVector.
        Parameters:
        r - length of new ExpVector.
        k - maximal degree in each exponent.
        q - density of nozero exponents.
        Returns:
        random ExpVector.
      • random

        public static ExpVector random(int r,               long k,               float q,               Random rnd)
        Generate a random ExpVector.
        Parameters:
        r - length of new ExpVector.
        k - maximal degree in each exponent.
        q - density of nozero exponents.
        rnd - is a source for random bits.
        Returns:
        random ExpVector.
      • EVSIGN

        public static int EVSIGN(ExpVector U)
        ExpVector sign.
        Parameters:
        U -
        Returns:
        0 if U is zero, -1 if some entry is negative, 1 if no entry is negativ and at least one entry is positive.
      • signum

        public abstract int signum()
        ExpVector signum.
        Specified by:
        signum in interface AbelianGroupElem<ExpVector>
        Returns:
        0 if this is zero, -1 if some entry is negative, 1 if no entry is negative and at least one entry is positive.
      • EVTDEG

        public static long EVTDEG(ExpVector U)
        ExpVector total degree.
        Parameters:
        U -
        Returns:
        sum of all exponents.
      • degree

        public long degree()
        ExpVector degree.
        Returns:
        total degree of all exponents.
      • totalDeg

        public abstract long totalDeg()
        ExpVector total degree.
        Returns:
        sum of all exponents.
      • EVMDEG

        public static long EVMDEG(ExpVector U)
        ExpVector maximal degree.
        Parameters:
        U -
        Returns:
        maximal exponent.
      • maxDeg

        public abstract long maxDeg()
        ExpVector maximal degree.
        Returns:
        maximal exponent.
      • EVWDEG

        public static long EVWDEG(long[][] w,          ExpVector U)
        ExpVector weighted degree.
        Parameters:
        w - weights.
        U -
        Returns:
        weighted sum of all exponents.
      • weightDeg

        public abstract long weightDeg(long[][] w)
        ExpVector weighted degree.
        Parameters:
        w - weights.
        Returns:
        weighted sum of all exponents.
      • EVLCM

        public static ExpVector EVLCM(ExpVector U,              ExpVector V)
        ExpVector least common multiple.
        Parameters:
        U -
        V -
        Returns:
        component wise maximum of U and V.
      • lcm

        public abstract ExpVector lcm(ExpVector V)
        ExpVector least common multiple.
        Parameters:
        V -
        Returns:
        component wise maximum of this and V.
      • EVGCD

        public static ExpVector EVGCD(ExpVector U,              ExpVector V)
        ExpVector greatest common divisor.
        Parameters:
        U -
        V -
        Returns:
        component wise minimum of U and V.
      • gcd

        public abstract ExpVector gcd(ExpVector V)
        ExpVector greatest common divisor.
        Parameters:
        V -
        Returns:
        component wise minimum of this and V.
      • EVDOV

        public static int[] EVDOV(ExpVector U)
        ExpVector dependency on variables.
        Parameters:
        U -
        Returns:
        array of indices where U has positive exponents.
      • dependencyOnVariables

        public abstract int[] dependencyOnVariables()
        ExpVector dependency on variables.
        Returns:
        array of indices where val has positive exponents.
      • EVMT

        public static boolean EVMT(ExpVector U,           ExpVector V)
        ExpVector multiple test. Test if U is component wise greater or equal to V.
        Parameters:
        U -
        V -
        Returns:
        true if U is a multiple of V, else false.
      • multipleOf

        public abstract boolean multipleOf(ExpVector V)
        ExpVector multiple test. Test if this is component wise greater or equal to V.
        Parameters:
        V -
        Returns:
        true if this is a multiple of V, else false.
      • divides

        public boolean divides(ExpVector V)
        ExpVector divides test. Test if V is component wise greater or equal to this.
        Parameters:
        V -
        Returns:
        true if this divides V, else false.
      • EVILCP

        public static int EVILCP(ExpVector U,         ExpVector V)
        Inverse lexicographical compare.
        Parameters:
        U -
        V -
        Returns:
        0 if U == V, -1 if U < V, 1 if U > V.
      • invLexCompareTo

        public abstract int invLexCompareTo(ExpVector V)
        ExpVector inverse lexicographical compareTo.
        Parameters:
        V -
        Returns:
        0 if U == V, -1 if U < V, 1 if U > V.
      • EVILCP

        public static int EVILCP(ExpVector U,         ExpVector V,         int begin,         int end)
        Inverse lexicographical compare part. Compare entries between begin and end (-1).
        Parameters:
        U -
        V -
        begin -
        end -
        Returns:
        0 if U == V, -1 if U < V, 1 if U > V.
      • invLexCompareTo

        public abstract int invLexCompareTo(ExpVector V,                  int begin,                  int end)
        ExpVector inverse lexicographical compareTo.
        Parameters:
        V -
        begin -
        end -
        Returns:
        0 if U == V, -1 if U < V, 1 if U > V.
      • EVIGLC

        public static int EVIGLC(ExpVector U,         ExpVector V)
        Inverse graded lexicographical compare.
        Parameters:
        U -
        V -
        Returns:
        0 if U == V, -1 if U < V, 1 if U > V.
      • invGradCompareTo

        public abstract int invGradCompareTo(ExpVector V)
        ExpVector inverse graded lexicographical compareTo.
        Parameters:
        V -
        Returns:
        0 if U == V, -1 if U < V, 1 if U > V.
      • EVIGLC

        public static int EVIGLC(ExpVector U,         ExpVector V,         int begin,         int end)
        Inverse graded lexicographical compare part. Compare entries between begin and end (-1).
        Parameters:
        U -
        V -
        begin -
        end -
        Returns:
        0 if U == V, -1 if U < V, 1 if U > V.
      • invGradCompareTo

        public abstract int invGradCompareTo(ExpVector V,                   int begin,                   int end)
        ExpVector inverse graded lexicographical compareTo.
        Parameters:
        V -
        begin -
        end -
        Returns:
        0 if U == V, -1 if U < V, 1 if U > V.
      • EVRILCP

        public static int EVRILCP(ExpVector U,          ExpVector V)
        Reverse inverse lexicographical compare.
        Parameters:
        U -
        V -
        Returns:
        0 if U == V, -1 if U < V, 1 if U > V.
      • revInvLexCompareTo

        public abstract int revInvLexCompareTo(ExpVector V)
        ExpVector reverse inverse lexicographical compareTo.
        Parameters:
        V -
        Returns:
        0 if U == V, -1 if U < V, 1 if U > V.
      • EVRILCP

        public static int EVRILCP(ExpVector U,          ExpVector V,          int begin,          int end)
        Reverse inverse lexicographical compare part. Compare entries between begin and end (-1).
        Parameters:
        U -
        V -
        begin -
        end -
        Returns:
        0 if U == V, -1 if U < V, 1 if U > V.
      • revInvLexCompareTo

        public abstract int revInvLexCompareTo(ExpVector V,                     int begin,                     int end)
        ExpVector reverse inverse lexicographical compareTo.
        Parameters:
        V -
        begin -
        end -
        Returns:
        0 if U == V, -1 if U < V, 1 if U > V.
      • EVRIGLC

        public static int EVRIGLC(ExpVector U,          ExpVector V)
        Reverse inverse graded lexicographical compare.
        Parameters:
        U -
        V -
        Returns:
        0 if U == V, -1 if U < V, 1 if U > V.
      • revInvGradCompareTo

        public abstract int revInvGradCompareTo(ExpVector V)
        ExpVector reverse inverse graded compareTo.
        Parameters:
        V -
        Returns:
        0 if U == V, -1 if U < V, 1 if U > V.
      • EVRIGLC

        public static int EVRIGLC(ExpVector U,          ExpVector V,          int begin,          int end)
        Reverse inverse graded lexicographical compare part. Compare entries between begin and end (-1).
        Parameters:
        U -
        V -
        begin -
        end -
        Returns:
        0 if U == V, -1 if U < V, 1 if U > V.
      • revInvGradCompareTo

        public abstract int revInvGradCompareTo(ExpVector V,                      int begin,                      int end)
        ExpVector reverse inverse graded compareTo.
        Parameters:
        V -
        begin -
        end -
        Returns:
        0 if U == V, -1 if U < V, 1 if U > V.
      • EVIWLC

        public static int EVIWLC(long[][] w,         ExpVector U,         ExpVector V)
        Inverse weighted lexicographical compare.
        Parameters:
        w - weight array.
        U -
        V -
        Returns:
        0 if U == V, -1 if U < V, 1 if U > V.
      • invWeightCompareTo

        public abstract int invWeightCompareTo(long[][] w,                     ExpVector V)
        ExpVector inverse weighted lexicographical compareTo.
        Parameters:
        w - weight array.
        V -
        Returns:
        0 if U == V, -1 if U < V, 1 if U > V.
      • EVIWLC

        public static int EVIWLC(long[][] w,         ExpVector U,         ExpVector V,         int begin,         int end)
        Inverse weighted lexicographical compare part. Compare entries between begin and end (-1).
        Parameters:
        w - weight array.
        U -
        V -
        begin -
        end -
        Returns:
        0 if U == V, -1 if U < V, 1 if U > V.
      • invWeightCompareTo

        public abstract int invWeightCompareTo(long[][] w,                     ExpVector V,                     int begin,                     int end)
        ExpVector inverse weighted lexicographical compareTo.
        Parameters:
        w - weight array.
        V -
        begin -
        end -
        Returns:
        0 if U == V, -1 if U < V, 1 if U > V.

SCaVis 2.0 © jWork.ORG