1D Arrays (original) (raw)

1D Arrays

[Common]

Classes
struct Gan_BitArray
1-dimensional array of bits More...
Defines
#define GAN_ARRAY_TYPE unsigned char
#define GAN_ARRAY_TYPE short
#define GAN_ARRAY_TYPE unsigned short
#define GAN_ARRAY_TYPE int
#define GAN_ARRAY_TYPE unsigned int
#define GAN_ARRAY_TYPE long
#define GAN_ARRAY_TYPE unsigned long
#define GAN_ARRAY_TYPE float
#define GAN_ARRAY_TYPE double
#define GAN_ARRAY_TYPE void *
#define GAN_ARRAY_FILLFUNC gan_fill_array_uc
#define GAN_ARRAY_FILLFUNC gan_fill_array_s
#define GAN_ARRAY_FILLFUNC gan_fill_array_us
#define GAN_ARRAY_FILLFUNC gan_fill_array_i
#define GAN_ARRAY_FILLFUNC gan_fill_array_ui
#define GAN_ARRAY_FILLFUNC gan_fill_array_l
#define GAN_ARRAY_FILLFUNC gan_fill_array_ul
#define GAN_ARRAY_FILLFUNC gan_fill_array_f
#define GAN_ARRAY_FILLFUNC gan_fill_array_d
#define GAN_ARRAY_FILLFUNC gan_fill_array_p
#define GAN_ARRAY_COPYFUNC gan_copy_array_uc
#define GAN_ARRAY_COPYFUNC gan_copy_array_s
#define GAN_ARRAY_COPYFUNC gan_copy_array_us
#define GAN_ARRAY_COPYFUNC gan_copy_array_i
#define GAN_ARRAY_COPYFUNC gan_copy_array_ui
#define GAN_ARRAY_COPYFUNC gan_copy_array_l
#define GAN_ARRAY_COPYFUNC gan_copy_array_ul
#define GAN_ARRAY_COPYFUNC gan_copy_array_f
#define GAN_ARRAY_COPYFUNC gan_copy_array_d
#define GAN_ARRAY_COPYFUNC gan_copy_array_p
#define GAN_FILL_DEC(t, f) void gan_fill_array_ ## f ( t *arr, unsigned long size, long stride, t val )
#define GAN_COPY_DEC(c, t)
#define GAN_BITWORD_SIZE 32
#define GAN_BITWORD_FULL (gan_uint32) GAN_UINT32_MAX
#define GAN_MSB_SET (gan_uint32) (1<<31)
#define GAN_LSB_SET (gan_uint32) 1
Typedefs
typedef gan_uint32 Gan_BitWord
32-bit word
typedef Gan_BitArray Gan_BitArray
1-dimensional array of bits
Enumerations
enum Gan_Alignment { GAN_WORD_ALIGNMENT, GAN_BYTE_ALIGNMENT, GAN_BIT_ALIGNMENT }
Alignment options when computing bounds of a bit array.
Functions
void gan_fill_array_uc (unsigned char *arr, unsigned long size, long stride, unsigned char val)
Fill array of objects.
void gan_copy_array_uc (const unsigned char *source, long s_stride, unsigned long size, unsigned char *dest, long d_stride)
Copy array of objects. Copy source array of objects of type #unsigned char to dest array. The stride arguments indicate the spacing between elements of the arrays.
void gan_fill_array_s (short *arr, unsigned long size, long stride, short val)
Fill array of objects.
void gan_copy_array_s (const short *source, long s_stride, unsigned long size, short *dest, long d_stride)
Copy array of objects. Copy source array of objects of type #short to dest array. The stride arguments indicate the spacing between elements of the arrays.
void gan_fill_array_us (unsigned short *arr, unsigned long size, long stride, unsigned short val)
Fill array of objects.
void gan_copy_array_us (const unsigned short *source, long s_stride, unsigned long size, unsigned short *dest, long d_stride)
Copy array of objects. Copy source array of objects of type #unsigned short to dest array. The stride arguments indicate the spacing between elements of the arrays.
void gan_fill_array_i (int *arr, unsigned long size, long stride, int val)
Fill array of objects.
void gan_copy_array_i (const int *source, long s_stride, unsigned long size, int *dest, long d_stride)
Copy array of objects. Copy source array of objects of type #int to dest array. The stride arguments indicate the spacing between elements of the arrays.
void gan_fill_array_ui (unsigned int *arr, unsigned long size, long stride, unsigned int val)
Fill array of objects.
void gan_copy_array_ui (const unsigned int *source, long s_stride, unsigned long size, unsigned int *dest, long d_stride)
Copy array of objects. Copy source array of objects of type #unsigned int to dest array. The stride arguments indicate the spacing between elements of the arrays.
void gan_fill_array_l (long *arr, unsigned long size, long stride, long val)
Fill array of objects.
void gan_copy_array_l (const long *source, long s_stride, unsigned long size, long *dest, long d_stride)
Copy array of objects. Copy source array of objects of type #long to dest array. The stride arguments indicate the spacing between elements of the arrays.
void gan_fill_array_ul (unsigned long *arr, unsigned long size, long stride, unsigned long val)
Fill array of objects.
void gan_copy_array_ul (const unsigned long *source, long s_stride, unsigned long size, unsigned long *dest, long d_stride)
Copy array of objects. Copy source array of objects of type #unsigned long to dest array. The stride arguments indicate the spacing between elements of the arrays.
void gan_fill_array_f (float *arr, unsigned long size, long stride, float val)
Fill array of objects.
void gan_copy_array_f (const float *source, long s_stride, unsigned long size, float *dest, long d_stride)
Copy array of objects. Copy source array of objects of type #float to dest array. The stride arguments indicate the spacing between elements of the arrays.
void gan_fill_array_d (double *arr, unsigned long size, long stride, double val)
Fill array of objects.
void gan_copy_array_d (const double *source, long s_stride, unsigned long size, double *dest, long d_stride)
Copy array of objects. Copy source array of objects of type #double to dest array. The stride arguments indicate the spacing between elements of the arrays.
void gan_fill_array_p (void **arr, unsigned long size, long stride, void *val)
Fill array of objects.
void gan_copy_array_p (const void **source, long s_stride, unsigned long size, void **dest, long d_stride)
Copy array of objects. Copy source array of objects of type #void * to dest array. The stride arguments indicate the spacing between elements of the arrays.
GAN_FILL_DEC (unsigned char, uc)
GAN_FILL_DEC (short, s)
GAN_FILL_DEC (unsigned short, us)
GAN_FILL_DEC (int, i)
GAN_FILL_DEC (unsigned int, ui)
GAN_FILL_DEC (long, l)
GAN_FILL_DEC (unsigned long, ul)
GAN_FILL_DEC (double, d)
GAN_FILL_DEC (float, f)
GAN_FILL_DEC (void *, p)
GAN_COPY_DEC (c, char)
GAN_COPY_DEC (uc, unsigned char)
GAN_COPY_DEC (s, short)
GAN_COPY_DEC (us, unsigned short)
GAN_COPY_DEC (i, int)
GAN_COPY_DEC (ui, unsigned int)
GAN_COPY_DEC (l, long)
GAN_COPY_DEC (ul, unsigned long)
GAN_COPY_DEC (f, float)
GAN_COPY_DEC (d, double)
GAN_COPY_DEC (p, void *)
GAN_FILL_DEC (gan_uint8, ui8)
Fill array of 8-bit unsigned integer objects.
GAN_COPY_DEC (ui8, gan_uint8)
Copy array of 8-bit unsigned integer objects. Copy source array of objects of type #gan_uint8 to dest array. The stride arguments indicate the spacing between elements of the arrays.
GAN_FILL_DEC (gan_uint16, ui16)
Fill array of 16-bit unsigned integer objects.
GAN_COPY_DEC (ui16, gan_uint16)
Copy array of 16-bit unsigned integer objects. Copy source array of objects of type #gan_uint16 to dest array. The stride arguments indicate the spacing between elements of the arrays.
GAN_FILL_DEC (gan_uint32, ui32)
Fill array of 32-bit unsigned integer objects.
GAN_COPY_DEC (ui32, gan_uint32)
Copy array of 32-bit unsigned integer objects. Copy source array of objects of type #gan_uint32 to dest array. The stride arguments indicate the spacing between elements of the arrays.
GAN_FILL_DEC (gan_int32, i32)
Fill array of 32-bit signed integer objects.
GAN_COPY_DEC (i32, gan_int32)
Copy array of 32-bit unsigned integer objects. Copy source array of objects of type #gan_int32 to dest array. The stride arguments indicate the spacing between elements of the arrays.
GAN_FILL_DEC (gan_ui64, ui64)
Fill array of 64-bit unsigned integer objects.
GAN_COPY_DEC (ui64, gan_ui64)
Copy array of 64-bit unsigned integer objects. Copy source array of objects of type #gan_ui64 to dest array. The stride arguments indicate the spacing between elements of the arrays.
GAN_FILL_DEC (gan_float32, f32)
Fill array of 32-bit floating point objects.
GAN_COPY_DEC (f32, gan_float32)
Copy array of 32-bit floating point objects. Copy source array of objects of type #gan_float32 to dest array. The stride arguments indicate the spacing between elements of the arrays.
GAN_FILL_DEC (gan_float64, f64)
Fill array of 64-bit floating point objects.
GAN_COPY_DEC (f64, gan_float64)
Copy array of 64-bit floating point objects. Copy source array of objects of type #gan_float64 to dest array. The stride arguments indicate the spacing between elements of the arrays.
Gan_BitArray * gan_bit_array_form_data (Gan_BitArray *ba, Gan_BitWord *data, unsigned data_words, unsigned int no_bits)
Form new bit array using pre-allocated data array.
Gan_BitArray * gan_bit_array_ms_form (Gan_MemoryStack *ms, Gan_BitArray *ba, unsigned int no_bits)
Form new bit array using stack memory style memory allocation.
Gan_Bool gan_bit_array_set_size (Gan_BitArray *ba, unsigned int no_bits)
Reset size of existing bit array.
void gan_bit_array_free (Gan_BitArray *ba)
Free bit array.
void gan_bit_array_free_va (Gan_BitArray *ba,...)
Free NULL terminated list of bit arrays.
Gan_Bool gan_bit_array_fill (Gan_BitArray *ba, Gan_Bool val)
Set all bits in a bit array.
Gan_Bool gan_bit_array_invert_i (Gan_BitArray *ba)
Invert all the bits in a bit array.
Gan_BitArray * gan_bit_array_invert_s (const Gan_BitArray *ba)
Invert all the bits in a bit array.
Gan_Bool gan_bit_array_and_i (Gan_BitArray *ba_dst, const Gan_BitArray *ba)
Perform binary AND operation between two bit arrays.
Gan_Bool gan_bit_array_nand_i (Gan_BitArray *ba_dst, const Gan_BitArray *ba)
Perform binary NAND (not and) operation between bit arrays.
Gan_Bool gan_bit_array_or_i (Gan_BitArray *ba_dst, const Gan_BitArray *ba)
Gan_Bool gan_bit_array_eor_i (Gan_BitArray *ba_dst, const Gan_BitArray *ba)
Gan_Bool gan_bit_array_andnot_i (Gan_BitArray *ba_dst, const Gan_BitArray *ba)
Perform binary AND-NOT operation between bit arrays.
Gan_BitArray * gan_bit_array_and_s (const Gan_BitArray *ba1, const Gan_BitArray *ba2)
Gan_BitArray * gan_bit_array_nand_s (const Gan_BitArray *ba1, const Gan_BitArray *ba2)
Gan_BitArray * gan_bit_array_or_s (const Gan_BitArray *ba1, const Gan_BitArray *ba2)
Gan_BitArray * gan_bit_array_eor_s (const Gan_BitArray *ba1, const Gan_BitArray *ba2)
Gan_BitArray * gan_bit_array_andnot_s (const Gan_BitArray *ba1, const Gan_BitArray *ba2)
Gan_Bool gan_bit_array_insert (const Gan_BitArray *src, unsigned int offset_src, Gan_BitArray *dst, unsigned int offset_dst, unsigned int no_bits)
Insert part of one bit array in another.
Gan_Bool gan_bit_array_copy_q (const Gan_BitArray *ba_source, Gan_BitArray *ba_dest)
Copy one bit array to another.
Gan_BitArray * gan_bit_array_copy_s (const Gan_BitArray *ba_source)
Return a copy of a bit array.
Gan_BitArray * gan_bit_array_expand_q (const Gan_BitArray *ba, const Gan_BitArray *ref_ba, Gan_BitArray *exp_ba)
Expand bit array by padding it with zeros in a reference bit array.
Gan_BitArray * gan_bit_array_expand_s (const Gan_BitArray *ba, const Gan_BitArray *ref_ba)
Expand bit array by padding it with zeros in a reference bit array.
Gan_Bool gan_bit_array_dilate_q (Gan_BitArray *ba_source, unsigned int no_bits, Gan_BitArray *ba_dest)
Dilate bit array and write result into another.
Gan_BitArray * gan_bit_array_dilate_s (Gan_BitArray *ba, unsigned int no_bits)
Dilate bit array in-place.
Gan_Bool gan_bit_array_shift_q (Gan_BitArray *ba_source, int no_bits, Gan_BitArray *ba_dest)
Shift bit array and write result into another.
Gan_BitArray * gan_bit_array_shift_s (Gan_BitArray *ba, int no_bits)
Shift bit array in-place.
unsigned int gan_bit_array_get_first_set_bit (Gan_BitArray *ba)
Get the first set bit in a bit array.
Gan_Bool gan_bit_array_fill_part (Gan_BitArray *ba, unsigned int offset, unsigned int no_bits, Gan_Bool val)
Fill part of a bit array.
Gan_Bool gan_bit_array_invert_part (Gan_BitArray *ba, unsigned int offset, unsigned int no_bits)
Invert part of a bit array.
void gan_bit_array_fprint (FILE *fp, const Gan_BitArray *ba, int indent)
Print bit array in ASCII to file.
unsigned GAN_NO_BITWORDS (unsigned no_bits)
Macro: Number of bit-words given number of bits.
Gan_BitArray * gan_bit_array_form (Gan_BitArray *ba, unsigned int no_bits)
Macro: Form bit array.
Gan_BitArray * gan_bit_array_alloc (unsigned int no_bits)
Macro: Allocate new bit array.
Gan_BitArray * gan_bit_array_ms_malloc (unsigned int no_bits)
Macro: Allocate new bit array using stack-style memory allocation.
Gan_Bool gan_bit_array_print (const Gan_BitArray *bit_array, int indent)
Macro: Print bit array in ASCII to standard output.
Gan_Bool gan_bit_array_set_bit (Gan_BitArray *bit_array, int pos)
Macro: Set bit in bit list to 1 (true).
Gan_Bool gan_bit_array_get_bit (const Gan_BitArray *bit_array, int pos)
Macro: get bit of bit array.
Gan_Bool gan_bit_array_clear_bit (Gan_BitArray *bit_array, int pos)
Macro: clear bit in bit list to 0 (false).
Gan_Bool gan_bit_array_twiddle_bit (Gan_BitArray *bit_array, int pos, Gan_Bool val)
Macro: set/clear bit depending on Boolean argument.
Gan_Bool gan_bit_array_invert_bit (Gan_BitArray *bit_array, int pos)
Macro: Invert bit.
Gan_Bool * gan_bit_array_dilate_i (Gan_BitArray *ba, unsigned int no_pixels)
Macro: Dilate bit array.

