# 9.34 Integer¶

FriCAS provides many operations for manipulating arbitrary precision integers. In this section we will show some of those that come from Integer itself plus some that are implemented in other packages. More examples of using integers are in the following sections: ugIntroNumbersPage in section ugIntroNumbersNumber IntegerNumberTheoryFunctionsXmpPage , DecimalExpansionXmpPage , BinaryExpansionXmpPage , HexadecimalExpansionXmpPage , and RadixExpansionXmpPage .

## 9.34.1 Basic Functions¶

The size of an integer in FriCAS is only limited by the amount of computer storage you have available. The usual arithmetic operations are available.

```
2^(5678 - 4856 + 2 * 17)
```

480481077043500814718154092512592439123952613987168226347385561008808420007630829308634252709141208374307457227821149607627692202643343568752733498024953930242542523045817764949544214392905306388478705146745768073877141698859815495632935288783334250628775936 |

_{Type: PositiveInteger}

There are a number of ways of working with the sign of an integer. Let’s use this x as an example.

```
x := -101
```

-101 |

_{Type: Integer}

First of all, there is the absolute value function.

```
abs(x)
```

101 |

_{Type: PositiveInteger}

The signsignInteger operation returns -1 if its argument is negative, 0 if zero and 1 if positive.

```
sign(x)
```

-1 |

_{Type: Integer}

You can determine if an integer is negative in several other ways.

```
x < 0
```

true |

_{Type: Boolean}

```
x <= -1
```

true |

_{Type: Boolean}

```
negative?(x)
```

true |

_{Type: Boolean}

Similarly, you can find out if it is positive.

```
x > 0
```

false |

_{Type: Boolean}

```
x >= 1
```

false |

_{Type: Boolean}

```
positive?(x)
```

false |

_{Type: Boolean}

This is the recommended way of determining whether an integer is zero.

```
zero?(x)
```

false |

_{Type: Boolean}

mathematical object for equality with zero. This is usually more efficient that using = (think of matrices: it is easier to tell if a matrix is zero by just checking term by term than constructing another zero matrix and comparing the two matrices term by term) and also avoids the problem that = is usually used for creating equations.

This is the recommended way of determining whether an integer is equal to one.

```
one?(x)
```

false |

_{Type: Boolean}

This syntax is used to test equality using =. It says that you want a Boolean (true or false) answer rather than an equation.

```
(x = -101)@Boolean
```

true |

_{Type: Boolean}

The operations odd?odd?Integer and even?even?Integer determine whether an integer is odd or even, respectively. They each return a Boolean object.

```
odd?(x)
```

true |

_{Type: Boolean}

```
even?(x)
```

false |

_{Type: Boolean}

The operation gcdgcdInteger computes the greatest common divisor of two integers.

```
gcd(56788,43688)
```

4 |

_{Type: PositiveInteger}

The operation lcmlcmInteger computes their least common multiple.

```
lcm(56788,43688)
```

620238536 |

_{Type: PositiveInteger}

To determine the maximum of two integers, use maxmaxInteger.

```
max(678,567)
```

678 |

_{Type: PositiveInteger}

To determine the minimum, use minminInteger.

```
min(678,567)
```

567 |

_{Type: PositiveInteger}

The reduce operation is used to extend binary operations to more than two arguments. For example, you can use reduce to find the maximum integer in a list or compute the least common multiple of all integers in the list.

```
reduce(max,[2,45,-89,78,100,-45])
```

100 |

_{Type: PositiveInteger}

```
reduce(min,[2,45,-89,78,100,-45])
```

-89 |

_{Type: Integer}

```
reduce(gcd,[2,45,-89,78,100,-45])
```

1 |

_{Type: PositiveInteger}

```
reduce(lcm,[2,45,-89,78,100,-45])
```

1041300 |

_{Type: PositiveInteger}

The infix operator / is not used to compute the quotient of integers. Rather, it is used to create rational numbers as described in FractionXmpPage .

```
13 / 4
```

134 |

_{Type: Fraction Integer}

The infix operation quoquoInteger computes the integer quotient.

```
13 quo 4
```

3 |

_{Type: PositiveInteger}

The infix operation remremInteger computes the integer remainder.

```
13 rem 4
```

1 |

_{Type: PositiveInteger}

