### Navigation

- index
- modules |
- next |
- previous |
- Combinatorial Geometry »

# Linear Expressions

A linear expression is just a linear polynomial in some (fixed) variables. This class only implements linear expressions for others to use.

EXAMPLES:

    sage: from sage.geometry.linear_expression import LinearExpressionModule
    sage: L.<x,y,z> = LinearExpressionModule(QQ);  L
    Module of linear expressions in variables x, y, z over Rational Field
    sage: x + 2*y + 3*z + 4
    x + 2*y + 3*z + 4

You can also pass coefficients and a constant term to construct linear expressions:

    sage: L([1, 2, 3], 4)
    x + 2*y + 3*z + 4
    sage: L([(1, 2, 3), 4])
    x + 2*y + 3*z + 4
    sage: L([4, 1, 2, 3])   # note: constant is first in single-tuple notation
    x + 2*y + 3*z + 4

The linear expressions are a module under the base ring, so you can add them and multiply them with scalars:

    sage: m = x + 2*y + 3*z + 4
    sage: 2*m
    2*x + 4*y + 6*z + 8
    sage: m+m
    2*x + 4*y + 6*z + 8
    sage: m-m
    0*x + 0*y + 0*z + 0

class `sage.geometry.linear_expression.``LinearExpression`(parent, coefficients, constant, check=True)

  Bases: `sage.structure.element.ModuleElement`

  A linear expression.

  A linear expression is just a linear polynomial in some (fixed) variables.

  EXAMPLES:

      sage: from sage.geometry.linear_expression import LinearExpressionModule
      sage: L.<x,y,z> = LinearExpressionModule(QQ)
      sage: m = L([1, 2, 3], 4); m
      x + 2*y + 3*z + 4
      sage: m2 = L([(1, 2, 3), 4]); m2
      x + 2*y + 3*z + 4
      sage: m3 = L([4, 1, 2, 3]); m3   # note: constant is first in single-tuple notation
      x + 2*y + 3*z + 4
      sage: m == m2
      True
      sage: m2 == m3
      True
      sage: L.zero()
      0*x + 0*y + 0*z + 0
      sage: a = L([12, 2/3, -1], -2)
      sage: a - m
      11*x - 4/3*y - 4*z - 6
      sage: LZ.<x,y,z> = LinearExpressionModule(ZZ)
      sage: a - LZ([2, -1, 3], 1)
      10*x + 5/3*y - 4*z - 3

  `A`()

    Return the coefficient vector.

    OUTPUT:

    The coefficient vector of the linear expression.

    EXAMPLES:

        sage: from sage.geometry.linear_expression import LinearExpressionModule
        sage: L.<x,y,z> = LinearExpressionModule(QQ)
        sage: linear = L([1, 2, 3], 4);  linear
        x + 2*y + 3*z + 4
        sage: linear.A()
        (1, 2, 3)
        sage: linear.b()
        4

  `b`()

    Return the constant term.

    OUTPUT:

    The constant term of the linear expression.

    EXAMPLES:

        sage: from sage.geometry.linear_expression import LinearExpressionModule
        sage: L.<x,y,z> = LinearExpressionModule(QQ)
        sage: linear = L([1, 2, 3], 4);  linear
        x + 2*y + 3*z + 4
        sage: linear.A()
        (1, 2, 3)
        sage: linear.b()
        4

  `change_ring`(base_ring)

    Change the base ring of this linear expression.

    INPUT:

    - `base_ring` – a ring; the new base ring

    OUTPUT:

    A new linear expression over the new base ring.

    EXAMPLES:

        sage: from sage.geometry.linear_expression import LinearExpressionModule
        sage: L.<x,y,z> = LinearExpressionModule(QQ)
        sage: a = x + 2*y + 3*z + 4;  a
        x + 2*y + 3*z + 4
        sage: a.change_ring(RDF)
        1.0*x + 2.0*y + 3.0*z + 4.0

  `coefficients`()

    Return all coefficients.

    OUTPUT:

    The constant (as first entry) and coefficients of the linear terms (as subsequent entries) in a list.

    EXAMPLES:

        sage: from sage.geometry.linear_expression import LinearExpressionModule
        sage: L.<x,y,z> = LinearExpressionModule(QQ)
        sage: linear = L([1, 2, 3], 4);  linear
        x + 2*y + 3*z + 4
        sage: linear.coefficients()
        [4, 1, 2, 3]

  `constant_term`()

    Return the constant term.

    OUTPUT:

    The constant term of the linear expression.

    EXAMPLES:

        sage: from sage.geometry.linear_expression import LinearExpressionModule
        sage: L.<x,y,z> = LinearExpressionModule(QQ)
        sage: linear = L([1, 2, 3], 4);  linear
        x + 2*y + 3*z + 4
        sage: linear.A()
        (1, 2, 3)
        sage: linear.b()
        4

  `evaluate`(point)

    Evaluate the linear expression.

    INPUT:

    - `point` – list/tuple/iterable of coordinates; the coordinates of a point

    OUTPUT:

    The linear expression \(Ax + b\) evaluated at the point \(x\).

    EXAMPLES:

        sage: from sage.geometry.linear_expression import LinearExpressionModule
        sage: L.<x,y> = LinearExpressionModule(QQ)
        sage: ex = 2*x + 3* y + 4
        sage: ex.evaluate([1,1])
        9
        sage: ex([1,1])    # syntactic sugar
        9
        sage: ex([pi, e])
        2*pi + 3*e + 4