Define Documentation

#define GAN_COPY_DEC ( c,
t )

| | **Value:**void\ gan_copy_array_ ## c ( const t *source, long s_stride, unsigned long size,\ t *dest, long d_stride ) | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |

Function Documentation

| | Perform binary AND operation between two bit arrays. Returns:GAN_TRUE on success, GAN_FALSE on failure.Perform binary AND operation between bit arrays ba and ba_dst, writing the result into ba_dst. | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Perform binary AND operation between bit arrays. **Returns:**The result as a new bit array.Perform binary AND operation between bit arrays ba1 and ba2, returning the result as a new bit array. | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Perform binary AND-NOT operation between bit arrays. Returns:GAN_TRUE on success, GAN_FALSE on failure.Perform binary AND-NOT operation between bit arrays ba and ba_dst, writing the result into ba_dst. | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Perform binary AND-NOT operation between bit arrays. **Returns:**The result as a new bit array.Perform binary AND-NOT operation between bit arrays ba1 and ba2, returning the result as a new bit array. | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Copy one bit array to another. Returns:GAN_TRUE on success, GAN_FALSE on failure.Copy bit array ba_source to ba_dest. | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |

| | Return a copy of a bit array. **Returns:**A new copy of the bit array ba_source.Return a copy of bit array ba_source. | | ------------------------------------------------------------------------------------------------------------------------------ |

