gmp_lib.mpz_export Method (void_ptr, ptr(size_t), Int32, size_t, Int32, size_t, mpz_t)

public static void_ptr mpz_export(
	void_ptr rop,
	ptr<size_t> countp,
	int order,
	size_t size,
	int endian,
	size_t nails,
	mpz_t op
)

Public Shared Function mpz_export ( 
	rop As void_ptr,
	countp As ptr(Of size_t),
	order As Integer,
	size As size_t,
	endian As Integer,
	nails As size_t,
	op As mpz_t
) As void_ptr

public:
static void_ptr mpz_export(
	void_ptr rop, 
	ptr<size_t>^ countp, 
	int order, 
	size_t size, 
	int endian, 
	size_t nails, 
	mpz_t^ op
)

static member mpz_export : 
        rop : void_ptr * 
        countp : ptr<size_t> * 
        order : int * 
        size : size_t * 
        endian : int * 
        nails : size_t * 
        op : mpz_t -> void_ptr 

Parameters

rop

Type: Math.Gmp.Nativevoid_ptr
The result integer.

countp

Type: Math.Gmp.Nativeptrsize_t
The number of words produced.

order

Type: SystemInt32
1 for most significant word first or -1 for least significant first.

size

Type: Math.Gmp.Nativesize_t
The number of bytes in each word.

endian

Type: SystemInt32
1 for most significant byte first, -1 for least significant first, or 0 for the native endianness of the host CPU.

nails

Type: Math.Gmp.Nativesize_t
The number of most significant bits to skip.

op

Type: Math.Gmp.Nativempz_t
The operand integer.

Return Value

The parameters specify the format of the data produced. Each word will be size bytes and order can be 1 for most significant word first or -1 for least significant first. Within each word endian can be 1 for most significant byte first, -1 for least significant first, or 0 for the native endianness of the host CPU. The most significant nails bits of each word are unused and set to zero, this can be 0 to produce full words.

The number of words produced is written to countp, or countp can be NULL to discard the count. rop must have enough space for the data, or if rop is NULL then a result array of the necessary size is allocated using the current GMP allocation function (see GNU MP - Custom Allocation). In either case the return value is the destination used, either rop or the allocated block.

If op is non-zero then the most significant word produced will be non-zero. If op is zero then the count returned will be zero and nothing written to rop. If rop is NULL in this case, no block is allocated, just NULL is returned.

The sign of op is ignored, just the absolute value is exported. An application can use mpz_sgn to get the sign and handle it as desired. (see GNU MP - Integer Comparisons)

There are no data alignment restrictions on rop, any address is allowed.

When an application is allocating space itself the required size can be determined with a calculation like the following. Since mpz_sizeinbase always returns at least 1, count here will be at least one, which avoids any portability problems with malloc(0), though if z is zero no space at all is actually needed (or written).

numb = 8 * size - nail;
count = (mpz_sizeinbase(z, 2) + numb - 1) / numb;
p = malloc(count * size);

Reference