Welcome to the L3 Harris Geospatial documentation center. Here you will find reference guides and help documents.
﻿

### BigInteger

BigInteger

The BigInteger class allows you to create and manipulate integer numbers of any size.

The BigInteger class stores a number as an array of unsigned, 32-bit integer "digits" with a radix, or base, of 4294967296. The class stores the digits in little-endian order, with the most-significant digit at the end of the array. The sign (positive or negative) is stored as a separate flag.

For speed, all of the basic math operations are written in C code. However, the BigInteger class and many of its methods are written in the IDL language. You can find the source code in the file lib/datatypes/biginteger__define.pro in your IDL installation.

### Examples

#### Constructors

You can create BigIntegers from regular numbers or from strings. For example, all of the following statements produce the same BigInteger value:

`b = BigInteger(-1440154473791)`
`b = -BigInteger(1440154473791)`
`b = BigInteger('-1440154473791')`
`b = BigInteger('1440154473791', SIGN=-1)`
`b = BigInteger('-14f4fe5553f', RADIX=16)`
`b = BigInteger('14f4fe5553f', RADIX=16, SIGN=-1)`
`b = BigInteger('-10100111101001111111001010101010100111111', RADIX=2)`
`b = BigInteger('-IDLISFUN', RADIX=36)`

You can also use special constructors to create BigIntegers. For example:

`b = BigInteger.Factorial(100000)`
`c = BigInteger.Random(2048)`
`HELP, b, c`

IDL prints:

`B               BIGINTEGER <ID=1 LENGTH=1516705 bits> = 2.8242294079603480...x10^456573`
`C               BIGINTEGER <ID=2 LENGTH=2048 bits> = 2.4851685629963955...x10^616`

#### Math Expressions

You can use BigIntegers in mathematical expressions in combination with other BigIntegers or regular numbers.

`b = BigInteger(89681)`
`c = b*96079`
`d = c^1000 + 1`
`HELP, d`

IDL prints:

`D               BIGINTEGER <ID=1 LENGTH=33005 bits> = 2.1326348897083203...x10^9935`

#### Useful Methods

The BigInteger class has numerous methods for exploring the properties of your BigInteger numbers. For example:

`d = BigInteger.Prime(1024)`
`PRINT, d`
`PRINT, d.IsPrime() ? "true" : "false"`
`PRINT, "The next prime is ", d.NextPrime() - d, " greater."`

IDL prints:

`1149852122999776946265950910757778460801690763339596229715397877648741495523473947736`
`9123431875461037047773232597449876136824910342085113678568090440263273346403963966558`
`7022954039171507173198715249963367029415827692424955706299669891876155639956998605077`
`128420061437794990570729762185868510044669595754416741`
` `
`true`
` `
`The next prime is 298 greater.`

## Syntax

Result = BigInteger( )

or

Result = BigInteger( Digits, SIGN=integer )

or

Result = BigInteger( Value, SIGN=integer )

or

Result = BigInteger( String, RADIX=integer, SIGN=integer )

## Return Value

Returns a reference to the newly-created BigInteger.

## Arguments

### Digits

Set this argument to an array of unsigned long integers (type ULONG) that contains the BigInteger value as a series of digits in radix 4294967296. You should input the digits in little-endian order, with the most significant digit at the end of the array. For negative BigInteger numbers, set the SIGN keyword to –1.

### Value

Set this argument to an integer or float to be transformed into a BigInteger. Float values will be truncated to integers. For negative numbers you can either specify a negative Value or set the SIGN keyword.

### String

Set this argument to a string containing the number. You can use the RADIX keyword if your string is in a radix other than the default of base 10. The string is case insensitive. For negative numbers you can either use a "–" sign at the beginning of your string, or set the SIGN keyword.

## Keywords

Integer, 2–36, default = 10