| | Macro: Dilate bit array. Parameters: ba Bit array no_pixels Number of pixels to dilate bit array Returns:GAN_TRUE on success, GAN_FALSE on failure.Dilate input bit array ba by no_pixels, and write result in-place into ba. | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |

| | Dilate bit array and write result into another. Parameters: ba_source Input bit array no_bits Number of bits to dilate bit array ba_dest Result bit array Returns:GAN_TRUE on success, GAN_FALSE on failure.Dilate input bit array ba_source by no_bits, and write result into another bit array ba_dest. | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Dilate bit array in-place. Parameters: ba Input bit array no_bits Number of bits to dilate bit array Returns:GAN_TRUE on success, GAN_FALSE on failure.Dilate input bit array ba by no_bits in-place. | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Perform binary EOR (exclusive or) operation between bit arrays. Returns:GAN_TRUE on success, GAN_FALSE on failure.Perform binary EOR (exclusive or) operation between bit arrays ba and ba_dst, writing the result into ba_dst. | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |

| | Perform binary EOR (exclusive or) operation between bit arrays. **Returns:**The result as a new bit array.Perform binary EOR (exclusive or) operation between bit arrays ba1 and ba2, returning the result as a new bit array. | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Expand bit array by padding it with zeros in a reference bit array. Parameters: ba Input bit array ref_ba Reference bit array specifying padded bits exp_ba Expanded bit array or NULL. Returns:GAN_TRUE on success, GAN_FALSE on failure.Expand bit array ba by padding it with zeros in a reference bit array ref_ba. | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Expand bit array by padding it with zeros in a reference bit array. Parameters: ba Input bit array ref_ba Reference bit array specifying padded bits **Returns:**Expanded bit array as a new bit array, or NULL on failure.Expand bit array ba by padding it with zeros in a reference bit array ref_ba. | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Set all bits in a bit array. Returns:GAN_TRUE on success, GAN_FALSE on failure.Set all bits in bit array ba to the given boolean value val. | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Fill part of a bit array. Returns:GAN_TRUE on success, GAN_FALSE on failure.Fill part of a bit array, specified by the start point offset and the given number of bits no_bits. The part is filled with the given boolean value val. | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Form new bit array using pre-allocated data array. Parameters: ba Existing bit array or NULL data Block of memory to use for bit array data_words Number of words in data array no_bits Number of bits in bit array **Returns:**Formed bit array, or NULL on error.Form new bit array of size no_bits using pre-allocated data array data. If data is not NULL, the number of data_words must be enough to store no_bits bits. | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Free NULL terminated list of bit arrays. **Returns:**No value.Free list of bit arrays starting with ba and terminated with NULL. | | ------------------------------------------------------------------------------------------------------------------------------------- |

