if (field->info->data_type_id == e_tid_uchar) {        return (float)((uchar*) field->elems)[elem_index];    }    if (field->info->data_type_id == e_tid_char) {        return (float)((char*) field->elems)[elem_index];    }    if (field->info->data_type_id == e_tid_ushort) {        return (float)((ushort*) field->elems)[elem_index];    }    if (field->info->data_type_id == e_tid_short) {        return (float)((short*) field->elems)[elem_index];    }    if (field->info->data_type_id == e_tid_ulong) {        return (float)((ulong*) field->elems)[elem_index];    }    if (field->info->data_type_id == e_tid_long) {        return (float)((long*) field->elems)[elem_index];    }    epr_set_err(e_err_invalid_data_format,                 "epr_get_field_elems_as_float: invalid type");    return 0.0;}/** * Interprates a memory data as a <code>float</code> data  *  * @param field the pointer at the array to convert  * * @return the <code>float</code> typed element *         or <code>NULL</code> if an error occured. */const float* epr_get_field_elems_float(const EPR_SField* field){    epr_clear_err();    if (field == NULL) {        epr_set_err(e_err_invalid_field_name,                     "epr_get_field_elem_as_floats: invalid field name");        return NULL;    }    if (field->info->data_type_id != e_tid_float) {        epr_set_err(e_err_invalid_data_format,                     "epr_get_field_elems_as_floats: invalid type");        return NULL;    }    return (float*) field->elems;}/** * Interprates a memory as a <code>double</code> value *  * @param field the pointer at the array to convert  * @param elem_index the index of the element  * in the given array to convert * * @return the <code>double</code> typed element *         or <code>error_code</code> if an error occured. */double epr_get_field_elem_as_double(const EPR_SField* field, uint elem_index){    epr_clear_err();    if (field == NULL) {        epr_set_err(e_err_invalid_field_name,                     "epr_get_field_elems_as_double: invalid field name");        return 0.0;                }    if (elem_index >= field->info->num_elems) {        epr_set_err(e_err_invalid_value,                     "epr_get_field_elems_as_double: invalid elem_index parameter");        return 0.0;    }    if (field->info->data_type_id == e_tid_double) {        return (double)((double*) field->elems)[elem_index];    }    if (field->info->data_type_id == e_tid_float) {        return (double)((float*) field->elems)[elem_index];    }    if (field->info->data_type_id == e_tid_uchar) {        return (double)((uchar*) field->elems)[elem_index];    }    if (field->info->data_type_id == e_tid_char) {        return (double)((char*) field->elems)[elem_index];    }    if (field->info->data_type_id == e_tid_ushort) {        return (double)((ushort*) field->elems)[elem_index];    }    if (field->info->data_type_id == e_tid_short) {        return (double)((short*) field->elems)[elem_index];    }    if (field->info->data_type_id == e_tid_ulong) {        return (double)((ulong*) field->elems)[elem_index];    }    if (field->info->data_type_id == e_tid_long) {        return (double)((long*) field->elems)[elem_index];    }    epr_set_err(e_err_invalid_data_format,                 "epr_get_field_elems_as_double: invalid type");    return 0.0;}/** * Interprates a memory data as a <code>double</code> data  *  * @param field the pointer at the array to convert  * * @return the <code>double</code> typed element *         or <code>NULL</code> if an error occured. */const double* epr_get_field_elems_double(const EPR_SField* field){    epr_clear_err();    epr_clear_err();    if (field == NULL) {        epr_set_err(e_err_invalid_field_name,                     "epr_get_field_elems_as_doubles: invalid field name");        return NULL;    }    if (field->info->data_type_id != e_tid_double) {        epr_set_err(e_err_invalid_data_format,                     "epr_get_field_elems_as_doubles: invalid type");        return NULL;    }    return (double*) field->elems;}/** * Interprates a memory data as a <code>short</code> data  *  * @param field the pointer at the array to convert  * @param time the pointer at the time structure to get * * @return the time [days, seconds, microseconds] *         or <code>NULL</code> if an error occured. */const EPR_STime* epr_get_field_elem_as_mjd(const EPR_SField* field){    epr_clear_err();    if (field == NULL) {        epr_set_err(e_err_invalid_field_name,                     "epr_get_field_elem_as_mjd: invalid field name");        return NULL;                }        if (field->info->data_type_id != e_tid_time) {        epr_set_err(e_err_invalid_data_format,                     "epr_get_field_elem_as_mjd: invalid type");        return NULL;    }	return (const EPR_STime*) field->elems;}/** * Interprates a memory data as a string. *  * @param field the pointer at the array to convert  * * @return the <code>char</code> typed element *         or <code>NULL</code> if an error occured. */const char* epr_get_field_elem_as_str(const EPR_SField* field){    epr_clear_err();    if (field == NULL) {        epr_set_err(e_err_invalid_field_name,                     "epr_get_field_elem_as_str: invalid field name");        return NULL;    }    if (field->info->data_type_id != e_tid_string) {        epr_set_err(e_err_invalid_data_format,                     "epr_get_field_elem_as_str: invalid type");        return NULL;    }    return (const char*) field->elems;}/** * Copies the data of the given field into the given buffer of <code>double</code>  * elements. The actual number of elements copied is the minimum of the given  * number of elements (the buffer's size) and the actual number of elements contained * in the field.  * <p>If the actual field data type is not <code>double</code> the function automatically * performs the conversion. *  * @param field the field from which to copy the elements * @param buffer the buffer in which to copy the data  * @param num_elems the number of elements in the given buffer  * @return the actual number of elements copied */uint epr_copy_field_elems_as_doubles(const EPR_SField* field, double* buffer, uint num_elems){    uint num_elems_min = 0;    uint i;    epr_clear_err();    if (field == NULL) {        epr_set_err(e_err_invalid_field_name,                     "epr_get_field_elems_as_doubles: invalid field name");        return num_elems_min;    }    num_elems_min = num_elems;    if (field->info->num_elems < num_elems_min) {        num_elems_min = field->info->num_elems;    }    if (field->info->data_type_id == e_tid_uchar) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (double)((uchar*) field->elems)[i];        }    } else if (field->info->data_type_id == e_tid_char) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (double)((char*) field->elems)[i];        }    } else if (field->info->data_type_id == e_tid_ushort) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (double)((ushort*) field->elems)[i];        }    } else if (field->info->data_type_id == e_tid_short) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (double)((short*) field->elems)[i];        }    } else if (field->info->data_type_id == e_tid_ulong) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (double)((ulong*) field->elems)[i];        }    } else if (field->info->data_type_id == e_tid_long) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (double)((long*) field->elems)[i];        }    } else if (field->info->data_type_id == e_tid_float) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (double)((float*) field->elems)[i];        }    } else if (field->info->data_type_id == e_tid_double) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (double)((double*) field->elems)[i];        }    } else {        epr_set_err(e_err_invalid_data_format,                     "epr_get_field_elems_as_double: invalid type");        return 0;    }    return num_elems_min;}/** * Copies the data of the given field into the given buffer of <code>float</code>  * elements. The actual number of elements copied is the minimum of the given  * number of elements (the buffer's size) and the actual number of elements contained * in the field.  * <p>If the actual field data type is not <code>float</code> the function automatically * performs the conversion. *  * @param field the field from which to copy the elements * @param buffer the buffer in which to copy the data  * @param num_elems the number of elements in the given buffer  * @return the actual number of elements copied */uint epr_copy_field_elems_as_floats(const EPR_SField* field, float* buffer, uint num_elems){    uint num_elems_min = 0;    uint i;    epr_clear_err();    if (field == NULL) {        epr_set_err(e_err_invalid_field_name,                     "epr_copy_field_elems_as_floats: invalid field name");        return num_elems_min;    }    num_elems_min = num_elems;    if (field->info->num_elems < num_elems_min) {        num_elems_min = field->info->num_elems;    }    if (field->info->data_type_id == e_tid_uchar) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (float)((uchar*) field->elems)[i];        }    } else if (field->info->data_type_id == e_tid_char) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (float)((char*) field->elems)[i];        }    } else if (field->info->data_type_id == e_tid_ushort) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (float)((ushort*) field->elems)[i];        }    } else if (field->info->data_type_id == e_tid_short) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (float)((short*) field->elems)[i];        }    } else if (field->info->data_type_id == e_tid_ulong) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (float)((ulong*) field->elems)[i];        }    } else if (field->info->data_type_id == e_tid_long) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (float)((long*) field->elems)[i];        }    } else if (field->info->data_type_id == e_tid_float) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (float)((float*) field->elems)[i];        }    } else {        epr_set_err(e_err_invalid_data_format,                     "epr_copy_field_elems_as_floats: invalid type");        return 0;    }    return num_elems_min;}/** * Copies the data of the given field into the given buffer of <code>long</code>  * elements. The actual number of elements copied is the minimum of the given  * number of elements (the buffer's size) and the actual number of elements contained * in the field.  * <p>If the actual field data type is not <code>long</code> the function automatically * performs the conversion. *  * @param field the field from which to copy the elements * @param buffer the buffer in which to copy the data  * @param num_elems the number of elements in the given buffer  * @return the actual number of elements copied */uint epr_copy_field_elems_as_longs(const EPR_SField* field, long* buffer, uint num_elems){    uint num_elems_min = 0;    uint i;    epr_clear_err();    if (field == NULL) {        epr_set_err(e_err_invalid_field_name,                     "epr_copy_field_elems_as_longs: invalid field name");        return num_elems_min;    }    num_elems_min = num_elems;    if (field->info->num_elems < num_elems_min) {        num_elems_min = field->info->num_elems;    }    if (field->info->data_type_id == e_tid_uchar) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (long)((uchar*) field->elems)[i];        }    } else if (field->info->data_type_id == e_tid_char) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (long)((char*) field->elems)[i];        }    } else if (field->info->data_type_id == e_tid_ushort) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (long)((ushort*) field->elems)[i];        }    } else if (field->info->data_type_id == e_tid_short) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (long)((short*) field->elems)[i];        }    } else if (field->info->data_type_id == e_tid_long) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (long)((long*) field->elems)[i];        }    } else {        epr_set_err(e_err_invalid_data_format,                     "epr_copy_field_elems_as_longs: invalid type");        return 0;    }    return num_elems_min;}/** * Copies the data of the given field into the given buffer of <code>ulong</code>  * elements. The actual number of elements copied is the minimum of the given  * number of elements (the buffer's size) and the actual number of elements contained * in the field.  * <p>If the actual field data type is not <code>ulong</code> the function automatically * performs the conversion. *  * @param field the field from which to copy the elements * @param buffer the buffer in which to copy the data  * @param num_elems the number of elements in the given buffer  * @return the actual number of elements copied */uint epr_copy_field_elems_as_ulongs(const EPR_SField* field, ulong* buffer, uint num_elems){    uint num_elems_min = 0;    uint i;    epr_clear_err();    if (field == NULL) {        epr_set_err(e_err_invalid_field_name,                     "epr_copy_field_elems_as_ulongs: invalid field name");        return num_elems_min;    }    num_elems_min = num_elems;    if (field->info->num_elems < num_elems_min) {        num_elems_min = field->info->num_elems;    }    if (field->info->data_type_id == e_tid_uchar) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (ulong)((uchar*) field->elems)[i];        }    } else if (field->info->data_type_id == e_tid_char) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (ulong)((char*) field->elems)[i];        }    } else if (field->info->data_type_id == e_tid_ushort) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (ulong)((ushort*) field->elems)[i];        }    } else if (field->info->data_type_id == e_tid_short) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (ulong)((short*) field->elems)[i];        }    } else if (field->info->data_type_id == e_tid_long) {        for (i = 0; i < num_elems_min; i++) {            buffer[i] = (ulong)((ulong*) field->elems)[i];        }    } else {        epr_set_err(e_err_invalid_data_format,                     "epr_copy_field_elems_as_ulongs: invalid type");        return 0;    }    return num_elems_min;}/***************************************************************************************/