The radix of the input String. This keyword can only be used with a string argument. For example, if your String is in base 16 (hexadecimal) then you would set RADIX=16. In this case, the String should contain the digits 0–9 and the letters A–F or a–f. If your string happened to be in base 36 then you could use the digits 0–9 and all letters of the alphabet A–Z.

### SIGN

Integer, -1, 0, or 1, default = 1

The sign of the BigInteger: –1 for negative, 0 for zero value, 1 for positive.

Tip: If you use a string or integer value and it already has a minus sign, then you do not need to set the SIGN keyword.

## Properties

You can retrieve the following properties using either "dot" notation or the ::GetProperty method. For example:

`b = -BigInteger(2)^100`
`d = b.DIGITS`
`s = b.SIGN`
`; Or, using GetProperty...`
`; b.GetProperty, DIGITS=d, SIGN=s`
`PRINT, d, s`

IDL prints:

`0           0           0          16`
`-1`

Note: BigInteger objects are immutable: You cannot set the DIGITS or SIGN properties.

### DIGITS

This property contains the BigInteger number as a series of unsigned 32-bit integers in base 4294967296, stored in little-endian order (largest digit at the end).

### SIGN

This property is an integer (–1, 0, or 1) that indicates whether the BigInteger number is negative, zero, or positive.

# BigInteger::BitLength

The BigInteger::BitLength method returns the number of bits in the number.

## Example

`bigint = BigInteger(2)^1279 - 1`
`PRINT, bigint.BitLength()`

IDL prints:

`1279`

## Syntax

Result = bigint.BitLength( )

## Return Value

An integer giving the number of bits in the BigInteger value.

Note: Since there is no "sign" bit in a BigInteger value, a negative BigInteger value will have the same bit length as the corresponding positive value.

None

None

# BigInteger::Factorial

The BigInteger::Factorial static constructor method returns a new BigInteger containing the value of N!.

## Example

`bigint = BigInteger.Factorial(100)`
`PRINT, bigint`

IDL prints:

`9332621544394415268169923885626670049071596826438162146859296389521759999322991`
`5608941463976156518286253697920827223758251185210916864000000000000000000000000`

## Syntax

Result = BigInteger.Factorial( N )

## Return Value

A BigInteger equal to N!.

## Arguments

N

An integer giving the factorial value.

None

# BigInteger::GCD

The BigInteger::GCD method computes the greatest common divisor (the greatest common factor) between this BigInteger and another integer. The greatest common divisor is the largest integer that evenly divides each number (i.e., the remainder is 0). By definition the GCD will always be greater than or equal to 1 and less than or equal to the smaller of the two numbers.

## Examples

`u = BigInteger.Factorial(49000)`
`   v = BigInteger.Factorial(6000) + 34`
`  result = u.GCD(v)`
`HELP, u, v`
`PRINT, "GCD = ", result`

IDL prints:

`U               BIGINTEGER <ID=1 LENGTH=692762 bits> = 8.3655952924066987...x10^208541`
`V               BIGINTEGER <ID=2 LENGTH=66656 bits> = 2.6839997657267398...x10^20065`
`GCD = 275978`

## Syntax

Result = bigint.GCD( Value )

## Return Value

Returns a BigInteger containing the greatest common divisor of bigint and Value.

## Arguments

### Value

Set this argument to either a normal IDL integer or a BigInteger.

None

# BigInteger::GetPrimes

The BigInteger::GetPrimes static method returns an unsigned integer array containing the prime numbers up to a certain maximum.

Note: The GetPrimes method will only return prime numbers up to the maximum that will fit in an unsigned 32-bit integer. For larger primes, use the NextPrime method.

## Example

`; All prime numbers up to 100.`
`result = BigInteger.GetPrimes(100, COUNT=c)`
`PRINT, "The first ", c, " primes are:"`
`PRINT, result, FORMAT='(13I4)'`

IDL prints:

`The first           25 primes are:`
`2   3   5   7  11  13  17  19  23  29  31  37  41`
`43  47  53  59  61  67  71  73  79  83  89  97`

