Index: unk/psLib/src/collections/psArray.c =================================================================== --- /trunk/psLib/src/collections/psArray.c (revision 649) +++ (revision ) @@ -1,239 +1,0 @@ -/** @file psArray.c - * - * @brief Contains support for array types - * - * This file defines basic types of one dimensional arrays which include: int, float, double, complex float, and - * void **. - * - * @author Ross Harman, MHPCC - * - * @version $Revision: 1.7 $ $Name: not supported by cvs2svn $ - * @date $Date: 2004-05-05 20:43:22 $ - * - * Copyright 2004 Maui High Performance Computing Center, University of Hawaii - */ - -/******************************************************************************/ -/* INCLUDE FILES */ -/******************************************************************************/ -#include "psMemory.h" -#include "psArray.h" - -/******************************************************************************/ -/* DEFINE STATEMENTS */ -/******************************************************************************/ - -// None - -/******************************************************************************/ -/* TYPE DEFINITIONS */ -/******************************************************************************/ - -// None - -/*****************************************************************************/ -/* GLOBAL VARIABLES */ -/*****************************************************************************/ - -// None - -/*****************************************************************************/ -/* FILE STATIC VARIABLES */ -/*****************************************************************************/ - -// None - -/*****************************************************************************/ -/* FUNCTION IMPLEMENTATION - LOCAL */ -/*****************************************************************************/ - -static void* p_psArrayAlloc(psArray *restrict psArr, psElemType elemType, int nalloc, int elemSize) -{ - void *arr = NULL; - - psArr->type.dimen = PS_DIMEN_VECTOR; - psArr->type.type = elemType; - psArr->nalloc = nalloc; - psArr->n = 0; - - if(nalloc != 0) { - arr = psAlloc(nalloc*sizeof(elemSize)); - } - - return arr; -} - -static void* p_psArrayRealloc(psArray *restrict psArr, void *arr, int nalloc, int elemSize) -{ - // For decrease in psArray size - if(nalloc < psArr->n) { - psArr->n = nalloc; - } - - psArr->nalloc = nalloc; - - return psRealloc(arr, nalloc*elemSize); -} - -/*****************************************************************************/ -/* FUNCTION IMPLEMENTATION - PUBLIC */ -/*****************************************************************************/ -psArray* psIntArrayAlloc(int nalloc) -{ - psArray *psArr = NULL; - psArr = psAlloc(sizeof(psArray)); - psArr->arr.intArr = (int*)p_psArrayAlloc(psArr, PS_TYPE_INT, nalloc, sizeof(int)); - return psArr; -} - -psArray *psIntArrayRealloc(psArray *restrict psArr, int nalloc) -{ - if(psArr == NULL) { // For creating new psArray with realloc - psArr = psIntArrayAlloc(nalloc); - } else if(psArr->nalloc != nalloc) { // No need to realloc to same size - psArr->arr.intArr = p_psArrayRealloc(psArr, psArr->arr.intArr, nalloc, sizeof(int)); - } - - return psArr; -} - -void psIntArrayFree(psArray *restrict psArr) -{ - if (psArr == NULL) { - return; - } - - psFree(psArr->arr.intArr); - psFree(psArr); -} - -psArray* psFloatArrayAlloc(int nalloc) -{ - psArray *psArr = NULL; - psArr = psAlloc(sizeof(psArray)); - psArr->arr.fltArr = (float*)p_psArrayAlloc(psArr, PS_TYPE_FLOAT, nalloc, sizeof(float)); - return psArr; -} - -psArray *psFloatArrayRealloc(psArray *restrict psArr, int nalloc) -{ - if(psArr == NULL) { // For creating new psArray with realloc - psArr = psFloatArrayAlloc(nalloc); - } else if(psArr->nalloc != nalloc) { // No need to realloc to same size - psArr->arr.fltArr = p_psArrayRealloc(psArr, psArr->arr.fltArr, nalloc, sizeof(float)); - } - - return psArr; -} - -void psFloatArrayFree(psArray *restrict psArr) -{ - if (psArr == NULL) { - return; - } - psFree(psArr->arr.fltArr); - psFree(psArr); -} - -psArray* psDoubleArrayAlloc(int nalloc) -{ - psArray *psArr = NULL; - psArr = psAlloc(sizeof(psArray)); - psArr->arr.dblArr = (double*)p_psArrayAlloc(psArr, PS_TYPE_DOUBLE, nalloc, sizeof(double)); - return psArr; -} - -psArray *psDoubleArrayRealloc(psArray *restrict psArr, int nalloc) -{ - if(psArr == NULL) { // For creating new psArray with realloc - psArr = psDoubleArrayAlloc(nalloc); - } else if(psArr->nalloc != nalloc) { // No need to realloc to same size - psArr->arr.dblArr = p_psArrayRealloc(psArr, psArr->arr.dblArr, nalloc, sizeof(double)); - } - - return psArr; -} - -void psDoubleArrayFree(psArray *restrict psArr) -{ - if (psArr == NULL) { - return; - } - psFree(psArr->arr.dblArr); - psFree(psArr); -} - -psArray* psComplexArrayAlloc(int nalloc) -{ - psArray *psArr = NULL; - psArr = psAlloc(sizeof(psArray)); - psArr->arr.cFltArr = (complex float*)p_psArrayAlloc(psArr, PS_TYPE_COMPLEX, nalloc, sizeof(complex float)); - return psArr; -} - -psArray *psComplexArrayRealloc(psArray *restrict psArr, int nalloc) -{ - if(psArr == NULL) { // For creating new psArray with realloc - psArr = psComplexArrayAlloc(nalloc); - } else if(psArr->nalloc != nalloc) { // No need to realloc to same size - psArr->arr.cFltArr = p_psArrayRealloc(psArr, psArr->arr.cFltArr, nalloc, sizeof(complex float)); - } - - return psArr; -} - -void psComplexArrayFree(psArray *restrict psArr) -{ - if (psArr == NULL) { - return; - } - psFree(psArr->arr.cFltArr); - psFree(psArr); -} - -psArray* psVoidPtrArrayAlloc(int nalloc) -{ - psArray *psArr = NULL; - psArr = psAlloc(sizeof(psArray)); - psArr->arr.ptrArr = p_psArrayAlloc(psArr, PS_TYPE_OTHER, nalloc, sizeof(void *)); - return psArr; -} - -psArray *psVoidPtrArrayRealloc(psArray *restrict psArr, int nalloc) -{ - int i = 0; - - for (i = nalloc; i < psArr->n; i++) { // For reduction in array size - psMemDecrRefCounter(psArr->arr.ptrArr[i]); - } - - if(psArr == NULL) { // For creating new psArray with realloc - psArr = psVoidPtrArrayAlloc(nalloc); - } else if(psArr->nalloc != nalloc) { // No need to realloc to same size - psArr->arr.ptrArr = p_psArrayRealloc(psArr, psArr->arr.ptrArr, nalloc, sizeof(void *)); - } - - return psArr; -} - -void psVoidPtrArrayFree(psArray *restrict psArr, void (*elemFree)(void *)) -{ - int i = 0; - - if(psArr == NULL) { - return; - } - - for(i = 0; i < psArr->nalloc; i++) { - if(elemFree == NULL) { - psMemDecrRefCounter(psArr->arr.ptrArr[i]); - } else { - elemFree(psMemDecrRefCounter(psArr->arr.ptrArr[i])); - } - } - - // Free pointer array - psFree(psArr->arr.ptrArr); - psFree(psArr); -} - Index: unk/psLib/src/collections/psArray.h =================================================================== --- /trunk/psLib/src/collections/psArray.h (revision 649) +++ (revision ) @@ -1,290 +1,0 @@ -/** @file psArray.h - * - * @brief Contains support for basic array types - * - * This file defines basic types of one dimensional arrays which include: int, float, double, complex float, and - * void **. - * - * @author Ross Harman, MHPCC - * - * @version $Revision: 1.9 $ $Name: not supported by cvs2svn $ - * @date $Date: 2004-05-05 21:57:39 $ - * - * Copyright 2004 Maui High Performance Computing Center, University of Hawaii - */ - -#ifndef PS_ARRAY_H -#define PS_ARRAY_H - -#include - -/******************************************************************************/ -/* DEFINE STATEMENTS */ -/******************************************************************************/ - -// None - -/******************************************************************************/ -/* TYPE DEFINITIONS */ -/******************************************************************************/ - -/** Types of the elements of vectors, images, etc. - * - * The basic types of the primitives used by psLib are defined within this enum. This enum is used by the psType struct. - * - */ -typedef enum { - PS_TYPE_CHAR, ///< Character. - PS_TYPE_SHORT, ///< Short integer. - PS_TYPE_INT, ///< Integer. - PS_TYPE_LONG, ///< Long integer. - PS_TYPE_UCHAR, ///< Unsigned character. - PS_TYPE_USHORT, ///< Unsigned short integer. - PS_TYPE_UINT, ///< Unsigned integer. - PS_TYPE_ULONG, ///< Unsigned long integer. - PS_TYPE_FLOAT, ///< Floating point. - PS_TYPE_DOUBLE, ///< Double-precision floating point. - PS_TYPE_COMPLEX, ///< Complex numbers consisting of floating point. - PS_TYPE_OTHER, ///< Something else that's not supported for arithmetic. -} psElemType; - -/** Dimensions of a data type. - * - * The dimensions of containers used by psLib are defined within this enum. This enum is used by the psType struct. - * - */ -typedef enum { - PS_DIMEN_SCALAR, ///< Scalar. - PS_DIMEN_VECTOR, ///< Vector. - PS_DIMEN_TRANSV, ///< Transposed vector. - PS_DIMEN_IMAGE, ///< Image. - PS_DIMEN_OTHER ///< Something else that's not supported for arithmetic. -} psDimen; - -/** The type of a data type. - * - * All psLib complex types consist of primitive components. This struct provides the description of those - * primitives. - * - */ -typedef struct -{ - psElemType type; ///< Primitive type. - psDimen dimen; ///< Dimensionality. -} -psType; - -/** An array of generic primitive types. - * - * Struct for maintaining an array of frequently used primitive types. - * - */ -typedef struct -{ - psType type; ///< Type of data. - int nalloc; ///< Total number of elements available. - int n; ///< Number of elements in use. - - union { - int *intArr; ///< Integer array. - float *fltArr; ///< Single precision floating point array. - double *dblArr; ///< Double precision floating point array. - complex float *cFltArr; ///< Single precision floating pont complex array. - void **ptrArr; ///< Void pointer array. - }arr; ///< Union with array data. -} -psArray; - -/*****************************************************************************/ -/* FUNCTION PROTOTYPES */ -/*****************************************************************************/ - -/** Allocate an integer array. - * - * Uses psLib memory allocation functions to create an array of integers as defined by the psIntArray struct. - * - * @return psArray*: Pointer to psArray. - * - */ -psArray *psIntArrayAlloc( - int nalloc ///< Total number of elements to make available. -); - -/** Reallocate an integer array. - * - * Uses psLib memory allocation functions to reallocate an array of integers as defined by the psIntArray - * struct. - * - * @return psArray*: Pointer to psArray. - * - */ -psArray *psIntArrayRealloc( - psArray *myArray, ///< Array to reallocate. - int nalloc ///< Total number of elements to make available. -); - - -/** Deallocate an integer array - * - * Uses psLib memory allocation functions to deallocate an array of integers as defined by the psIntArray - * struct. - * - * @return: void - * - */ -void psIntArrayFree( - psArray *restrict psArr ///< Array to free. -); - -/** Allocate a float array. - * - * Uses psLib memory allocation functions to create an array of floats as defined by the psFloatArray struct. - * - * @return psArray*: Pointer to psArray. - * - */ -psArray *psFloatArrayAlloc( - int nalloc ///< Total number of elements to make available. -); - -/** Reallocate a float array. - * - * Uses psLib memory allocation functions to reallocate an array of floats as defined by the psFloatArray - * struct. - * - * @return psArray*: Pointer to psArray. - * - */ -psArray *psFloatArrayRealloc( - psArray *psArr, ///< Array to reallocate. - int nalloc ///< Total number of elements to make available. -); - -/** Deallocate a float array. - * - * Uses psLib memory allocation functions to deallocate an array of floats as defined by the psFloatArray - * struct. - * - * @return: void - * - */ -void psFloatArrayFree( - psArray *restrict myArray ///< Array to free. -); - -/** Allocate a double array. - * - * Uses psLib memory allocation functions to create an array of doubles as defined by the psDoubleArray - * struct. - * - * @return psArray*: Pointer to psArray. - * - */ -psArray *psDoubleArrayAlloc( - int nalloc ///< Total number of elements to make available. -); - -/** Reallocate a double array. - * - * Uses psLib memory allocation functions to reallocate an array of Doubles as defined by the psDoubleArray - * struct. - * - * @return psArray*: Pointer to psArray. - * - */ -psArray *psDoubleArrayRealloc( - psArray *psArr, ///< Array to reallocate. - int nalloc ///< Total number of elements to make available. -); - -/** Deallocate a double array. - * - * Uses psLib memory allocation functions to deallocate an array of doubles as defined by the psDoubleArray - * struct. - * - * @return: void - * - */ -void psDoubleArrayFree( - psArray *restrict psArr ///< Array to free. -); - -/** Allocate a complex array. - * - * Uses psLib memory allocation functions to create an array of single precision floating point complex - * numbers as defined by the psComplexArray struct. - * - * @return psArray*: Pointer to psArray. - * - */ -psArray *psComplexArrayAlloc(int nalloc) ///< Total number of elements to make available. -; - -/** Reallocate a complex array. - * - * Uses psLib memory allocation functions to reallocate an array of single precision floating point complex - * numbers as defined by the psComplexArray struct. - * - * @return psArray*: Pointer to psArray. - * - */ -psArray *psComplexArrayRealloc( - psArray *psArr, ///< Array to reallocate. - int nalloc ///< Total number of elements to make available. -); - -/** Deallocate a complex array. - * - * Uses psLib memory allocation functions to deallocate an array of single precision floating point complex - * numbers as defined by the psComplexArray struct. - * - * @return: void - * - */ -void psComplexArrayFree( - psArray *restrict psArr ///< Array to free. -); - -/** Allocate a void pointer array. - * - * Uses psLib memory allocation functions to create an array of void pointers as defined by the psVoidPtrArray - * struct. - * - * @return psArray*: Pointer to psArray. - * - */ -psArray *psVoidPtrArrayAlloc( - int nalloc ///< Number of elements to use. -); - -/** Reallocate a void pointer array. - * - * Uses psLib memory allocation functions to reallocate an array of void pointers as defined by the - * psVoidPtrArray struct. If the array size is increased or decreased, this function does not allocate or - * deallocate the contents of individual array elements. The user must do this after calling this function. - * - * @return psArray*: Pointer to psArray. - * - */ -psArray *psVoidPtrArrayRealloc( - psArray *restrict psArr, ///< Void pointer array to destroy. - int nalloc ///< Number of elements. -); - -/** Deallocate a void pointer array. - * - * Uses psLib memory allocation functions to deallocate an array of void pointers as defined by the - * psVoidPtrArray struct. This function does not free the array elements unless the user provides a callback - * function. NULL may be passed as an alternative to supplying a callback, but the user must remember to - * delete the array elements afterwards. The user must not delete or deallocate the array elements prior to - * calling this function, as it requires valid elements for memory reference decrementation operations. - * - * @return: void - * - */ -void psVoidPtrArrayFree( - psArray *restrict psArr, ///< Void pointer array to destroy. - void (*elemFree)(void *) ///< Optional callback function to remove array elements. -); - -#endif Index: unk/psLib/src/types/psArray.c =================================================================== --- /trunk/psLib/src/types/psArray.c (revision 649) +++ (revision ) @@ -1,239 +1,0 @@ -/** @file psArray.c - * - * @brief Contains support for array types - * - * This file defines basic types of one dimensional arrays which include: int, float, double, complex float, and - * void **. - * - * @author Ross Harman, MHPCC - * - * @version $Revision: 1.7 $ $Name: not supported by cvs2svn $ - * @date $Date: 2004-05-05 20:43:22 $ - * - * Copyright 2004 Maui High Performance Computing Center, University of Hawaii - */ - -/******************************************************************************/ -/* INCLUDE FILES */ -/******************************************************************************/ -#include "psMemory.h" -#include "psArray.h" - -/******************************************************************************/ -/* DEFINE STATEMENTS */ -/******************************************************************************/ - -// None - -/******************************************************************************/ -/* TYPE DEFINITIONS */ -/******************************************************************************/ - -// None - -/*****************************************************************************/ -/* GLOBAL VARIABLES */ -/*****************************************************************************/ - -// None - -/*****************************************************************************/ -/* FILE STATIC VARIABLES */ -/*****************************************************************************/ - -// None - -/*****************************************************************************/ -/* FUNCTION IMPLEMENTATION - LOCAL */ -/*****************************************************************************/ - -static void* p_psArrayAlloc(psArray *restrict psArr, psElemType elemType, int nalloc, int elemSize) -{ - void *arr = NULL; - - psArr->type.dimen = PS_DIMEN_VECTOR; - psArr->type.type = elemType; - psArr->nalloc = nalloc; - psArr->n = 0; - - if(nalloc != 0) { - arr = psAlloc(nalloc*sizeof(elemSize)); - } - - return arr; -} - -static void* p_psArrayRealloc(psArray *restrict psArr, void *arr, int nalloc, int elemSize) -{ - // For decrease in psArray size - if(nalloc < psArr->n) { - psArr->n = nalloc; - } - - psArr->nalloc = nalloc; - - return psRealloc(arr, nalloc*elemSize); -} - -/*****************************************************************************/ -/* FUNCTION IMPLEMENTATION - PUBLIC */ -/*****************************************************************************/ -psArray* psIntArrayAlloc(int nalloc) -{ - psArray *psArr = NULL; - psArr = psAlloc(sizeof(psArray)); - psArr->arr.intArr = (int*)p_psArrayAlloc(psArr, PS_TYPE_INT, nalloc, sizeof(int)); - return psArr; -} - -psArray *psIntArrayRealloc(psArray *restrict psArr, int nalloc) -{ - if(psArr == NULL) { // For creating new psArray with realloc - psArr = psIntArrayAlloc(nalloc); - } else if(psArr->nalloc != nalloc) { // No need to realloc to same size - psArr->arr.intArr = p_psArrayRealloc(psArr, psArr->arr.intArr, nalloc, sizeof(int)); - } - - return psArr; -} - -void psIntArrayFree(psArray *restrict psArr) -{ - if (psArr == NULL) { - return; - } - - psFree(psArr->arr.intArr); - psFree(psArr); -} - -psArray* psFloatArrayAlloc(int nalloc) -{ - psArray *psArr = NULL; - psArr = psAlloc(sizeof(psArray)); - psArr->arr.fltArr = (float*)p_psArrayAlloc(psArr, PS_TYPE_FLOAT, nalloc, sizeof(float)); - return psArr; -} - -psArray *psFloatArrayRealloc(psArray *restrict psArr, int nalloc) -{ - if(psArr == NULL) { // For creating new psArray with realloc - psArr = psFloatArrayAlloc(nalloc); - } else if(psArr->nalloc != nalloc) { // No need to realloc to same size - psArr->arr.fltArr = p_psArrayRealloc(psArr, psArr->arr.fltArr, nalloc, sizeof(float)); - } - - return psArr; -} - -void psFloatArrayFree(psArray *restrict psArr) -{ - if (psArr == NULL) { - return; - } - psFree(psArr->arr.fltArr); - psFree(psArr); -} - -psArray* psDoubleArrayAlloc(int nalloc) -{ - psArray *psArr = NULL; - psArr = psAlloc(sizeof(psArray)); - psArr->arr.dblArr = (double*)p_psArrayAlloc(psArr, PS_TYPE_DOUBLE, nalloc, sizeof(double)); - return psArr; -} - -psArray *psDoubleArrayRealloc(psArray *restrict psArr, int nalloc) -{ - if(psArr == NULL) { // For creating new psArray with realloc - psArr = psDoubleArrayAlloc(nalloc); - } else if(psArr->nalloc != nalloc) { // No need to realloc to same size - psArr->arr.dblArr = p_psArrayRealloc(psArr, psArr->arr.dblArr, nalloc, sizeof(double)); - } - - return psArr; -} - -void psDoubleArrayFree(psArray *restrict psArr) -{ - if (psArr == NULL) { - return; - } - psFree(psArr->arr.dblArr); - psFree(psArr); -} - -psArray* psComplexArrayAlloc(int nalloc) -{ - psArray *psArr = NULL; - psArr = psAlloc(sizeof(psArray)); - psArr->arr.cFltArr = (complex float*)p_psArrayAlloc(psArr, PS_TYPE_COMPLEX, nalloc, sizeof(complex float)); - return psArr; -} - -psArray *psComplexArrayRealloc(psArray *restrict psArr, int nalloc) -{ - if(psArr == NULL) { // For creating new psArray with realloc - psArr = psComplexArrayAlloc(nalloc); - } else if(psArr->nalloc != nalloc) { // No need to realloc to same size - psArr->arr.cFltArr = p_psArrayRealloc(psArr, psArr->arr.cFltArr, nalloc, sizeof(complex float)); - } - - return psArr; -} - -void psComplexArrayFree(psArray *restrict psArr) -{ - if (psArr == NULL) { - return; - } - psFree(psArr->arr.cFltArr); - psFree(psArr); -} - -psArray* psVoidPtrArrayAlloc(int nalloc) -{ - psArray *psArr = NULL; - psArr = psAlloc(sizeof(psArray)); - psArr->arr.ptrArr = p_psArrayAlloc(psArr, PS_TYPE_OTHER, nalloc, sizeof(void *)); - return psArr; -} - -psArray *psVoidPtrArrayRealloc(psArray *restrict psArr, int nalloc) -{ - int i = 0; - - for (i = nalloc; i < psArr->n; i++) { // For reduction in array size - psMemDecrRefCounter(psArr->arr.ptrArr[i]); - } - - if(psArr == NULL) { // For creating new psArray with realloc - psArr = psVoidPtrArrayAlloc(nalloc); - } else if(psArr->nalloc != nalloc) { // No need to realloc to same size - psArr->arr.ptrArr = p_psArrayRealloc(psArr, psArr->arr.ptrArr, nalloc, sizeof(void *)); - } - - return psArr; -} - -void psVoidPtrArrayFree(psArray *restrict psArr, void (*elemFree)(void *)) -{ - int i = 0; - - if(psArr == NULL) { - return; - } - - for(i = 0; i < psArr->nalloc; i++) { - if(elemFree == NULL) { - psMemDecrRefCounter(psArr->arr.ptrArr[i]); - } else { - elemFree(psMemDecrRefCounter(psArr->arr.ptrArr[i])); - } - } - - // Free pointer array - psFree(psArr->arr.ptrArr); - psFree(psArr); -} - Index: unk/psLib/src/types/psArray.h =================================================================== --- /trunk/psLib/src/types/psArray.h (revision 649) +++ (revision ) @@ -1,290 +1,0 @@ -/** @file psArray.h - * - * @brief Contains support for basic array types - * - * This file defines basic types of one dimensional arrays which include: int, float, double, complex float, and - * void **. - * - * @author Ross Harman, MHPCC - * - * @version $Revision: 1.9 $ $Name: not supported by cvs2svn $ - * @date $Date: 2004-05-05 21:57:39 $ - * - * Copyright 2004 Maui High Performance Computing Center, University of Hawaii - */ - -#ifndef PS_ARRAY_H -#define PS_ARRAY_H - -#include - -/******************************************************************************/ -/* DEFINE STATEMENTS */ -/******************************************************************************/ - -// None - -/******************************************************************************/ -/* TYPE DEFINITIONS */ -/******************************************************************************/ - -/** Types of the elements of vectors, images, etc. - * - * The basic types of the primitives used by psLib are defined within this enum. This enum is used by the psType struct. - * - */ -typedef enum { - PS_TYPE_CHAR, ///< Character. - PS_TYPE_SHORT, ///< Short integer. - PS_TYPE_INT, ///< Integer. - PS_TYPE_LONG, ///< Long integer. - PS_TYPE_UCHAR, ///< Unsigned character. - PS_TYPE_USHORT, ///< Unsigned short integer. - PS_TYPE_UINT, ///< Unsigned integer. - PS_TYPE_ULONG, ///< Unsigned long integer. - PS_TYPE_FLOAT, ///< Floating point. - PS_TYPE_DOUBLE, ///< Double-precision floating point. - PS_TYPE_COMPLEX, ///< Complex numbers consisting of floating point. - PS_TYPE_OTHER, ///< Something else that's not supported for arithmetic. -} psElemType; - -/** Dimensions of a data type. - * - * The dimensions of containers used by psLib are defined within this enum. This enum is used by the psType struct. - * - */ -typedef enum { - PS_DIMEN_SCALAR, ///< Scalar. - PS_DIMEN_VECTOR, ///< Vector. - PS_DIMEN_TRANSV, ///< Transposed vector. - PS_DIMEN_IMAGE, ///< Image. - PS_DIMEN_OTHER ///< Something else that's not supported for arithmetic. -} psDimen; - -/** The type of a data type. - * - * All psLib complex types consist of primitive components. This struct provides the description of those - * primitives. - * - */ -typedef struct -{ - psElemType type; ///< Primitive type. - psDimen dimen; ///< Dimensionality. -} -psType; - -/** An array of generic primitive types. - * - * Struct for maintaining an array of frequently used primitive types. - * - */ -typedef struct -{ - psType type; ///< Type of data. - int nalloc; ///< Total number of elements available. - int n; ///< Number of elements in use. - - union { - int *intArr; ///< Integer array. - float *fltArr; ///< Single precision floating point array. - double *dblArr; ///< Double precision floating point array. - complex float *cFltArr; ///< Single precision floating pont complex array. - void **ptrArr; ///< Void pointer array. - }arr; ///< Union with array data. -} -psArray; - -/*****************************************************************************/ -/* FUNCTION PROTOTYPES */ -/*****************************************************************************/ - -/** Allocate an integer array. - * - * Uses psLib memory allocation functions to create an array of integers as defined by the psIntArray struct. - * - * @return psArray*: Pointer to psArray. - * - */ -psArray *psIntArrayAlloc( - int nalloc ///< Total number of elements to make available. -); - -/** Reallocate an integer array. - * - * Uses psLib memory allocation functions to reallocate an array of integers as defined by the psIntArray - * struct. - * - * @return psArray*: Pointer to psArray. - * - */ -psArray *psIntArrayRealloc( - psArray *myArray, ///< Array to reallocate. - int nalloc ///< Total number of elements to make available. -); - - -/** Deallocate an integer array - * - * Uses psLib memory allocation functions to deallocate an array of integers as defined by the psIntArray - * struct. - * - * @return: void - * - */ -void psIntArrayFree( - psArray *restrict psArr ///< Array to free. -); - -/** Allocate a float array. - * - * Uses psLib memory allocation functions to create an array of floats as defined by the psFloatArray struct. - * - * @return psArray*: Pointer to psArray. - * - */ -psArray *psFloatArrayAlloc( - int nalloc ///< Total number of elements to make available. -); - -/** Reallocate a float array. - * - * Uses psLib memory allocation functions to reallocate an array of floats as defined by the psFloatArray - * struct. - * - * @return psArray*: Pointer to psArray. - * - */ -psArray *psFloatArrayRealloc( - psArray *psArr, ///< Array to reallocate. - int nalloc ///< Total number of elements to make available. -); - -/** Deallocate a float array. - * - * Uses psLib memory allocation functions to deallocate an array of floats as defined by the psFloatArray - * struct. - * - * @return: void - * - */ -void psFloatArrayFree( - psArray *restrict myArray ///< Array to free. -); - -/** Allocate a double array. - * - * Uses psLib memory allocation functions to create an array of doubles as defined by the psDoubleArray - * struct. - * - * @return psArray*: Pointer to psArray. - * - */ -psArray *psDoubleArrayAlloc( - int nalloc ///< Total number of elements to make available. -); - -/** Reallocate a double array. - * - * Uses psLib memory allocation functions to reallocate an array of Doubles as defined by the psDoubleArray - * struct. - * - * @return psArray*: Pointer to psArray. - * - */ -psArray *psDoubleArrayRealloc( - psArray *psArr, ///< Array to reallocate. - int nalloc ///< Total number of elements to make available. -); - -/** Deallocate a double array. - * - * Uses psLib memory allocation functions to deallocate an array of doubles as defined by the psDoubleArray - * struct. - * - * @return: void - * - */ -void psDoubleArrayFree( - psArray *restrict psArr ///< Array to free. -); - -/** Allocate a complex array. - * - * Uses psLib memory allocation functions to create an array of single precision floating point complex - * numbers as defined by the psComplexArray struct. - * - * @return psArray*: Pointer to psArray. - * - */ -psArray *psComplexArrayAlloc(int nalloc) ///< Total number of elements to make available. -; - -/** Reallocate a complex array. - * - * Uses psLib memory allocation functions to reallocate an array of single precision floating point complex - * numbers as defined by the psComplexArray struct. - * - * @return psArray*: Pointer to psArray. - * - */ -psArray *psComplexArrayRealloc( - psArray *psArr, ///< Array to reallocate. - int nalloc ///< Total number of elements to make available. -); - -/** Deallocate a complex array. - * - * Uses psLib memory allocation functions to deallocate an array of single precision floating point complex - * numbers as defined by the psComplexArray struct. - * - * @return: void - * - */ -void psComplexArrayFree( - psArray *restrict psArr ///< Array to free. -); - -/** Allocate a void pointer array. - * - * Uses psLib memory allocation functions to create an array of void pointers as defined by the psVoidPtrArray - * struct. - * - * @return psArray*: Pointer to psArray. - * - */ -psArray *psVoidPtrArrayAlloc( - int nalloc ///< Number of elements to use. -); - -/** Reallocate a void pointer array. - * - * Uses psLib memory allocation functions to reallocate an array of void pointers as defined by the - * psVoidPtrArray struct. If the array size is increased or decreased, this function does not allocate or - * deallocate the contents of individual array elements. The user must do this after calling this function. - * - * @return psArray*: Pointer to psArray. - * - */ -psArray *psVoidPtrArrayRealloc( - psArray *restrict psArr, ///< Void pointer array to destroy. - int nalloc ///< Number of elements. -); - -/** Deallocate a void pointer array. - * - * Uses psLib memory allocation functions to deallocate an array of void pointers as defined by the - * psVoidPtrArray struct. This function does not free the array elements unless the user provides a callback - * function. NULL may be passed as an alternative to supplying a callback, but the user must remember to - * delete the array elements afterwards. The user must not delete or deallocate the array elements prior to - * calling this function, as it requires valid elements for memory reference decrementation operations. - * - * @return: void - * - */ -void psVoidPtrArrayFree( - psArray *restrict psArr, ///< Void pointer array to destroy. - void (*elemFree)(void *) ///< Optional callback function to remove array elements. -); - -#endif