unsigned int gan_bit_array_get_first_set_bit ( Gan_BitArray * ba )

| | Get the first set bit in a bit array. **Returns:**The bit that is set or UINT_MAX if all are zero | | ----------------------------------------------------------------------------------------------------- |

| | Insert part of one bit array in another. Parameters: src Source bit array offset_src Offset of start of insertion region in src dst Destination bit array offset_dst Offset of start of insertion region in dst no_bits Number of bits to insert Returns:GAN_TRUE on success, GAN_FALSE on failure.Insert part of bit array src in bit array dst | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Invert all the bits in a bit array. Returns:GAN_TRUE on success, GAN_FALSE on failure.Invert all the bits in a bit array ba. | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Invert part of a bit array. Returns:GAN_TRUE on success, GAN_FALSE on failure.Invert part of a bit array, specified by the start point offset and the given number of bits no_bits. | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Invert all the bits in a bit array. **Returns:**A new inverted bit array.Invert all the bits in a bit array ba, returning the result as anew bit array. | | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |

| | Form new bit array using stack memory style memory allocation. Parameters: ms Pointer to memory stack structure ba Existing bit array or NULL no_bits Number of bits in bit array **Returns:**Formed bit array, or NULL on error.Form new bit array of size no_bits using stack-style memory allocation. | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Perform binary NAND (not and) operation between bit arrays. Returns:GAN_TRUE on success, GAN_FALSE on failure.Perform binary NAND (not and) operation between bit arrays ba and ba_dst, writing the result into ba_dst. | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Perform binary NAND (not and) operation between bit arrays. **Returns:**The result as a new bit array.Perform binary NAND (not and) operation between bit arrays ba1 and ba2, returning the result as a new bit array. | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Perform binary OR operation between bit arrays. Returns:GAN_TRUE on success, GAN_FALSE on failure.Perform binary OR operation between bit arrays ba and ba_dst, writing the result into ba_dst. | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Perform binary OR operation between bit arrays. **Returns:**The result as a new bit array.Perform binary OR operation between bit arrays ba1 and ba2, returning the result as a new bit array. | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Macro: Print bit array in ASCII to standard output. Print bit array in ASCII to standard output. Implemented as a macro call to gan_bit_array_fprint(). | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Reset size of existing bit array. Returns:GAN_TRUE on success, GAN_FALSE on failure.Reset size of existing bit array ba to no_bits. | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Shift bit array and write result into another. Parameters: ba_source Input bit array no_bits Number of bits to shift bit array ba_dest Result bit array Returns:GAN_TRUE on success, GAN_FALSE on failure.Shift input bit array ba_source by no_bits, and write result into another bit array ba_dest. If no_bits is >= 0, the shift is towards the end of the bit array, and vice veraa. | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