## Syntax

Result = bigint.GetPrimes( N, COUNT=variable, /IS_INDEX )

## Return Value

An array of unsigned 32-bit integers.

## Arguments

N

An integer giving the maximum value to return. All prime numbers less than or equal to N will be included (N itself does not need to be prime).

## Keywords

### COUNT

Output variable

Returns the number of prime numbers in Result. If IS_INDEX is set then COUNT will be equal to N.

### IS_INDEX

Flag, default=0

Treat the input N as the number of prime numbers to return instead of the maximum value. In the above example, if we wanted the same result we would set N=25 and /IS_INDEX.

# BigInteger::GetProperty

You can retrieve the properties of a BigInteger using either "dot" notation or the ::GetProperty method.

## Example

`bigint = -BigInteger(2)^79 + 1`
`digits = bigint.DIGITS`
`sign = bigint.SIGN`
`; Or, using GetProperty...`
`bigint.GetProperty, DIGITS=digits, SIGN=sign`
`PRINT, digits`
`PRINT, sign`

IDL prints:

`4294967295   4294967295   32767`
`-1`

Note: BigInteger objects are immutable: You cannot set the DIGITS or SIGN properties.

## Syntax

Result = bigint.GetProperty( PROPERTY=variable )

None

## Keywords

### DIGITS

This property contains the BigInteger number as a series of unsigned 32-bit integers in base 4294967296, stored in little-endian order (largest digit at the end).

### SIGN

This property is an integer (–1, 0, or 1) that indicates whether the BigInteger number is negative, zero, or positive.

# BigInteger::Hashcode

The BigInteger::Hashcode method returns a hash code based upon the BigInteger value. The hash code is constructed by calling the Hashcode method on the DIGITS property, then taking the bitwise not operator if the BigInteger is negative.

## Example

`bigint = BigInteger(2)^1279 - 1`
`HELP, bigint.Hashcode()`

IDL prints:

`<Expression>    ULONG     =   1097148854`

## Syntax

Result = bigint.Hashcode( )

## Return Value

An integer giving the hash code based upon the BigInteger value.

None

None

# BigInteger::IsPowerOfTwo

The BigInteger::IsPowerOfTwo method tests whether the value is a power of two and returns 1 (true) or 0 (false).

## Example

`bigint = BigInteger(2)^1279`
`PRINT, bigint.IsPowerOfTwo()`

IDL prints:

`1`

## Syntax

Result = bigint.IsPowerOfTwo( )

## Return Value

Returns 1 (true) or 0 (false).

None

None

# BigInteger::IsPrime

The BigInteger::IsPrime method returns 1 (true) if the number is probably prime, or 0 (false) if the number is definitely composite. The method uses three tests in succession:

1. Division by all prime factors up to 1999.
2. The Miller-Rabin probabilistic primality test. This is an iterative test, where random numbers are used to test the primality based upon a set of equalities. The algorithm follows the pseudocode in Donald E. Knuth, The Art of Computer Programming, Vol 2: Seminumerical Algorithms, 3rd ed., Addison Wesley, 1998, section 4.5.4, algorithm P.
3. The Lucas probable prime test. This algorithm follows the pseudocode in NIST Federal Information Processing Standards 186-4: Digital Signature Standard (DSS), July 2013, downloaded from http://csrc.nist.gov/publications/PubsFIPS.html, Dec 2013, section C3.3.

If the number is less than 3996001, the first test is sufficient to guarantee that the number is prime or composite with no chance of failure. For larger numbers, if the number passes all three tests then the probability of failure is less than 2-100.

## Example

`bigint = BigInteger(2)^1279 - 1`
`PRINT, bigint.IsPrime() ? 'prime' : 'composite'`

IDL prints:

`prime`

## Syntax

Result = bigint.IsPrime( ITERATIONS=value )

## Return Value

Returns 1 if the number is probably prime, 0 if the number is composite.

None

## Keywords

### ITERATIONS

