Factored

Factored creates a domain whose objects are kept in factored form as long as possible. Thus certain operations like * (multiplication) and gcd are relatively easy to do. Others, such as addition, require somewhat more work, and the result may not be completely factored unless the argument domain R provides a factor operation. Each object consists of a unit and a list of factors, where each factor consists of a member of R (the base), an exponent, and a flag indicating what is known about the base. A flag may be one of “nil”, “sqfr”, “irred” or “prime”, which mean that nothing is known about the base, it is square-free, it is irreducible, or it is prime, respectively. The current restriction to factored objects of integral domains allows simplification to be performed without worrying about multiplication order.

Decomposing Factored Objects

In this section we will work with a factored integer.

g := factor(4312)
   3 2
  2 7 11
                       Type: Factored Integer

Let’s begin by decomposing g into pieces. The only possible units for integers are 1 and -1.

unit(g)
  1
                       Type: PositiveInteger

There are three factors.

numberOfFactors(g)
  3
                       Type: PositiveInteger

We can make a list of the bases,

[nthFactor(g,i) for i in 1..numberOfFactors(g)]
  [2,7,11]
                       Type: List Integer

and the exponents,

[nthExponent(g,i) for i in 1..numberOfFactors(g)]
  [3,2,1]
                       Type: List Integer

and the flags. You can see that all the bases (factors) are prime.

[nthFlag(g,i) for i in 1..numberOfFactors(g)]
  ["prime","prime","prime"]
                       Type: List Union("nil","sqfr","irred","prime")

A useful operation for pulling apart a factored object into a list of records of the components is factorList.

factorList(g)
  [[flg= "prime",fctr= 2,xpnt= 3], [flg= "prime",fctr= 7,xpnt= 2],
   [flg= "prime",fctr= 11,xpnt= 1]]
         Type: List Record(flg: Union("nil","sqfr","irred","prime"),
                           fctr: Integer,xpnt: Integer)

If you don’t care about the flags, use factors.

factors(g)
  [[factor= 2,exponent= 3],[factor= 7,exponent= 2],[factor= 11,exponent= 1]]
                       Type: List Record(factor: Integer,exponent: Integer)

Neither of these operations returns the unit.

first(%).factor
  2
                       Type: PositiveInteger

Expanding Factored Objects

Recall that we are working with this factored integer.

g := factor(4312)
   3 2
  2 7 11
                       Type: Factored Integer

To multiply out the factors with their multiplicities, use expand.

expand(g)
  4312
                       Type: PositiveInteger

If you would like, say, the distinct factors multiplied together but with multiplicity one, you could do it this way.

reduce(*,[t.factor for t in factors(g)])
  154
                       Type: PositiveInteger

Arithmetic with Factored Objects

We’re still working with this factored integer.

g := factor(4312)
   3 2
  2 7 11
                       Type: Factored Integer

We’ll also define this factored integer.

f := factor(246960)
   4 2   3
  2 3 5 7
                       Type: Factored Integer

Operations involving multiplication and division are particularly easy with factored objects.

f * g
   7 2   5
  2 3 5 7 11
                       Type: Factored Integer

f**500
   2000 1000 500 1500
  2    3    5   7
                       Type: Factored Integer

gcd(f,g)
   3 2
  2 7
                       Type: Factored Integer

lcm(f,g)
   4 2   3
  2 3 5 7 11
                       Type: Factored Integer

If we use addition and subtraction things can slow down because we may need to compute greatest common divisors.

f + g
   3 2
  2 7 641
                       Type: Factored Integer

f - g
   3 2
  2 7 619
                       Type: Factored Integer

Test for equality with 0 and 1 by using zero? and one?, respectively.

zero?(factor(0))
  true
                       Type: Boolean

zero?(g)
  false
                       Type: Boolean

one?(factor(1))
  true
                       Type: Boolean

one?(f)
  false
                       Type: Boolean

Another way to get the zero and one factored objects is to use package calling.

0$Factored(Integer)
  0
                       Type: Factored Integer

1$Factored(Integer)
  1
                       Type: Factored Integer

Creating New Factored Objects

The map operation is used to iterate across the unit and bases of a factored object.

The following four operations take a base and an exponent and create a factored object. They differ in handling the flag component.

nilFactor(24,2)
    2
  24
                       Type: Factored Integer

This factor has no associated information.

nthFlag(%,1)
  "nil"
                       Type: Union("nil",...)

This factor is asserted to be square-free.

sqfrFactor(30,2)
    2
  30
                       Type: Factored Integer

This factor is asserted to be irreducible.

irreducibleFactor(13,10)
    10
  13
                       Type: Factored Integer

This factor is asserted to be prime.

primeFactor(11,5)
    5
  11
                       Type: Factored Integer

A partial inverse to factorList is makeFR.

h := factor(-720)
     4 2
  - 2 3 5
                       Type: Factored Integer

The first argument is the unit and the second is a list of records as returned by factorList.

h - makeFR(unit(h),factorList(h))
  0
                       Type: Factored Integer

Factored Objects with Variables

Some of the operations available for polynomials are also available for factored polynomials.

p := (4*x*x-12*x+9)*y*y + (4*x*x-12*x+9)*y + 28*x*x - 84*x + 63
     2            2      2                  2
  (4x  - 12x + 9)y  + (4x  - 12x + 9)y + 28x  - 84x + 63
                       Type: Polynomial Integer

fp := factor(p)
          2  2
  (2x - 3) (y  + y + 7)
                       Type: Factored Polynomial Integer

You can differentiate with respect to a variable.

D(p,x)
            2
  (8x - 12)y  + (8x - 12)y + 56x - 84
                       Type: Polynomial Integer

D(fp,x)
             2
  4(2x - 3)(y  + y + 7)
                       Type: Factored Polynomial Integer

numberOfFactors(%)
  3
                       Type: PositiveInteger

See Also:

  • )help FactoredFunctions2
  • )show Factored

Table Of Contents

This Page