| | Shift bit array in-place. Parameters: ba Input bit array no_bits Number of bits to shift bit array Returns:GAN_TRUE on success, GAN_FALSE on failure.Shift input bit array ba by no_bits in-place. If no_bits is >= 0, the shift is towards the end of the bit array, and vice veraa. | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

void gan_copy_array_d ( const double * source,
long s_stride,
unsigned long size,
double * dest,
long d_stride
)

| | Copy array of objects. Copy source array of objects of type #double to dest array. The stride arguments indicate the spacing between elements of the arrays. **Returns:**No value. | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

void gan_copy_array_f ( const float * source,
long s_stride,
unsigned long size,
float * dest,
long d_stride
)

| | Copy array of objects. Copy source array of objects of type #float to dest array. The stride arguments indicate the spacing between elements of the arrays. **Returns:**No value. | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

void gan_copy_array_i ( const int * source,
long s_stride,
unsigned long size,
int * dest,
long d_stride
)

| | Copy array of objects. Copy source array of objects of type #int to dest array. The stride arguments indicate the spacing between elements of the arrays. **Returns:**No value. | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

void gan_copy_array_l ( const long * source,
long s_stride,
unsigned long size,
long * dest,
long d_stride
)

| | Copy array of objects. Copy source array of objects of type #long to dest array. The stride arguments indicate the spacing between elements of the arrays. **Returns:**No value. | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