Integer >= 1

The number of iterations to perform for the Miller-Rabin primality test. Each iteration has a 1/4 chance (in the worst case) of incorrectly identifying a composite number as being prime. The default value is based upon the bit length, and is designed to give a probability of 2-100 of incorrectly identifying a composite number as prime:

 Bit length Iterations 2048+ 2 1024–2047 4 512–1023 7 256–511 16 128–255 34 64–127 44 32–63 49 <32 64

The number of iterations was computed from the formula in section F1.1 of NIST Federal Information Processing Standards 186-4: Digital Signature Standard (DSS), July 2013, downloaded from http://csrc.nist.gov/publications/PubsFIPS.html, Dec 2013.

# BigInteger::LCM

The BigInteger::LCM method computes the least common multiple (LCM) between this BigInteger and another integer. The least common multiple is the smallest integer that can be evenly divided (no remainder) by each number. By definition the LCM will always be greater than or equal to the larger of the two numbers.

## Examples

`u = BigInteger.Factorial(90)`
`   v = BigInteger.Factorial(60) + 34`
`  lcm = u.LCM(v)`
`HELP, u, v, lcm`

IDL prints:

`U               BIGINTEGER <ID=1 LENGTH=459 bits> = 1.4857159644817615...x10^138`
`V               BIGINTEGER <ID=2 LENGTH=273 bits> = 8.3209871127413901...x10^81`
`LCM         BIGINTEGER <ID=3 LENGTH=727 bits> = 3.6360657040137889...x10^218`

## Syntax

Result = bigint.LCM( Value )

## Return Value

Returns a BigInteger containing the least common multiple of bigint and Value.

## Arguments

### Value

Set this argument to either a normal IDL integer or a BigInteger.

None

# BigInteger::Log2

The BigInteger::Log2 method returns the base-2 logarithm of the number, along with an optional remainder.

Note: If the number is 0 or negative then the method throws an error.

## Example

`bigint = BigInteger.Factorial(10000)`
`PRINT, bigint.Log2(REMAINDER=rem)`
`HELP, rem`

IDL prints:

`118458`
`REM             BIGINTEGER <ID=2 LENGTH=118455 bits> = 2.6859533835705141...x10^35658`

## Syntax

Result = bigint.Log2( )

## Return Value

An integer giving the base-2 logarithm.

None

## Keywords

### REMAINDER

Output variable

Returns a BigInteger containing the remainder, equal to bigint – 2Result.

# BigInteger::Log10

The BigInteger::Log10 method returns the base-10 logarithm of the number, along with an optional remainder.

Note: If the number is 0 or negative then the method throws an error.

## Example

`bigint = BigInteger.Factorial(10000)`
`PRINT, bigint.Log10(REMAINDER=rem)`
`HELP, rem`

IDL prints:

`35659`
`REM             BIGINTEGER <ID=2 LENGTH=118458 bits> = 1.8462596809170546...x10^35659`

## Syntax

Result = bigint.Log10( )

## Return Value

An integer giving the base-10 logarithm.

None

## Keywords

### REMAINDER

Output variable

Returns a BigInteger containing the remainder, equal to bigint – 10Result.

# BigInteger::ModInverse

The BigInteger::ModInverse method computes the multiplicative inverse of the BigInteger modulo the input Modulus. In order for the inverse to exist, the BigInteger and the Modulus must be co-prime (i.e. their GCD must be 1). If the ModInverse exists then bigint*result mod Modulus = 1. The ModInverse method uses the extended Euclidean algorithm.

If the BigInteger and Modulus are not co-prime then IDL throws an error.

## Examples

`u = BigInteger.Factorial(90)`
`v = BigInteger.Factorial(60) - 1`
`r = u.ModInverse(v)`
`PRINT, r`
`PRINT, "u*r mod v = ", u*r mod v`

IDL prints:

`5398464503473793715027616372607916377802131923010621870166614886971773279155082918`
`u*r mod v = 1`

