Macaulay2 » Documentation
Packages » CoincidentRootLoci :: generic(CoincidentRootLocus)
next | previous | forward | backward | up | index | toc

# generic(CoincidentRootLocus) -- get the generic element

- Function: generic
- Usage:
    `generic X`
- Inputs:
  - X, a coincident root locus
- Optional inputs:
  - Reduce => ..., default value false, reduce the number of variables
  - Variable => ..., default value null, specify a name for a variable
- Outputs:
  - a ring element, the generic binary form which belongs to X

## Description

    i1 : X = coincidentRootLocus {3,1,1}

    o1 = CRL(3,1,1)

    o1 : Coincident root locus

    i2 : F = generic X

           3       5      3           3            2           4        3
    o2 = t0 t1 t2 x  + (t0 t1 t2  + t0 t1 t2  + 3t0 t0 t1 t2 )x x  + (t0 t1 t2  +
           0  0  0 0      0  0  1     0  1  0      0  1  0  0  0 1      0  1  1
         ------------------------------------------------------------------------
            2               2                  2        3 2       2
         3t0 t0 t1 t2  + 3t0 t0 t1 t2  + 3t0 t0 t1 t2 )x x  + (3t0 t0 t1 t2  +
            0  1  0  1      0  1  1  0      0  1  0  0  0 1       0  1  1  1
         ------------------------------------------------------------------------
               2               2           3        2 3          2
         3t0 t0 t1 t2  + 3t0 t0 t1 t2  + t0 t1 t2 )x x  + (3t0 t0 t1 t2  +
            0  1  0  1      0  1  1  0     1  0  0  0 1       0  1  1  1
         ------------------------------------------------------------------------
           3           3          4     3       5
         t0 t1 t2  + t0 t1 t2 )x x  + t0 t1 t2 x
           1  0  1     1  1  0  0 1     1  1  1 1

    o2 : QQ[t0 ..t0 , t1 ..t1 , t2 ..t2 ][x ..x ]
              0    1    0    1    0    1   0   1

    i3 : member(F,X)

    o3 = true

    i4 : factor F

                                                      3
    o4 = (t2 x  + t2 x )(t1 x  + t1 x )(t0 x  + t0 x )
            0 0     1 1    0 0     1 1    0 0     1 1

    o4 : Expression of class Product

    i5 : G = generic(X,Reduce=>true)

          5 5      4      4      4    4        3 2     3         3
    o5 = t x  + (3t t  + t t  + t t )x x  + (3t t  + 3t t t  + 3t t t  +
          0 0      0 1    0 2    0 3  0 1      0 1     0 1 2     0 1 3
         ------------------------------------------------------------------------
          3      3 2     2 3     2 2       2 2       2        2 3       3
         t t t )x x  + (t t  + 3t t t  + 3t t t  + 3t t t t )x x  + (t t t  +
          0 2 3  0 1     0 1     0 1 2     0 1 3     0 1 2 3  0 1     0 1 2
         ------------------------------------------------------------------------
            3         2        4    3     5
         t t t  + 3t t t t )x x  + t t t x
          0 1 3     0 1 2 3  0 1    1 2 3 1

    o5 : QQ[t ..t ][x ..x ]
             0   3   0   1

    i6 : member(G,X)

    o6 = true

    i7 : factor G

                                                3
    o7 = (t x  + t x )(t x  + t x )(t x  + t x )
           0 0    3 1   0 0    2 1   0 0    1 1

    o7 : Expression of class Product

## See also

- random(CoincidentRootLocus) -- get a random element
- isMember(RingElement,CoincidentRootLocus) -- test membership in a coincident root locus

## Ways to use this method:

- generic(CoincidentRootLocus) -- get the generic element

The source of this document is in /build/macaulay2-88fgJW/macaulay2-1.25.11+ds/M2/Macaulay2/packages/CoincidentRootLoci/documentation.m2:130:0.