One integer is evenly divisible by another if the remainder is zero. The operation exquoexquoInteger can also be used. See ugTypesUnionsPage in Section ugTypesUnionsNumber for an example.

```
zero?(167604736446952 rem 2003644)
```

true |

_{Type: Boolean}

The operation dividedivideInteger returns a record of the quotient and remainder and thus is more efficient when both are needed.

```
d := divide(13,4)
```

[quotient=3,remainder=1] |

_{Type: Record(quotient: Integer,remainder: Integer)}

```
d.quotient
```

3 |

_{Type: PositiveInteger}

Records are discussed in detail in Section ugTypesRecords .

```
d.remainder
```

1 |

_{Type: PositiveInteger}

## 9.34.2 Primes and Factorization¶

Use the operation factorfactorInteger to factor integers. It returns an object of type Factored Integer. See FactoredXmpPage for a discussion of the manipulation of factored objects.

```
factor 102400
```

21252 |

_{Type: Factored Integer}

The operation prime?prime?Integer returns true or false depending on whether its argument is a prime.

```
prime? 7
```

true |

_{Type: Boolean}

```
prime? 8
```

false |

_{Type: Boolean}

The operation nextPrimenextPrimeIntegerPrimesPackage returns the least prime number greater than its argument.

```
nextPrime 100
```

101 |

_{Type: PositiveInteger}

The operation prevPrimeprevPrimeIntegerPrimesPackage returns the greatest prime number less than its argument.

```
prevPrime 100
```

97 |

_{Type: PositiveInteger}

To compute all primes between two integers (inclusively), use the operation primesprimesIntegerPrimesPackage.

```
primes(100,175)
```

[173,167,163,157,151,149,139,137,131,127,113,109,107,103,101] |

_{Type: List Integer}

You might sometimes want to see the factorization of an integer when it is considered a Gaussian integer. See ComplexXmpPage for more details.

```
factor(2 :: Complex Integer)
```

-i(1+i)2 |

_{Type: Factored Complex Integer}

## 9.34.3 Some Number Theoretic Functions¶

FriCAS provides several number theoretic operations for integers. More examples are in IntegerNumberTheoryFunctionsXmpPage .

The operation fibonaccifibonacciIntegerNumberTheoryFunctions computes the Fibonacci numbers. The algorithm has running time for argument n.

```
[fibonacci(k) for k in 0..]
```

[0,1,1,2,3,5,8,13,21,34,…] |

_{Type: Stream Integer}

The operation legendrelegendreIntegerNumberTheoryFunctions computes the Legendre symbol for its two integer arguments where the second one is prime. If you know the second argument to be prime, use jacobijacobiIntegerNumberTheoryFunctions instead where no check is made.

```
[legendre(i,11) for i in 0..10]
```

[0,1,-1,1,1,1,-1,-1,-1,1,-1] |

_{Type: List Integer}

The operation jacobijacobiIntegerNumberTheoryFunctions computes the Jacobi symbol for its two integer arguments. By convention, 0 is returned if the greatest common divisor of the numerator and denominator is not 1.

```
[jacobi(i,15) for i in 0..9]
```

[0,1,1,0,1,0,0,-1,1,0] |

_{Type: List Integer}

The operation eulerPhieulerPhiIntegerNumberTheoryFunctions computes the values of Euler’s -function where equals the number of positive integers less than or equal to n that are relatively prime to the positive integer n.

```
[eulerPhi i for i in 1..]
```

[1,1,2,2,4,2,6,4,6,4,…] |

_{Type: Stream Integer}

The operation moebiusMumoebiusMuIntegerNumberTheoryFunctions computes the Möbius λ function.

```
[moebiusMu i for i in 1..]
```

[1,-1,-1,0,-1,1,-1,0,0,1,…] |

_{Type: Stream Integer}

Although they have somewhat limited utility, FriCAS provides Roman numerals.

```
a := roman(78)
```

LXXVIII |

_{Type: RomanNumeral}

```
b := roman(87)
```

LXXXVII |

_{Type: RomanNumeral}

```
a + b
```

CLXV |

_{Type: RomanNumeral}

```
a * b
```

MMMMMMDCCLXXXVI |

_{Type: RomanNumeral}

```
b rem a
```

IX |

_{Type: RomanNumeral}