void gan_copy_array_p ( const void ** source,
long s_stride,
unsigned long size,
void ** dest,
long d_stride
)

| | Copy array of objects. Copy source array of objects of type #void * to dest array. The stride arguments indicate the spacing between elements of the arrays. **Returns:**No value. | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |

void gan_copy_array_s ( const short * source,
long s_stride,
unsigned long size,
short * dest,
long d_stride
)

| | Copy array of objects. Copy source array of objects of type #short to dest array. The stride arguments indicate the spacing between elements of the arrays. **Returns:**No value. | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

void gan_copy_array_uc ( const unsigned char * source,
long s_stride,
unsigned long size,
unsigned char * dest,
long d_stride
)

| | Copy array of objects. Copy source array of objects of type #unsigned char to dest array. The stride arguments indicate the spacing between elements of the arrays. **Returns:**No value. | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |

void gan_copy_array_ui ( const unsigned int * source,
long s_stride,
unsigned long size,
unsigned int * dest,
long d_stride
)

| | Copy array of objects. Copy source array of objects of type #unsigned int to dest array. The stride arguments indicate the spacing between elements of the arrays. **Returns:**No value. | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

void gan_copy_array_ul ( const unsigned long * source,
long s_stride,
unsigned long size,
unsigned long * dest,
long d_stride
)