class `sage.geometry.linear_expression.``LinearExpressionModule`(base_ring, names=())

  Bases: `sage.structure.parent.Parent`, `sage.structure.unique_representation.UniqueRepresentation`

  The module of linear expressions.

  This is the module of linear polynomials which is the parent for linear expressions.

  EXAMPLES:

      sage: from sage.geometry.linear_expression import LinearExpressionModule
      sage: L = LinearExpressionModule(QQ, ('x', 'y', 'z'))
      sage: L
      Module of linear expressions in variables x, y, z over Rational Field
      sage: L.an_element()
      x + 0*y + 0*z + 0

  `Element`

    alias of `LinearExpression`

  `ambient_module`()

    Return the ambient module.

    See also

    `ambient_vector_space()`

    OUTPUT:

    The domain of the linear expressions as a free module over the base ring.

    EXAMPLES:

        sage: from sage.geometry.linear_expression import LinearExpressionModule
        sage: L = LinearExpressionModule(QQ, ('x', 'y', 'z'))
        sage: L.ambient_module()
        Vector space of dimension 3 over Rational Field
        sage: M = LinearExpressionModule(ZZ, ('r', 's'))
        sage: M.ambient_module()
        Ambient free module of rank 2 over the principal ideal domain Integer Ring
        sage: M.ambient_vector_space()
        Vector space of dimension 2 over Rational Field

  `ambient_vector_space`()

    Return the ambient vector space.

    See also

    `ambient_module()`

    OUTPUT:

    The vector space (over the fraction field of the base ring) where the linear expressions live.

    EXAMPLES:

        sage: from sage.geometry.linear_expression import LinearExpressionModule
        sage: L = LinearExpressionModule(QQ, ('x', 'y', 'z'))
        sage: L.ambient_vector_space()
        Vector space of dimension 3 over Rational Field
        sage: M = LinearExpressionModule(ZZ, ('r', 's'))
        sage: M.ambient_module()
        Ambient free module of rank 2 over the principal ideal domain Integer Ring
        sage: M.ambient_vector_space()
        Vector space of dimension 2 over Rational Field

  `change_ring`(base_ring)

    Return a new module with a changed base ring.

    INPUT:

    - `base_ring` – a ring; the new base ring

    OUTPUT:

    A new linear expression over the new base ring.

    EXAMPLES:

        sage: from sage.geometry.linear_expression import LinearExpressionModule
        sage: M.<y> = LinearExpressionModule(ZZ)
        sage: L = M.change_ring(QQ);  L
        Module of linear expressions in variable y over Rational Field

    TESTS:

        sage: L.change_ring(QQ) is L
        True

  `gen`(i)

    Return the \(i\)-th generator.

    INPUT:

    - `i` – integer

    OUTPUT:

    A linear expression.

    EXAMPLES:

        sage: from sage.geometry.linear_expression import LinearExpressionModule
        sage: L = LinearExpressionModule(QQ, ('x', 'y', 'z'))
        sage: L.gen(0)
        x + 0*y + 0*z + 0

  `gens`()

    Return the generators.

    OUTPUT:

    A tuple of linear expressions, one for each linear variable.

    EXAMPLES:

        sage: from sage.geometry.linear_expression import LinearExpressionModule
        sage: L = LinearExpressionModule(QQ, ('x', 'y', 'z'))
        sage: L.gens()
        (x + 0*y + 0*z + 0, 0*x + y + 0*z + 0, 0*x + 0*y + z + 0)

  `ngens`()

    Return the number of linear variables.

    OUTPUT:

    An integer.

    EXAMPLES:

        sage: from sage.geometry.linear_expression import LinearExpressionModule
        sage: L = LinearExpressionModule(QQ, ('x', 'y', 'z'))
        sage: L.ngens()
        3

  `random_element`()

    Return a random element.

    EXAMPLES:

        sage: from sage.geometry.linear_expression import LinearExpressionModule
        sage: L.<x,y,z> = LinearExpressionModule(QQ)
        sage: L.random_element()
        -1/2*x - 1/95*y + 1/2*z - 12

### Navigation

- index
- modules |
- next |
- previous |
- Combinatorial Geometry »