## Syntax

Result = bigint.ModInverse( Modulus )

## Return Value

Returns a BigInteger containing the multiplicative inverse of bigint and Modulus.

## Arguments

### Modulus

Set this argument to either a normal IDL integer or a BigInteger.

None

# BigInteger::ModPower

The BigInteger::ModPower method computes the modular exponentiation,

Result = bigintExponent mod Modulus

The method uses the right-to-left binary algorithm: the exponent is broken down into binary bits and the result is then the product of each power of two (if the bit is set) modulo the Modulus.

## Examples

`u = BigInteger.Random(1024)`
`v = BigInteger.Random(1024)`
`e = BigInteger(2)^1024 - 1`
`TIC & r = u.ModPower(e, v) & TOC`
`HELP, r`

IDL prints:

`% Time elapsed: 0.074999809 seconds.`
`R               BIGINTEGER <ID=1 LENGTH=1018 bits> = 2.2843081667189526...x10^306`

Note that computing this result using ue mod v would be impossible because the ue would require approximately 10308 digits of storage and take longer than the age of the universe.

## Syntax

Result = bigint.ModPower( Exponent, Modulus )

## Return Value

Returns a BigInteger containing the modular exponentiation.

## Arguments

### Exponent

Set this argument to either a normal IDL integer or a BigInteger.

### Modulus

Set this argument to either a normal IDL integer or a BigInteger.

None

# BigInteger::NextPrime

The BigInteger::NextPrime method computes the next prime number that follows this BigInteger.

The method uses an algorithm based upon the Sieve of Erastosthenes. Several thousand numbers are generated in sequence following the BigInteger value. The algorithm removes any numbers that are divisible by primes up to 997. The algorithm then tests the surviving numbers for primality and returns the first match.

The algorithm's speed is highly variable because it depends upon the gap between successive primes. See below for an example.

## Example

From Thomas R. Nicely's website (http://www.trnicely.net), the first known gap of 10000 is found after the prime number 43775*547#/1866 - 1402. Here, the "#" symbol indicates the Primorial function. We can compute this gap as well as the next gap, and the time needed for the computation:

`b = 43775*BigInteger.Primorial(547)/1866 - 1402`
`TIC & c = b.NextPrime() & TOC`
`TIC & d = c.NextPrime() & TOC`
`PRINT, 'Gap between b and c is ', c - b`
`PRINT, 'Gap between c and d is ', d - c`

IDL prints:

`% Time elapsed: 13.886000 seconds.`
`% Time elapsed: 0.32699990 seconds.`
`Gap between b and c is 10000`
`Gap between c and d is 84`

## Syntax

Result = bigint.NextPrime( )

## Return Value

Returns a BigInteger containing the next prime number.

None

None

# BigInteger::Prime

The BigInteger::Prime static constructor method returns a new BigInteger containing a random prime number with a given bit length.

## Example

`bigint = BigInteger.Prime(256)`
`PRINT, bigint`

IDL prints:

`103231891082001480830106615945373073145045889883067503900939711192099772102403`

## Syntax

Result = BigInteger.Prime( BitLength, SEED=value )

## Return Value

A new BigInteger.

## Arguments

BitLength

An integer giving the number of bits in the prime number.

## Keywords

### SEED

Integer or array

This seed will be used as the starting value for the RANDOMU function.

Note: Normally, you should never need to use the SEED keyword as BigInteger will automatically pick a new seed value each time it is called. You should only use the SEED keyword if you need to re-generate the same prime number for a given bit length.

# BigInteger::Primorial

The BigInteger::Primorial static constructor method returns a new BigInteger containing the primorial of N.

The primorial (or "prime factorial") is defined as the product of all prime numbers less than or equal to N (N may be a prime number or a composite number).

## Example

`bigint = BigInteger.Primorial(100, COUNT=c)`
`PRINT, 'product of first ', c, ' primes is ', bigint`

IDL prints:

`product of first           25 primes is 2305567963945518424753102147331756070`

## Syntax

Result = BigInteger.Primorial( N, COUNT=variable, /IS_INDEX )

## Return Value

A new BigInteger.

## Arguments

N

An integer giving the maximum value to use when computing the primorial. All prime numbers less than or equal to N will be included in the product (N itself does not need to be prime).

## Keywords

### COUNT

Output variable

Returns the number of prime numbers that were multiplied together to produce the result. If IS_INDEX is set then COUNT will just be equal to N.

### IS_INDEX

Flag, default=0

Treat the input N as the number of prime numbers to include in the primorial, instead of the maximum value. In the above example, if we wanted the same result, we would set N=25 and /IS_INDEX.

# BigInteger::Random

The BigInteger::Random static constructor method returns a new BigInteger containing a random number between 0 and the given bit length. The RANDOMU function is used to construct the random digits.

## Example

`bigint = BigInteger.Random(2048)`
`HELP, bigint`

IDL prints:

`BIGINT          BIGINTEGER <ID=1 LENGTH=2047 bits> = 1.0066318959964815...x10^616`

## Syntax

Result = BigInteger.Random( BitLength, /EXACT, SEED=value )

## Return Value

A new BigInteger.

## Arguments

BitLength

An integer giving the maximum number of bits. The result could have less bits, unless the EXACT keyword is set.

## Keywords

### EXACT

Flag, default=0

Return a BigInteger with exactly BitLength bits. In other words, the number will be between 2BitLength and 2BitLength+1 – 1. The default is to return a random number between 0 and 2BitLength+1 – 1.

### SEED

Integer or array

This seed will be used as the starting value for the RANDOMU function.

Note: Normally, you should never need to use the SEED keyword as BigInteger will automatically pick a new seed value each time it is called. You should only use the SEED keyword if you need to re-generate the same random number for a given bit length.

# BigInteger::Signum

The BigInteger::Signum method returns –1 if the number is negative, 0 if the number is zero, and 1 if the number is positive.

## Syntax

Result = bigint.Signum( )

## Return Value

Returns –1, 0, or +1.

None

None

# BigInteger::Sqrt

The BigInteger::Sqrt method uses Newton's iterative method to compute the square root of the number along with an optional remainder. If the number is negative, IDL throws an error.

## Example

`b = BigInteger.Random(2048)`
`c = b^2 + 1`
`b1 = c.Sqrt(REMAINDER=r)`
`PRINT, "sqrt(c) equals b:", b eq b1 ? "true" : "false"`
`PRINT, "remainder is ", r`

IDL prints:

`sqrt(c) equals b:   true`
`remainder is 1`

## Syntax

Result = bigint.Sqrt( REMAINDER=variable )

## Return Value

Returns a BigInteger containing the "integer" part of the square root.

None

## Keywords

### REMAINDER

Output variable

Returns a BigInteger containing the remainder, equal to bigintresult2.

# BigInteger::ToDouble

The BigInteger::ToDouble method converts the number to a double-precision value.

## Examples

Find the largest factorial that will still fit in a double:

`bigint = BigInteger.Factorial(170)`
`HELP, bigint.ToDouble()`

IDL prints:

`<Expression>    DOUBLE    =   7.2574156e+306`

Now find a huge factorial and use the optional EXPONENT keyword:

`bigint = BigInteger.Factorial(100000)`
`HELP, bigint.ToDouble(EXPONENT=exponent), exponent`

IDL prints:

`<Expression>    DOUBLE    =        2.8242294`
`EXPONENT        LONG      =       456573`

The value of 100000! is approximately 2.82x10456573.

## Syntax

Result = bigint.ToDouble( EXPONENT=variable )

## Return Value

Returns a double-precision value.

None

## Keywords

### EXPONENT

Output variable

If set, then the ToDouble method will not include the exponent in the Result, but will instead return the exponent in this variable. This allows you to convert BigIntegers that are larger than 10308 into useable pieces.