| | Copy array of objects. Copy source array of objects of type #unsigned long to dest array. The stride arguments indicate the spacing between elements of the arrays. **Returns:**No value. | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |

void gan_copy_array_us ( const unsigned short * source,
long s_stride,
unsigned long size,
unsigned short * dest,
long d_stride
)

| | Copy array of objects. Copy source array of objects of type #unsigned short to dest array. The stride arguments indicate the spacing between elements of the arrays. **Returns:**No value. | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

GAN_COPY_DEC ( f64 ,
gan_float64
)

| | Copy array of 64-bit floating point objects. Copy source array of objects of type #gan_float64 to dest array. The stride arguments indicate the spacing between elements of the arrays. **Returns:**No value. | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

GAN_COPY_DEC ( f32 ,
gan_float32
)

| | Copy array of 32-bit floating point objects. Copy source array of objects of type #gan_float32 to dest array. The stride arguments indicate the spacing between elements of the arrays. **Returns:**No value. | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

GAN_COPY_DEC ( ui64 ,
gan_ui64
)

| | Copy array of 64-bit unsigned integer objects. Copy source array of objects of type #gan_ui64 to dest array. The stride arguments indicate the spacing between elements of the arrays. **Returns:**No value. | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

GAN_COPY_DEC ( i32 ,
gan_int32
)

| | Copy array of 32-bit unsigned integer objects. Copy source array of objects of type #gan_int32 to dest array. The stride arguments indicate the spacing between elements of the arrays. **Returns:**No value. | | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

GAN_COPY_DEC ( ui32 ,
gan_uint32
)

| | Copy array of 32-bit unsigned integer objects. Copy source array of objects of type #gan_uint32 to dest array. The stride arguments indicate the spacing between elements of the arrays. **Returns:**No value. | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

GAN_COPY_DEC ( ui16 ,
gan_uint16
)

| | Copy array of 16-bit unsigned integer objects. Copy source array of objects of type #gan_uint16 to dest array. The stride arguments indicate the spacing between elements of the arrays. **Returns:**No value. | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

GAN_COPY_DEC ( ui8 ,
gan_uint8
)

| | Copy array of 8-bit unsigned integer objects. Copy source array of objects of type #gan_uint8 to dest array. The stride arguments indicate the spacing between elements of the arrays. **Returns:**No value. | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

void gan_fill_array_d ( double * arr,
unsigned long size,
long stride,
double val
)

| | Fill array of objects. **Returns:**No value.Fill array arr of objects of type #double with a constant value val. | | ----------------------------------------------------------------------------------------------------------------------- |

void gan_fill_array_f ( float * arr,
unsigned long size,
long stride,
float val
)

| | Fill array of objects. **Returns:**No value.Fill array arr of objects of type #float with a constant value val. | | ---------------------------------------------------------------------------------------------------------------------- |

void gan_fill_array_i ( int * arr,
unsigned long size,
long stride,
int val
)

| | Fill array of objects. **Returns:**No value.Fill array arr of objects of type #int with a constant value val. | | -------------------------------------------------------------------------------------------------------------------- |

