Home       Trees       Indices       Help   
Package sage :: Package structure :: Module factorization :: Class Factorization
[hide private]
[frames] | no frames]

Class Factorization

source code

            object --+    
                     |    
sage_object.SageObject --+
                         |
                        Factorization


A formal factorization of an object. 

EXAMPLES:
    sage: N = 2006
    sage: F = N.factor(); F
    2 * 17 * 59
    sage: F.unit()
    1
    sage: F = factor(-2006); F
    -1 * 2 * 17 * 59
    sage: F.unit()
    -1
    sage: loads(F.dumps()) == F
    True        
    sage: F = Factorization([(x,1/3)])
    Traceback (most recent call last):
    ...
    TypeError: powers of factors must be integers


Instance Methods [hide private]
 
__init__(self, x, unit=['4ti2-20061025', 'R-2.6.0', 'atlas-3.7.37', 'atlas-3.8.1', 'a..., cr=False, sort=True, simplify=True)
Create a \code{Factorization} object.		 source code
 
__getitem__(self, i)
Return i-th factor of self.		 source code
 
__setitem__(self, i, v)
Set the i-th factor of self.		 source code
 
__len__(self)
Return the number of prime factors of self, not counting the unit part.		 source code
 
__cmp__(self, other)
Compare self and other.		 source code
 
__copy__(self)
Return a copy of self.		 source code
 
__deepcopy__(self, memo)
Return a deep copy of self.		 source code
 
base_ring(self)
Return the parent structure of my factors.		 source code
 
is_commutative(self)
Return True if my factors commute.		 source code
 
_set_cr(self, cr)
Change whether or not the factorization is printed with carriage returns after each factor.		 source code
 
simplify(self)
Combine adjacent products that commute as much as possible.		 source code
 
sort(self, _cmp=['4ti2-20061025', 'R-2.6.0', 'atlas-3.7.37', 'atlas-3.8.1', 'a...)
Sort the factors in this factorization.		 source code
 
unit(self)
Return the unit part of this factorization.		 source code
 
unit_part(self)
Same as \code{self.unit()}.		 source code
 
_cr(self)
Return whether or not factorizations are printed with carriage returns between factors.		 source code
 
_repr_(self)
Return the string representation of this factorization.		 source code
 
_latex_(self)
Return the \LaTeX{} representation of this factorization.		 source code
 
__add__(self, other)
Return the sum of self and other.		 source code
 
__sub__(self, other)
Return the sum of self and other.		 source code
 
__neg__(self)
Return negative of this factorization.		 source code
 
__rmul__(self, left)
Return the product left * self, where left is not a Factorization.		 source code
 
__mul__(self, other)
Return the product of two factorizations, which is obtained by combining together like factors.		 source code
 
__pow__(self, n)
Return the $n$-th power of a factorization, which is got by combining together like factors.		 source code
 
__invert__(self)
Return the formal inverse of the factors in the factorization.		 source code
 
value(self)
Return the product of the factors in the factorization, multiplied out.		 source code
 
expand(self)
Same as \code{self.value()}, so this returns the product of the factors, multiplied out.		 source code
 
prod(self)
Same as \code{self.value()}.		 source code

Inherited from sage_object.SageObject: __hash__, __new__, __repr__, _axiom_, _axiom_init_, _gap_, _gap_init_, _gp_, _gp_init_, _interface_, _interface_init_, _interface_is_cached_, _kash_, _kash_init_, _macaulay2_, _macaulay2_init_, _magma_, _magma_init_, _maple_, _maple_init_, _mathematica_, _mathematica_init_, _maxima_, _maxima_init_, _octave_, _octave_init_, _pari_, _pari_init_, _r_init_, _sage_, _singular_, _singular_init_, category, db, dump, dumps, plot, rename, reset_name, save, version

Inherited from object: __delattr__, __getattribute__, __reduce__, __reduce_ex__, __setattr__, __str__

Properties [hide private]

Inherited from object: __class__

Method Details [hide private]

__init__(self, x, unit=['4ti2-20061025', 'R-2.6.0', 'atlas-3.7.37', 'atlas-3.8.1', 'a..., cr=False, sort=True, simplify=True)
(Constructor)

source code  

Create a \code{Factorization} object.

INPUT:
    x    -- a list of (p, e) pairs with e an integer (or a TypeError
            is raised).
    unit -- (default: 1) the unit part of the factorization
    cr   -- (default: False) if True, print the factorization with
            carriage returns between factors
    sort -- (default: True) if True, sort the factors by calling
            the sort function after creating the factorization.
            See the documentation for self.sort for how this works.

OUTPUT:
    a Factorization object

EXAMPLES:
We create a factorization with all the default options:
    sage: Factorization([(2,3), (5, 1)])
    2^3 * 5

We create a factorization with a specified unit part:
    sage: Factorization([(2,3), (5, 1)], unit=-1)
    -1 * 2^3 * 5

We try to create a factorization but with a string an exponent, which
results in a TypeError:
    sage: Factorization([(2,3), (5, 'x')])
    Traceback (most recent call last):
    ...
    TypeError: powers of factors must be integers

We create a factorization that puts newlines after each multiply sign when
printing.  This is mainly useful when the primes are large.
    sage: Factorization([(2,3), (5, 2)], cr=True)
    2^3 * 
    5^2

Another factorization with newlines and nontrivial unit part (which appears
on a line by itself):
    sage: Factorization([(2,3), (5, 2)], cr=True, unit=-2)
    -2 * 
    2^3 * 
    5^2

A factorization, but where we do not sort the factors:
    sage: Factorization([(5,3), (2, 3)], sort=False)
    5^3 * 2^3

By default factorizations are sorted by the prime base (for commutative bases):
    sage: Factorization([(2, 7), (5,2), (2, 5)])
    2^12 * 5^2
    sage: R.<a,b> = FreeAlgebra(QQ,2)
    sage: Factorization([(a,1),(b,1),(a,2)])
    a * b * a^2

Autosorting (the default) swaps around the factors below:
    sage: F = Factorization([(ZZ^3, 2), (ZZ^2, 5)], cr=True); F
    (Ambient free module of rank 2 over the principal ideal domain Integer Ring)^5 * 
    (Ambient free module of rank 3 over the principal ideal domain Integer Ring)^2
Overrides: object.__init__

__getitem__(self, i)
(Indexing operator)

source code  

Return i-th factor of self.

EXAMPLES:
    sage: a = factor(-75); a
    -1 * 3 * 5^2
    sage: a[0]
    (3, 1)
    sage: a[1]
    (5, 2)
    sage: a[-1]
    (5, 2)
    sage: a[5]
    Traceback (most recent call last):
    ...
    IndexError: list index out of range

__setitem__(self, i, v)
(Index assignment operator)

source code  

Set the i-th factor of self.

NOT ALLOWED -- Factorizations are immutable.

EXAMPLES:
    sage: a = factor(-75); a
    -1 * 3 * 5^2
    sage: a[0] = (2,3)
    Traceback (most recent call last):
    ...
    TypeError: 'Factorization' object does not support item assignment

__len__(self)
(Length operator)

source code  

Return the number of prime factors of self, not counting
the unit part. 

EXAMPLES:
    sage: len(factor(15))
    2

Note that the unit part is not included in the count.
    sage: a = factor(-75); a
    -1 * 3 * 5^2
    sage: len(a)
    2
    sage: list(a)
    [(3, 1), (5, 2)]
    sage: len(list(a))
    2

__cmp__(self, other)
(Comparison operator)

source code  

Compare self and other.  This compares the underlying
lists of self and other (ignoring the unit!)

EXAMPLES:
We compare two contrived formal factorizations:
    sage: a = Factorization([(2, 7), (5,2), (2, 5)])
    sage: b = Factorization([(2, 7), (5,10), (7, 3)])
    sage: a
    2^12 * 5^2
    sage: b
    2^7 * 5^10 * 7^3
    sage: a < b
    True
    sage: b < a
    False
    sage: a.expand()
    102400
    sage: b.expand()
    428750000000

We compare factorizations of some polynomials:
    sage: x = polygen(QQ)
    sage: x^2 - 1 > x^2 - 4
    True
    sage: factor(x^2 - 1) > factor(x^2 - 4)
    True

__copy__(self)

source code  

Return a copy of self.

This is of course not a deepcopy -- only references to the
factors are returned, not copies of them.  Use
\code{deepcopy(self)} if you need a deep copy of self.

EXAMPLES:
We create a factorization that has mutable primes:
    sage: F = Factorization([([1,2], 5), ([5,6], 10)]); F
    ([1, 2])^5 * ([5, 6])^10

We make a copy of it:
    sage: G = copy(F); G
    ([1, 2])^5 * ([5, 6])^10
    sage: G is F
    False

Note that if we change one of the mutable "primes" of F, this does
change G. 
    sage: F[1][0][0] = 'hello'
    sage: G
    ([1, 2])^5 * (['hello', 6])^10

__deepcopy__(self, memo)

source code  

Return a deep copy of self.

This is of course not a deepcopy -- only references to the factors
are returned, not copies of them.

EXAMPLES:
We make a factorization that has mutable entries:
    sage: F = Factorization([([1,2], 5), ([5,6], 10)]); F
    ([1, 2])^5 * ([5, 6])^10

Now we make a copy of it and a deep copy.
    sage: K = copy(F)
    sage: G = deepcopy(F); G
    ([1, 2])^5 * ([5, 6])^10

We change one of the mutable entries of F:
    sage: F[0][0][0] = 10

This of course changes F:
    sage: F
    ([10, 2])^5 * ([5, 6])^10

It also changes the copy K of F:
    sage: K
    ([10, 2])^5 * ([5, 6])^10

It does \emph{not} change the deep copy G:
    sage: G
    ([1, 2])^5 * ([5, 6])^10

base_ring(self)

source code  

Return the parent structure of my factors.

EXAMPLES:
    sage: F = factor(2006)
    sage: F.base_ring()
    Integer Ring

    sage: R.<x,y,z> = FreeAlgebra(QQ, 3)
    sage: F = Factorization([(z, 2)], 3)
    sage: (F*F^-1).base_ring()
    Rational Field

is_commutative(self)

source code  

Return True if my factors commute.

EXAMPLES:
    sage: F = factor(2006)
    sage: F.is_commutative()
    True
    sage: K = QuadraticField(23, 'a')
    sage: F = K.factor(13)
    sage: F.is_commutative()
    True
    sage: R.<x,y,z> = FreeAlgebra(QQ, 3)
    sage: F = Factorization([(z, 2)], 3)
    sage: F.is_commutative()
    False
    sage: (F*F^-1).is_commutative()
    True

_set_cr(self, cr)

source code  

Change whether or not the factorization is printed with
carriage returns after each factor.

EXAMPLES:
    sage: x = polygen(QQ,'x')
    sage: F = factor(x^6 - 1); F
    (x - 1) * (x + 1) * (x^2 - x + 1) * (x^2 + x + 1)
    sage: F._set_cr(True); F
    (x - 1) * 
    (x + 1) * 
    (x^2 - x + 1) * 
    (x^2 + x + 1)
    sage: F._set_cr(False); F
    (x - 1) * (x + 1) * (x^2 - x + 1) * (x^2 + x + 1)

simplify(self)

source code  

Combine adjacent products that commute as much as possible.

TESTS:
    sage: R.<x,y> = FreeAlgebra(ZZ, 2)
    sage: F = Factorization([(x,3), (y, 2), (y,2)], simplify=False); F
    x^3 * y^2 * y^2
    sage: F.simplify(); F
    x^3 * y^4
    sage: F * Factorization([(y, -2)], 2)
    (2) * x^3 * y^2

sort(self, _cmp=['4ti2-20061025', 'R-2.6.0', 'atlas-3.7.37', 'atlas-3.8.1', 'a...)

source code  

Sort the factors in this factorization.

INPUT:
    _cmp -- (default: None) comparison function

OUTPUT:
    changes this factorization to be sorted

If _cmp is None, we determine the comparison function as
follows: If the prime in the first factor has a dimension
method, then we sort based first on \emph{dimension} then on
the exponent.  If there is no dimension method, we next
attempt to sort based on a degree method, in which case, we
sort based first on \emph{degree}, then exponent to break ties
when two factors have the same degree, and if those match
break ties based on the actual prime itself.  If there is no
degree method, we sort based on dimension.

EXAMPLES:
We create a factored polynomial:
    sage: x = polygen(QQ,'x')
    sage: F = factor(x^3 + 1); F
    (x + 1) * (x^2 - x + 1)

Then we sort it but using the negated version of the standard
Python cmp function:
    sage: F.sort(_cmp = lambda x,y: -cmp(x,y))
    sage: F
    (x^2 - x + 1) * (x + 1)

unit(self)

source code  

Return the unit part of this factorization.

EXAMPLES:
    sage: F = factor(-2006); F
    -1 * 2 * 17 * 59
    sage: F.unit()
    -1

unit_part(self)

source code  

Same as \code{self.unit()}.

EXAMPLES:
We create a polynomial over the real double field and factor it:
    sage: x = polygen(RDF, 'x')
    sage: F = factor(-2*x^2 - 1); F
    (-2.0) * (1.0*x^2 + 0.5)

Note that the unit part of the factorization is $-2.0$. 
    sage: F.unit_part()
    -2.0

_cr(self)

source code  

Return whether or not factorizations are printed with carriage returns
between factors.

EXAMPLES:
Our first example involves factoring an integer:
    sage: F = factor(-93930); F
    -1 * 2 * 3 * 5 * 31 * 101
    sage: F._cr()
    False
    sage: F._set_cr(True)
    sage: F._cr()
    True

This of course looks funny:
    sage: F
    -1 * 
    2 * 
    3 * 
    5 * 
    31 * 
    101

Next we factor a modular symbols space:
    sage: F = ModularSymbols(11).factor(); F
    (Modular Symbols subspace of dimension 1 of ...) * 
    (Modular Symbols subspace of dimension 1 of ...) * 
    (Modular Symbols subspace of dimension 1 of ...)

_repr_(self)

source code  

Return the string representation of this factorization.

EXAMPLES:
    sage: f = factor(-100); f
    -1 * 2^2 * 5^2
    sage: f._repr_()
    '-1 * 2^2 * 5^2'

Note that the default printing of a factorization can be overloaded
using the rename method.
    sage: f.rename('factorization of -100')
    sage: f
    factorization of -100

However _repr_ always prints normally.
    sage: f._repr_()
    '-1 * 2^2 * 5^2'

EXAMPLES:
   sage: x = polygen(QQ)
   sage: Factorization([(x-1,1), (x-2,2)])
    (x - 1) * (x - 2)^2

_latex_(self)

source code  

Return the \LaTeX{} representation of this factorization.

EXAMPLES:
    sage: f = factor(-100); f
    -1 * 2^2 * 5^2
    sage: latex(f)
    -1 \cdot 2^{2} \cdot 5^{2}
    sage: f._latex_()
    '-1 \\cdot 2^{2} \\cdot 5^{2}'

__add__(self, other)
(Addition operator)

source code  

Return the sum of self and other.

EXAMPLES:
    sage: factor(-10) + 16
    6
    sage: factor(10) - 16
    -6
    sage: factor(100) + factor(19)
    119

__sub__(self, other)
(Subtraction operator)

source code  

Return the sum of self and other.

EXAMPLES:
    sage: factor(-10) + 16
    6
    sage: factor(10) - 16
    -6

__neg__(self)

source code  

Return negative of this factorization.

EXAMPLES:
    sage: a = factor(-75); a
    -1 * 3 * 5^2
    sage: -a
    3 * 5^2
    sage: (-a).unit()
    1

__rmul__(self, left)

source code  

Return the product left * self, where left is not a Factorization.

EXAMPLES:
    sage: a = factor(15); a
    3 * 5
    sage: -2 * a
    -2 * 3 * 5
    sage: a * -2
    -2 * 3 * 5
    sage: R.<x,y> = FreeAlgebra(QQ,2)
    sage: f = Factorization([(x,2),(y,3)]); f
    x^2 * y^3
    sage: x * f
    x^3 * y^3
    sage: f * x
    x^2 * y^3 * x

__mul__(self, other)

source code  

Return the product of two factorizations, which is obtained by
combining together like factors.

EXAMPLES:
    sage: factor(-10) * factor(-16)
    2^5 * 5
    sage: factor(-10) * factor(16)
    -1 * 2^5 * 5

    sage: R.<x,y> = FreeAlgebra(ZZ, 2)
    sage: F = Factorization([(x,3), (y, 2), (x,1)]); F
    x^3 * y^2 * x
    sage: F*F
    x^3 * y^2 * x^4 * y^2 * x
    sage: -1 * F
    -1 * x^4 * y^2

__pow__(self, n)

source code  

Return the $n$-th power of a factorization, which is got by
combining together like factors.

EXAMPLES:
    sage: f = factor(-100); f
    -1 * 2^2 * 5^2
    sage: f^3
    -1 * 2^6 * 5^6
    sage: f^4
    2^8 * 5^8

    sage: F = factor(2006); F
    2 * 17 * 59
    sage: F**2
    2^2 * 17^2 * 59^2

    sage: R.<x,y> = FreeAlgebra(ZZ, 2)
    sage: F = Factorization([(x,3), (y, 2), (x,1)]); F
    x^3 * y^2 * x
    sage: F**2
    x^3 * y^2 * x^4 * y^2 * x

__invert__(self)

source code  

Return the formal inverse of the factors in the factorization.

EXAMPLES:
    sage: F = factor(2006); F
    2 * 17 * 59
    sage: F^-1
    2^-1 * 17^-1 * 59^-1

    sage: R.<x,y> = FreeAlgebra(QQ, 2)
    sage: F = Factorization([(x,3), (y, 2), (x,1)], 2); F
    (2) * x^3 * y^2 * x
    sage: F^-1
    (1/2) * x^-1 * y^-2 * x^-3

value(self)

source code  

Return the product of the factors in the factorization, multiplied out.

EXAMPLES:
    sage: F = factor(2006); F
    2 * 17 * 59
    sage: F.value()
    2006

    sage: R.<x,y> = FreeAlgebra(ZZ, 2)
    sage: F = Factorization([(x,3), (y, 2), (x,1)]); F
    x^3 * y^2 * x
    sage: F.value()
    x^3*y^2*x

expand(self)

source code  

Same as \code{self.value()}, so this returns the product of
the factors, multiplied out.

    sage: x = polygen(QQ, 'x')
    sage: F = factor(-x^5 + 1); F
    (-1) * (x - 1) * (x^4 + x^3 + x^2 + x + 1)
    sage: F.expand()
    -x^5 + 1

prod(self)

source code  

Same as \code{self.value()}.

EXAMPLES:
    sage: F = factor(100)
    sage: F.prod()
    100

   Home       Trees       Indices       Help   
Generated by Epydoc 3.0beta1 on Thu Jul 17 04:24:03 2008 http://epydoc.sourceforge.net