If you do not specify EXPONENT and the BigInteger is too large, then ToDouble returns Infinity.

# BigInteger::ToInteger

The BigInteger::ToInteger method converts the BigInteger to a signed 64-bit integer value. If the value is too large then IDL issues a warning and returns 0.

## Examples

The largest prime that will still fit in a 64-bit integer:

`bigint = BigInteger(2)^63`
`while (~bigint.IsPrime()) do bigint = bigint - 1`
`PRINT, bigint.ToInteger()`

IDL prints:

`9223372036854775783`

## Syntax

Result = bigint.ToInteger( )

## Return Value

Returns a 64-bit signed integer value.

None

None

# BigInteger::ToString

The BigInteger::ToString method converts the BigInteger to its string representation. By default the string is in base 10 but you can use the RADIX keyword to convert to a different base.

## Examples

`bigint = BigInteger('303117847695258070278031236')`
`PRINT, bigint.ToString()`
`PRINT, bigint.ToString(RADIX=2)`
`PRINT, bigint.ToString(RADIX=16, /UPPERCASE)`
`PRINT, bigint.ToString(RADIX=36, /UPPERCASE)`

IDL prints:

`303117847695258070278031236`
`1111101010111011101100110111001100010011100...`
`FABBB37313829F24214784`
`12345IDLISFUN67890`

## Syntax

Result = bigint.ToString( RADIX=value, /UPPERCASE )

## Return Value

Returns the string representation of the number.

None

## Keywords

Integer, 2–36, default = 10

Return the result in a different base.

### UPPERCASE

Flag, default=0

Set this keyword to return the string using uppercase letters instead of lowercase. This keyword only has an effect if RADIX is greater than 10.

### Operators

 Name Operators Operands Result Math + – * / ^ mod BigIntegers or numbers A new BigInteger Increment,Decrement ++ –– BigInteger The BigInteger is incremented or decremented Comparisons EQ, NE, GT, GE, LT, LE BigIntegers or numbers Boolean 0 or 1 Bitwise AND, NOT, OR, XOR BigIntegers or numbers A new BigInteger Min/max > < BigIntegers or numbers A new BigInteger

### Logical Truth and Negation

A BigInteger is considered "true" if the value is not zero, otherwise it is false. The "~" negation operator will return a boolean 0 if the BigInteger was nonzero, or 1 if the BigInteger was zero.

### Help and Print

The PRINT procedure will output the BigInteger value in base 10. To output to a different base you can use the ToString method.

The HELP procedure will output the BigInteger's heap ID and a shortened version of the BigInteger value.

### ISA and TYPENAME

You can use the ISA function to determine if a variable is a BigInteger:

`if ISA(bigint, "BigInteger") then ...`

You can use the TYPENAME function or the TYPENAME attribute to retrieve the class name:

`if (TYPENAME(bigint) eq "BIGINTEGER") then ...`
`if (bigint.TYPENAME eq "BIGINTEGER") then ...`

### Copying BigIntegers

If you assign a BigInteger variable to a new variable, you are creating a new reference to the same object. Since BigIntegers are immutable (the value cannot be changed) this is usually not a problem. If for some reason you must have a new object, you can use the DIGITS and SIGN properties to create a new BigInteger. For example:

`b = BigInteger(2)^1279 - 1`
`c = b`
`d = BigInteger(b.digits, SIGN=b.sign)`
`HELP, b, c, d`

IDL prints:

`B               BIGINTEGER <ID=7 LENGTH=1279 bits> = 1.0407932194664400...x10^385`
`C               BIGINTEGER <ID=7 LENGTH=1279 bits> = 1.0407932194664400...x10^385`
`D               BIGINTEGER <ID=9 LENGTH=1279 bits> = 1.0407932194664400...x10^385`

Notice that both b and c have the same heap variable ID, while d has a new heap ID.

## Version History

 8.4 Introduced