void gan_fill_array_l ( long * arr,
unsigned long size,
long stride,
long val
)

| | Fill array of objects. **Returns:**No value.Fill array arr of objects of type #long with a constant value val. | | --------------------------------------------------------------------------------------------------------------------- |

void gan_fill_array_p ( void ** arr,
unsigned long size,
long stride,
void * val
)

| | Fill array of objects. **Returns:**No value.Fill array arr of objects of type #void * with a constant value val. | | ------------------------------------------------------------------------------------------------------------------------ |

void gan_fill_array_s ( short * arr,
unsigned long size,
long stride,
short val
)

| | Fill array of objects. **Returns:**No value.Fill array arr of objects of type #short with a constant value val. | | ---------------------------------------------------------------------------------------------------------------------- |

void gan_fill_array_uc ( unsigned char * arr,
unsigned long size,
long stride,
unsigned char val
)

| | Fill array of objects. **Returns:**No value.Fill array arr of objects of type #unsigned char with a constant value val. | | ------------------------------------------------------------------------------------------------------------------------------ |

void gan_fill_array_ui ( unsigned int * arr,
unsigned long size,
long stride,
unsigned int val
)

| | Fill array of objects. **Returns:**No value.Fill array arr of objects of type #unsigned int with a constant value val. | | ----------------------------------------------------------------------------------------------------------------------------- |

void gan_fill_array_ul ( unsigned long * arr,
unsigned long size,
long stride,
unsigned long val
)

| | Fill array of objects. **Returns:**No value.Fill array arr of objects of type #unsigned long with a constant value val. | | ------------------------------------------------------------------------------------------------------------------------------ |

void gan_fill_array_us ( unsigned short * arr,
unsigned long size,
long stride,
unsigned short val
)

| | Fill array of objects. **Returns:**No value.Fill array arr of objects of type #unsigned short with a constant value val. | | ------------------------------------------------------------------------------------------------------------------------------- |

GAN_FILL_DEC ( gan_float64 ,
f64
)

| | Fill array of 64-bit floating point objects. **Returns:**No value.Fill array arr of objects of type #gan_float64 with a constant value val. | | --------------------------------------------------------------------------------------------------------------------------------------------------- |

GAN_FILL_DEC ( gan_float32 ,
f32
)

| | Fill array of 32-bit floating point objects. **Returns:**No value.Fill array arr of objects of type #gan_float32 with a constant value val. | | --------------------------------------------------------------------------------------------------------------------------------------------------- |

GAN_FILL_DEC ( gan_ui64 ,
ui64
)

| | Fill array of 64-bit unsigned integer objects. **Returns:**No value.Fill array arr of objects of type #gan_ui64 with a constant value val. | | -------------------------------------------------------------------------------------------------------------------------------------------------- |

GAN_FILL_DEC ( gan_int32 ,
i32
)

| | Fill array of 32-bit signed integer objects. **Returns:**No value.Fill array arr of objects of type #gan_int32 with a constant value val. | | ------------------------------------------------------------------------------------------------------------------------------------------------- |

GAN_FILL_DEC ( gan_uint32 ,
ui32
)

| | Fill array of 32-bit unsigned integer objects. **Returns:**No value.Fill array arr of objects of type #gan_uint32 with a constant value val. | | ---------------------------------------------------------------------------------------------------------------------------------------------------- |

GAN_FILL_DEC ( gan_uint16 ,
ui16
)

| | Fill array of 16-bit unsigned integer objects. **Returns:**No value.Fill array arr of objects of type #gan_uint16 with a constant value val. | | ---------------------------------------------------------------------------------------------------------------------------------------------------- |

GAN_FILL_DEC ( gan_uint8 ,
ui8
)

| | Fill array of 8-bit unsigned integer objects. **Returns:**No value.Fill array arr of objects of type #gan_uint8 with a constant value val. | | -------------------------------------------------------------------------------------------------------------------------------------------------- |

Generated on Fri Mar 17 12:44:53 2006 by doxygen 1.3.9.1