phoebe_types

phoebe_types

Synopsis

enum                bool;
enum                PHOEBE_type;
char*               phoebe_type_get_name                (PHOEBE_type type);
                    PHOEBE_vector;
PHOEBE_vector*      phoebe_vector_new                   ();
PHOEBE_vector*      phoebe_vector_new_from_qualifier    (char *qualifier);
PHOEBE_vector*      phoebe_vector_new_from_column       (char *filename,
                                                         int col);
PHOEBE_vector*      phoebe_vector_new_from_range        (int dim,
                                                         double start,
                                                         double end);
PHOEBE_vector*      phoebe_vector_duplicate             (PHOEBE_vector *vec);
int                 phoebe_vector_alloc                 (PHOEBE_vector *vec,
                                                         int dimension);
int                 phoebe_vector_realloc               (PHOEBE_vector *vec,
                                                         int dimension);
int                 phoebe_vector_pad                   (PHOEBE_vector *vec,
                                                         double value);
int                 phoebe_vector_free                  (PHOEBE_vector *vec);
int                 phoebe_vector_add                   (PHOEBE_vector *result,
                                                         PHOEBE_vector *fac1,
                                                         PHOEBE_vector *fac2);
int                 phoebe_vector_subtract              (PHOEBE_vector *result,
                                                         PHOEBE_vector *fac1,
                                                         PHOEBE_vector *fac2);
int                 phoebe_vector_multiply              (PHOEBE_vector *result,
                                                         PHOEBE_vector *fac1,
                                                         PHOEBE_vector *fac2);
int                 phoebe_vector_divide                (PHOEBE_vector *result,
                                                         PHOEBE_vector *fac1,
                                                         PHOEBE_vector *fac2);
int                 phoebe_vector_raise                 (PHOEBE_vector *result,
                                                         PHOEBE_vector *fac1,
                                                         PHOEBE_vector *fac2);
int                 phoebe_vector_offset                (PHOEBE_vector *vec,
                                                         double offset);
int                 phoebe_vector_sum                   (PHOEBE_vector *vec,
                                                         double *sum);
int                 phoebe_vector_mean                  (PHOEBE_vector *vec,
                                                         double *mean);
int                 phoebe_vector_median                (PHOEBE_vector *vec,
                                                         double *median);
int                 phoebe_vector_standard_deviation    (PHOEBE_vector *vec,
                                                         double *sigma);
int                 phoebe_vector_multiply_by           (PHOEBE_vector *vec,
                                                         double factor);
int                 phoebe_vector_dot_product           (double *result,
                                                         PHOEBE_vector *fac1,
                                                         PHOEBE_vector *fac2);
int                 phoebe_vector_vec_product           (PHOEBE_vector *result,
                                                         PHOEBE_vector *fac1,
                                                         PHOEBE_vector *fac2);
int                 phoebe_vector_submit                (PHOEBE_vector *result,
                                                         PHOEBE_vector *vec);
int                 phoebe_vector_norm                  (double *result,
                                                         PHOEBE_vector *vec);
int                 phoebe_vector_dim                   (int *result,
                                                         PHOEBE_vector *vec);
int                 phoebe_vector_randomize             (PHOEBE_vector *result,
                                                         double limit);
int                 phoebe_vector_min_max               (PHOEBE_vector *vec,
                                                         double *min,
                                                         double *max);
int                 phoebe_vector_min_index             (PHOEBE_vector *vec,
                                                         int *index);
int                 phoebe_vector_max_index             (PHOEBE_vector *vec,
                                                         int *index);
int                 phoebe_vector_rescale               (PHOEBE_vector *vec,
                                                         double ll,
                                                         double ul);
bool                phoebe_vector_compare               (PHOEBE_vector *vec1,
                                                         PHOEBE_vector *vec2);
int                 phoebe_vector_less_than             (bool *result,
                                                         PHOEBE_vector *vec1,
                                                         PHOEBE_vector *vec2);
int                 phoebe_vector_leq_than              (bool *result,
                                                         PHOEBE_vector *vec1,
                                                         PHOEBE_vector *vec2);
int                 phoebe_vector_greater_than          (bool *result,
                                                         PHOEBE_vector *vec1,
                                                         PHOEBE_vector *vec2);
int                 phoebe_vector_geq_than              (bool *result,
                                                         PHOEBE_vector *vec1,
                                                         PHOEBE_vector *vec2);
int                 phoebe_vector_append_element        (PHOEBE_vector *vec,
                                                         double val);
int                 phoebe_vector_remove_element        (PHOEBE_vector *vec,
                                                         int index);
                    PHOEBE_matrix;
PHOEBE_matrix*      phoebe_matrix_new                   ();
int                 phoebe_matrix_alloc                 (PHOEBE_matrix *matrix,
                                                         int cols,
                                                         int rows);
int                 phoebe_matrix_free                  (PHOEBE_matrix *matrix);
int                 phoebe_matrix_get_row               (PHOEBE_vector *vec,
                                                         PHOEBE_matrix *matrix,
                                                         int row);
int                 phoebe_matrix_set_row               (PHOEBE_matrix *matrix,
                                                         PHOEBE_vector *vec,
                                                         int row);
                    PHOEBE_array;
PHOEBE_array*       phoebe_array_new                    (PHOEBE_type type);
PHOEBE_array*       phoebe_array_new_from_qualifier     (char *qualifier);
PHOEBE_array*       phoebe_array_new_from_column        (char *filename,
                                                         int col);
int                 phoebe_array_alloc                  (PHOEBE_array *array,
                                                         int dimension);
int                 phoebe_array_realloc                (PHOEBE_array *array,
                                                         int dimension);
PHOEBE_array*       phoebe_array_duplicate              (PHOEBE_array *array);
bool                phoebe_array_compare                (PHOEBE_array *array1,
                                                         PHOEBE_array *array2);
int                 phoebe_array_free                   (PHOEBE_array *array);
PHOEBE_vector*      phoebe_vector_new_from_array        (PHOEBE_array *array);
                    PHOEBE_hist;
enum                PHOEBE_hist_rebin_type;
PHOEBE_hist*        phoebe_hist_new                     ();
PHOEBE_hist*        phoebe_hist_new_from_arrays         (int bins,
                                                         double *binarray,
                                                         double *valarray);
PHOEBE_hist*        phoebe_hist_new_from_file           (char *filename);
PHOEBE_hist*        phoebe_hist_duplicate               (PHOEBE_hist *hist);
int                 phoebe_hist_alloc                   (PHOEBE_hist *hist,
                                                         int bins);
int                 phoebe_hist_realloc                 (PHOEBE_hist *hist,
                                                         int bins);
int                 phoebe_hist_free                    (PHOEBE_hist *hist);
int                 phoebe_hist_set_ranges              (PHOEBE_hist *hist,
                                                         PHOEBE_vector *bin_centers);
int                 phoebe_hist_set_values              (PHOEBE_hist *hist,
                                                         PHOEBE_vector *values);
int                 phoebe_hist_get_bin_centers         (PHOEBE_hist *hist,
                                                         PHOEBE_vector *bin_centers);
int                 phoebe_hist_get_bin                 (int *bin,
                                                         PHOEBE_hist *hist,
                                                         double r);
int                 phoebe_hist_evaluate                (double *y,
                                                         PHOEBE_hist *hist,
                                                         double x);
int                 phoebe_hist_integrate               (double *integral,
                                                         PHOEBE_hist *hist,
                                                         double ll,
                                                         double ul);
int                 phoebe_hist_shift                   (PHOEBE_hist *hist,
                                                         double shift);
int                 phoebe_hist_correlate               (double *cfval,
                                                         PHOEBE_hist *h1,
                                                         PHOEBE_hist *h2,
                                                         double sigma1,
                                                         double sigma2,
                                                         double ll,
                                                         double ul,
                                                         double xi);
int                 phoebe_hist_pad                     (PHOEBE_hist *hist,
                                                         double val);
int                 phoebe_hist_crop                    (PHOEBE_hist *hist,
                                                         double ll,
                                                         double ul);
bool                phoebe_hist_compare                 (PHOEBE_hist *hist1,
                                                         PHOEBE_hist *hist2);
int                 phoebe_hist_resample                (PHOEBE_hist *out,
                                                         PHOEBE_hist *in,
                                                         PHOEBE_hist_rebin_type type);
int                 phoebe_hist_rebin                   (PHOEBE_hist *out,
                                                         PHOEBE_hist *in,
                                                         PHOEBE_hist_rebin_type type);
                    PHOEBE_ld;
                    PHOEBE_passband;
enum                PHOEBE_curve_type;
int                 phoebe_curve_type_get_name          (PHOEBE_curve_type ctype,
                                                         char **name);
enum                PHOEBE_column_type;
int                 phoebe_column_type_get_name         (PHOEBE_column_type ctype,
                                                         char **name);
int                 phoebe_column_get_type              (PHOEBE_column_type *type,
                                                         const char *string);
enum                PHOEBE_data_flag;
                    PHOEBE_curve;
PHOEBE_curve*       phoebe_curve_new                    ();
PHOEBE_curve*       phoebe_curve_new_from_file          (char *filename);
PHOEBE_curve*       phoebe_curve_new_from_pars          (PHOEBE_curve_type ctype,
                                                         int index);
PHOEBE_curve*       phoebe_curve_duplicate              (PHOEBE_curve *curve);
int                 phoebe_curve_alloc                  (PHOEBE_curve *curve,
                                                         int dim);
int                 phoebe_curve_realloc                (PHOEBE_curve *curve,
                                                         int dim);
int                 phoebe_curve_compute                (PHOEBE_curve *curve,
                                                         PHOEBE_vector *nodes,
                                                         int index,
                                                         PHOEBE_column_type itype,
                                                         PHOEBE_column_type dtype);
int                 phoebe_curve_transform              (PHOEBE_curve *curve,
                                                         PHOEBE_column_type itype,
                                                         PHOEBE_column_type dtype,
                                                         PHOEBE_column_type wtype);
int                 phoebe_curve_alias                  (PHOEBE_curve *curve,
                                                         double phmin,
                                                         double phmax);
int                 phoebe_curve_set_properties         (PHOEBE_curve *curve,
                                                         PHOEBE_curve_type type,
                                                         char *filename,
                                                         PHOEBE_passband *passband,
                                                         PHOEBE_column_type itype,
                                                         PHOEBE_column_type dtype,
                                                         PHOEBE_column_type wtype,
                                                         double sigma);
int                 phoebe_curve_free                   (PHOEBE_curve *curve);
enum                PHOEBE_spectrum_dispersion;
                    PHOEBE_spectrum;
enum                PHOEBE_minimizer_type;
int                 phoebe_minimizer_type_get_name      (PHOEBE_minimizer_type minimizer,
                                                         char **name);
                    PHOEBE_minimizer_feedback;
PHOEBE_minimizer_feedback* phoebe_minimizer_feedback_new
                                                        ();
PHOEBE_minimizer_feedback* phoebe_minimizer_feedback_duplicate
                                                        (PHOEBE_minimizer_feedback *feedback);
int                 phoebe_minimizer_feedback_alloc     (PHOEBE_minimizer_feedback *feedback,
                                                         int tba,
                                                         int cno);
int                 phoebe_minimizer_feedback_accept    (PHOEBE_minimizer_feedback *feedback);
int                 phoebe_minimizer_feedback_free      (PHOEBE_minimizer_feedback *feedback);
PHOEBE_spectrum*    phoebe_spectrum_duplicate           (PHOEBE_spectrum *spectrum);
PHOEBE_value        phoebe_value_duplicate              (PHOEBE_type type,
                                                         PHOEBE_value val);

Description

Details

enum bool

typedef enum bool {
	NO,
	YES
} bool;


enum PHOEBE_type

typedef enum PHOEBE_type {
	TYPE_INT,
	TYPE_BOOL,
	TYPE_DOUBLE,
	TYPE_STRING,
	TYPE_INT_ARRAY,
	TYPE_BOOL_ARRAY,
	TYPE_DOUBLE_ARRAY,
	TYPE_STRING_ARRAY,
	TYPE_CURVE,
	TYPE_SPECTRUM,
	TYPE_MINIMIZER_FEEDBACK,
	TYPE_ANY
} PHOEBE_type;

Various data types used in Phoebe.

TYPE_INT

The integer type.

TYPE_BOOL

The boolean type.

TYPE_DOUBLE

The double precision floating-point type.

TYPE_STRING

The string type.

TYPE_INT_ARRAY

Array of integers.

TYPE_BOOL_ARRAY

Array of booleans.

TYPE_DOUBLE_ARRAY

Array of doubles.

TYPE_STRING_ARRAY

Array of strings.

TYPE_CURVE

The PHOEBE_curve type.

TYPE_SPECTRUM

The PHOEBE_spectrum type.

TYPE_MINIMIZER_FEEDBACK

The PHOEBE_minimizer_feedback type.

TYPE_ANY

Can be any PHOEBE_type.

phoebe_type_get_name ()

char*               phoebe_type_get_name                (PHOEBE_type type);

type :

Returns :


PHOEBE_vector

typedef struct {
	int dim;
	double *val;
} PHOEBE_vector;

int dim;

Vector dimension.

double *val;

An array of vector values.

phoebe_vector_new ()

PHOEBE_vector*      phoebe_vector_new                   ();

Initializes a vector for allocation.

Returns :

A PHOEBE_vector.

phoebe_vector_new_from_qualifier ()

PHOEBE_vector*      phoebe_vector_new_from_qualifier    (char *qualifier);

Allocates a new PHOEBE_vector and assigns it elements taken from the array parameter represented by qualifier.

qualifier :

The array parameter.

Returns :

A PHOEBE_vector, or NULL if an error occured.

phoebe_vector_new_from_column ()

PHOEBE_vector*      phoebe_vector_new_from_column       (char *filename,
                                                         int col);

Reads in the col-th column from file filename, parses it and stores it into the returned vector.

filename :

The full path to the file to be read.

col :

The column to be read.

Returns :

A PHOEBE_vector, or NULL if an error occured.

phoebe_vector_new_from_range ()

PHOEBE_vector*      phoebe_vector_new_from_range        (int dim,
                                                         double start,
                                                         double end);

Creates a vector that starts at start, ends at end, and has dim equidistant steps.

dim :

vector dimension

start :

first vector element

end :

last vector element

Returns :


phoebe_vector_duplicate ()

PHOEBE_vector*      phoebe_vector_duplicate             (PHOEBE_vector *vec);

Makes a duplicate copy of PHOEBE_vector vec.

vec :

The PHOEBE_vector to copy.

Returns :

A PHOEBE_vector.

phoebe_vector_alloc ()

int                 phoebe_vector_alloc                 (PHOEBE_vector *vec,
                                                         int dimension);

Allocates storage memory for a PHOEBE_vector of dimension.

vec :

The PHOEBE_vector to store.

dimension :

The size of the new PHOEBE_vector.

Returns :

A PHOEBE_error_code indicating the success of the operation. Possible errors: ERROR_VECTOR_ALREADY_ALLOCATED and ERROR_VECTOR_INVALID_DIMENSION.

phoebe_vector_realloc ()

int                 phoebe_vector_realloc               (PHOEBE_vector *vec,
                                                         int dimension);

Reallocates storage memory for a PHOEBE_vector of dimension.

vec :

PHOEBE_vector to reallocate.

dimension :

new size for vec.

Returns :

A PHOEBE_error_code indicating the success of the operation. Possible errors: ERROR_VECTOR_INVALID_DIMENSION.

phoebe_vector_pad ()

int                 phoebe_vector_pad                   (PHOEBE_vector *vec,
                                                         double value);

Pads all components of vec with value.

vec :

The PHOEBE_vector to pad with value.

value :

The new value for all elements of vec.

Returns :

A PHOEBE_error_code indicating the success of the operation.

phoebe_vector_free ()

int                 phoebe_vector_free                  (PHOEBE_vector *vec);

Frees the storage memory allocated for PHOEBE_vector vec.

vec :

The PHOEBE_vector to free.

Returns :

A PHOEBE_error_code indicating the success of the operation.

phoebe_vector_add ()

int                 phoebe_vector_add                   (PHOEBE_vector *result,
                                                         PHOEBE_vector *fac1,
                                                         PHOEBE_vector *fac2);

Adds PHOEBE_vector fac1 to fac2 and returns the sum PHOEBE_vector result.

result :

The placeholder for a return value.

fac1 :

Vector 1.

fac2 :

Vector 2.

Returns :

PHOEBE_error_code

phoebe_vector_subtract ()

int                 phoebe_vector_subtract              (PHOEBE_vector *result,
                                                         PHOEBE_vector *fac1,
                                                         PHOEBE_vector *fac2);

Subtracts PHOEBE_vector fac2 from fac1 and returns the difference PHOEBE_vector result.

result :

The placeholder for a return value.

fac1 :

Vector 1.

fac2 :

Vector 2.

Returns :

A PHOEBE_error_code indicating the success of the operation. Possible errors: ERROR_VECTOR_DIMENSIONS_MISMATCH.

phoebe_vector_multiply ()

int                 phoebe_vector_multiply              (PHOEBE_vector *result,
                                                         PHOEBE_vector *fac1,
                                                         PHOEBE_vector *fac2);

Multiplies PHOEBE_vector fac1 with fac2 and returns the product PHOEBE_vector result.

result :

The placeholder for a return value.

fac1 :

Vector 1.

fac2 :

Vector 2.

Returns :

A PHOEBE_error_code indicating the success of the operation. Possible errors: ERROR_VECTOR_DIMENSIONS_MISMATCH.

phoebe_vector_divide ()

int                 phoebe_vector_divide                (PHOEBE_vector *result,
                                                         PHOEBE_vector *fac1,
                                                         PHOEBE_vector *fac2);

Divides PHOEBE_vector fac1 with fac2 and returns the quotient PHOEBE_vector result.

result :

The placeholder for a return value.

fac1 :

Vector 1.

fac2 :

Vector 2.

Returns :

A PHOEBE_error_code indicating the success of the operation. Possible errors: ERROR_VECTOR_DIMENSIONS_MISMATCH.

phoebe_vector_raise ()

int                 phoebe_vector_raise                 (PHOEBE_vector *result,
                                                         PHOEBE_vector *fac1,
                                                         PHOEBE_vector *fac2);

Raises all elements of PHOEBE_vector fac1 to the corresponding element of PHOEBE_vector fac2, basically result[i] = fac1[i]^fac2[i].

result :

The placeholder for a return value.

fac1 :

Vector 1.

fac2 :

Vector 2.

Returns :

A PHOEBE_error_code indicating the success of the operation. Possible errors: ERROR_VECTOR_DIMENSIONS_MISMATCH.

phoebe_vector_offset ()

int                 phoebe_vector_offset                (PHOEBE_vector *vec,
                                                         double offset);

Adds offset to all elements of PHOEBE_vector vec.

vec :

PHOEBE_vector to be offset

offset :

offset value.

Returns :

PHOEBE_error_code.

phoebe_vector_sum ()

int                 phoebe_vector_sum                   (PHOEBE_vector *vec,
                                                         double *sum);

Computes a sum of all vector elements.

vec :

PHOEBE_vector for which a sum is computed

sum :

Returns :

PHOEBE_error_code.

phoebe_vector_mean ()

int                 phoebe_vector_mean                  (PHOEBE_vector *vec,
                                                         double *mean);

Computes the mean (arithmetic average) of all vector elements.

vec :

PHOEBE_vector for which a mean is computed

mean :

Returns :

PHOEBE_error_code.

phoebe_vector_median ()

int                 phoebe_vector_median                (PHOEBE_vector *vec,
                                                         double *median);

Sorts the vector elements and returns a median value. The passed vector vec is not changed.

vec :

PHOEBE_vector for which a median is computed

median :

placeholder for the median value

Returns :

PHOEBE_error_code.

phoebe_vector_standard_deviation ()

int                 phoebe_vector_standard_deviation    (PHOEBE_vector *vec,
                                                         double *sigma);

Computes standard deviation (sigma) of vector elements.

vec :

PHOEBE_vector for which standard deviation is computed

sigma :

placeholder for standard deviation value

Returns :

PHOEBE_error_code.

phoebe_vector_multiply_by ()

int                 phoebe_vector_multiply_by           (PHOEBE_vector *vec,
                                                         double factor);

Multiplies all elements of the PHOEBE_vector vec with the scalar value factor.

vec :

PHOEBE_vector to be modified

factor :

scaling factor

Returns :

PHOEBE_error_code.

phoebe_vector_dot_product ()

int                 phoebe_vector_dot_product           (double *result,
                                                         PHOEBE_vector *fac1,
                                                         PHOEBE_vector *fac2);

Returns the scalar (dot) product of two PHOEBE_vectors.

result :

The placeholder for a return value.

fac1 :

Vector 1.

fac2 :

Vector 2.

Returns :

A PHOEBE_error_code indicating the success of the operation. Possible errors: ERROR_VECTOR_DIMENSIONS_MISMATCH.

phoebe_vector_vec_product ()

int                 phoebe_vector_vec_product           (PHOEBE_vector *result,
                                                         PHOEBE_vector *fac1,
                                                         PHOEBE_vector *fac2);

Returns the vector product of the two PHOEBE_vectors. Both fac1 and fac2 need to have exactly 3 elements.

result :

The placeholder for a return value.

fac1 :

Vector 1.

fac2 :

Vector 2.

Returns :

A PHOEBE_error_code indicating the success of the operation. Possible errors: ERROR_VECTOR_DIMENSION_NOT_THREE, and ERROR_VECTOR_DIMENSIONS_MISMATCH.

phoebe_vector_submit ()

int                 phoebe_vector_submit                (PHOEBE_vector *result,
                                                         PHOEBE_vector *vec);

Calculates the functional value of func for each element of vec.

result :

The placeholder for a return value.

vec :

The PHOEBE_vector to submit to func.

Returns :

A PHOEBE_error_code indicating the success of the operation.

phoebe_vector_norm ()

int                 phoebe_vector_norm                  (double *result,
                                                         PHOEBE_vector *vec);

Returns the norm of PHOEBE_vector vec.

result :

The placeholder for a return value.

vec :

The PHOEBE_vector to norm.

Returns :

A PHOEBE_error_code indicating the success of the operation.

phoebe_vector_dim ()

int                 phoebe_vector_dim                   (int *result,
                                                         PHOEBE_vector *vec);

Returns the dimension of vec.

result :

The placeholder for a return value.

vec :

The PHOEBE_vector to examine.

Returns :

A PHOEBE_error_code indicating the success of the operation.

phoebe_vector_randomize ()

int                 phoebe_vector_randomize             (PHOEBE_vector *result,
                                                         double limit);

Fills all vector elements with random numbers from the interval [0, limit]. limit may also be negative, then it's [limit, 0]. The vector must be allocated prior to calling this function.

result :

The placeholder for a return value.

limit :

The upper limit for generated numbers.

Returns :

A PHOEBE_error_code indicating the success of the operation. Possible errors: ERROR_VECTOR_IS_EMPTY.

phoebe_vector_min_max ()

int                 phoebe_vector_min_max               (PHOEBE_vector *vec,
                                                         double *min,
                                                         double *max);

Scans through the dataset of and assigns the minimal and the maximal value encountered to min and max variables.

vec :

The PHOEBE_vector to scan for minimum and maximum.

min :

The placeholder for the minimal value in vec.

max :

The placeholder for the maximal value in vec.

Returns :

A PHOEBE_error_code indicating the success of the operation.

phoebe_vector_min_index ()

int                 phoebe_vector_min_index             (PHOEBE_vector *vec,
                                                         int *index);

Scans through the PHOEBE_vector vec and assigns the index of the lowest value in vec to index.

vec :

The PHOEBE_vector to scan for minimum.

index :

The placeholder for the index of the minimal value in vec.

Returns :

A PHOEBE_error_code indicating the success of the operation.

phoebe_vector_max_index ()

int                 phoebe_vector_max_index             (PHOEBE_vector *vec,
                                                         int *index);

Scans through the PHOEBE_vector vec and assigns the index of the highest value in vec to index.

vec :

The PHOEBE_vector to scan for maximum.

index :

The placeholder for the index of the maximal value in vec.

Returns :

A PHOEBE_error_code indicating the success of the operation.

phoebe_vector_rescale ()

int                 phoebe_vector_rescale               (PHOEBE_vector *vec,
                                                         double ll,
                                                         double ul);

Linearly rescales the values of elements in the vector vec to the [ll, ul] interval.

vec :

The PHOEBE_vector to rescale.

ll :

The lower limit for rescaling.

ul :

The upper limit for rescaling.

Returns :

PHOEBE_error_code.

phoebe_vector_compare ()

bool                phoebe_vector_compare               (PHOEBE_vector *vec1,
                                                         PHOEBE_vector *vec2);

Compares two passed PHOEBE_vectors. It returns TRUE if all vector elements are the same; it returns FALSE otherwise. The comparison is done by comparing the difference of both elements to PHOEBE_NUMERICAL_ACCURACY.

vec1 :

Vector 1.

vec2 :

Vector 2.

Returns :

A boolean indicating whether the two vectors have identical elements.

phoebe_vector_less_than ()

int                 phoebe_vector_less_than             (bool *result,
                                                         PHOEBE_vector *vec1,
                                                         PHOEBE_vector *vec2);

Tests whether *all* vector elements of vec1 are less than their respective counterparts of vec2. If so, TRUE is returned, otherwise FALSE is returned.

result :

The placeholder for the result.

vec1 :

Vector 1.

vec2 :

Vector 2.

Returns :

A PHOEBE_error_code indicating the success of the operation. Possible errors: ERROR_VECTOR_NOT_INITIALIZED and ERROR_VECTOR_DIMENSIONS_MISMATCH.

phoebe_vector_leq_than ()

int                 phoebe_vector_leq_than              (bool *result,
                                                         PHOEBE_vector *vec1,
                                                         PHOEBE_vector *vec2);

Tests whether *all* vector elements of vec1 are less or equal to their respective counterparts of vec2. If so, TRUE is returned, otherwise FALSE is returned.

result :

The placeholder for the result.

vec1 :

Vector 1.

vec2 :

Vector 2.

Returns :

A PHOEBE_error_code indicating the success of the operation. Possible errors: ERROR_VECTOR_NOT_INITIALIZED and ERROR_VECTOR_DIMENSIONS_MISMATCH.

phoebe_vector_greater_than ()

int                 phoebe_vector_greater_than          (bool *result,
                                                         PHOEBE_vector *vec1,
                                                         PHOEBE_vector *vec2);

Tests whether *all* vector elements of vec1 are greater than their respective counterparts of vec2. If so, TRUE is returned, otherwise FALSE is returned.

result :

The placeholder for the result.

vec1 :

Vector 1.

vec2 :

Vector 2.

Returns :

A PHOEBE_error_code indicating the success of the operation. Possible errors: ERROR_VECTOR_NOT_INITIALIZED and ERROR_VECTOR_DIMENSIONS_MISMATCH.

phoebe_vector_geq_than ()

int                 phoebe_vector_geq_than              (bool *result,
                                                         PHOEBE_vector *vec1,
                                                         PHOEBE_vector *vec2);

Tests whether *all* vector elements of vec1 are greater or equal to their respective counterparts of vec2. If so, TRUE is returned, otherwise FALSE is returned.

result :

The placeholder for the result.

vec1 :

Vector 1.

vec2 :

Vector 2.

Returns :

A PHOEBE_error_code indicating the success of the operation. Possible errors: ERROR_VECTOR_NOT_INITIALIZED and ERROR_VECTOR_DIMENSIONS_MISMATCH.

phoebe_vector_append_element ()

int                 phoebe_vector_append_element        (PHOEBE_vector *vec,
                                                         double val);

Appends an element with value val to the PHOEBE_vector vec.

vec :

The vector to extend.

val :

The value to append.

Returns :

A PHOEBE_error_code indicating the success of the operation.

phoebe_vector_remove_element ()

int                 phoebe_vector_remove_element        (PHOEBE_vector *vec,
                                                         int index);

Removes the index-th element from PHOEBE_vector vec.

vec :

The vector to shorten.

index :

The index of the element to be removed.

Returns :

A PHOEBE_error_code indicating the success of the operation. Possible errors: ERROR_INDEX_OUT_OF_RANGE.

PHOEBE_matrix

typedef struct {
	int rows;
	int cols;
	double **val;
} PHOEBE_matrix;

int rows;

The horizontal dimension of the matrix.

int cols;

The vertical dimension of the matrix.

double **val;

The elements of the matrix.

phoebe_matrix_new ()

PHOEBE_matrix*      phoebe_matrix_new                   ();

Initializes an unallocated PHOEBE_matrix.

Returns :

An empty PHOEBE_matrix.

phoebe_matrix_alloc ()

int                 phoebe_matrix_alloc                 (PHOEBE_matrix *matrix,
                                                         int cols,
                                                         int rows);

Allocates storage memory for matrix. The subscripts are such that the elements of matrix should be accessed by matrix[row][col].

matrix :

A PHOEBE_matrix to allocate.

cols :

The number of columns for matrix.

rows :

The number of rows for matrix.

Returns :

A PHOEBE_error_code indicating the success of the operation. Possible errors: ERROR_MATRIX_ALREADY_ALLOCATED and ERROR_MATRIX_INVALID_DIMENSION.

phoebe_matrix_free ()

int                 phoebe_matrix_free                  (PHOEBE_matrix *matrix);

Frees the storage memory allocated for matrix.

matrix :

The PHOEBE_matrix to be freed.

Returns :

A PHOEBE_error_code indicating the success of the operation.

phoebe_matrix_get_row ()

int                 phoebe_matrix_get_row               (PHOEBE_vector *vec,
                                                         PHOEBE_matrix *matrix,
                                                         int row);

Copies the contents of row of matrix to vec, assuming that vec is already allocated.

vec :

The PHOEBE_vector to store the values from row.

matrix :

The PHOEBE_matrix to read row from.

row :

The row of matrix to be copied to vec.

Returns :

A PHOEBE_error_code indicating the success of the operation.

phoebe_matrix_set_row ()

int                 phoebe_matrix_set_row               (PHOEBE_matrix *matrix,
                                                         PHOEBE_vector *vec,
                                                         int row);

Sets the elements of row of matrix to the values of elements in vec.

matrix :

A PHOEBE_matrix to modify.

vec :

The PHOEBE_vector to be placed in matrix.

row :

The row of matrix to be replaced with vec.

Returns :

A PHOEBE_error_code indicating the success of the operation.

PHOEBE_array

typedef struct {
	int              dim;
	PHOEBE_type     type;
	union {
		int      *iarray;
		double   *darray;
		bool     *barray;
		char  **strarray;
	} val;
} PHOEBE_array;

int dim;

The size of the array.

PHOEBE_type type;

The type of the array.

phoebe_array_new ()

PHOEBE_array*       phoebe_array_new                    (PHOEBE_type type);

type :

Returns :


phoebe_array_new_from_qualifier ()

PHOEBE_array*       phoebe_array_new_from_qualifier     (char *qualifier);

qualifier :

Returns :


phoebe_array_new_from_column ()

PHOEBE_array*       phoebe_array_new_from_column        (char *filename,
                                                         int col);

Reads in the col-th column from file filename, parses it and stores it into the returned array. The first element determines the type of the array.

filename :

absolute path to the file to be read.

col :

column to be read.

Returns :

PHOEBE_array, or NULL if an error occured.

phoebe_array_alloc ()

int                 phoebe_array_alloc                  (PHOEBE_array *array,
                                                         int dimension);

array :

dimension :

Returns :


phoebe_array_realloc ()

int                 phoebe_array_realloc                (PHOEBE_array *array,
                                                         int dimension);

array :

dimension :

Returns :


phoebe_array_duplicate ()

PHOEBE_array*       phoebe_array_duplicate              (PHOEBE_array *array);

array :

Returns :


phoebe_array_compare ()

bool                phoebe_array_compare                (PHOEBE_array *array1,
                                                         PHOEBE_array *array2);

Compares two passed PHOEBE_arrays. It returns TRUE if all array elements are the same; it returns FALSE otherwise. In cases of double precision numbers the comparison is done by comparing the difference of both elements to PHOEBE_NUMERICAL_ACCURACY.

array1 :

Array 1.

array2 :

Array 2.

Returns :

Boolean indicating whether the two arrays have identical elements.

phoebe_array_free ()

int                 phoebe_array_free                   (PHOEBE_array *array);

array :

Returns :


phoebe_vector_new_from_array ()

PHOEBE_vector*      phoebe_vector_new_from_array        (PHOEBE_array *array);

Converts the array of doubles into PHOEBE_vector.

array :

PHOEBE_array of type TYPE_INT or TYPE_DOUBLE

Returns :

PHOEBE_vector, or NULL in case of failure.

PHOEBE_hist

typedef struct {
	int bins;
	double *range;
	double *val;
} PHOEBE_hist;

int bins;

Number of histogram bins.

double *range;

A vector of histogram ranges.

double *val;

A vector of histogram values.

enum PHOEBE_hist_rebin_type

typedef enum PHOEBE_hist_rebin_type {
	PHOEBE_HIST_CONSERVE_VALUES = 20,
	PHOEBE_HIST_CONSERVE_DENSITY
} PHOEBE_hist_rebin_type;

There are two ways to rebin a histogram:

1) conserve the values and 2) conserve the value densities.

The first option is better if we are degrading the histogram, and the second option is better if we are oversampling the histogram.

PHOEBE_HIST_CONSERVE_VALUES

When rebinning, conserve the values.

PHOEBE_HIST_CONSERVE_DENSITY

When rebinning, conserve the densities.

phoebe_hist_new ()

PHOEBE_hist*        phoebe_hist_new                     ();

Returns :


phoebe_hist_new_from_arrays ()

PHOEBE_hist*        phoebe_hist_new_from_arrays         (int bins,
                                                         double *binarray,
                                                         double *valarray);

bins :

binarray :

valarray :

Returns :


phoebe_hist_new_from_file ()

PHOEBE_hist*        phoebe_hist_new_from_file           (char *filename);

filename :

Returns :


phoebe_hist_duplicate ()

PHOEBE_hist*        phoebe_hist_duplicate               (PHOEBE_hist *hist);

hist :

Returns :


phoebe_hist_alloc ()

int                 phoebe_hist_alloc                   (PHOEBE_hist *hist,
                                                         int bins);

hist :

bins :

Returns :


phoebe_hist_realloc ()

int                 phoebe_hist_realloc                 (PHOEBE_hist *hist,
                                                         int bins);

hist :

bins :

Returns :


phoebe_hist_free ()

int                 phoebe_hist_free                    (PHOEBE_hist *hist);

hist :

Returns :


phoebe_hist_set_ranges ()

int                 phoebe_hist_set_ranges              (PHOEBE_hist *hist,
                                                         PHOEBE_vector *bin_centers);

hist :

bin_centers :

Returns :


phoebe_hist_set_values ()

int                 phoebe_hist_set_values              (PHOEBE_hist *hist,
                                                         PHOEBE_vector *values);

Sets bin values to the passed vector elements. The histogram hist must be initialized and allocated, and the dimension of values must match the number of bins.

hist :

histogram to be modified

values :

a vector of values to be copied to the histogram

Returns :

PHOEBE_error_code.

phoebe_hist_get_bin_centers ()

int                 phoebe_hist_get_bin_centers         (PHOEBE_hist *hist,
                                                         PHOEBE_vector *bin_centers);

hist :

bin_centers :

Returns :


phoebe_hist_get_bin ()

int                 phoebe_hist_get_bin                 (int *bin,
                                                         PHOEBE_hist *hist,
                                                         double r);

bin :

hist :

r :

Returns :


phoebe_hist_evaluate ()

int                 phoebe_hist_evaluate                (double *y,
                                                         PHOEBE_hist *hist,
                                                         double x);

y :

hist :

x :

Returns :


phoebe_hist_integrate ()

int                 phoebe_hist_integrate               (double *integral,
                                                         PHOEBE_hist *hist,
                                                         double ll,
                                                         double ul);

This function integrates the passed histogram hist from ll to ul by a simple rectangular scheme.

integral :

placeholder for the integral value

hist :

histogram to be integrated

ll :

lower integral limit

ul :

upper integral limit

Returns :

PHOEBE_error_code.

phoebe_hist_shift ()

int                 phoebe_hist_shift                   (PHOEBE_hist *hist,
                                                         double shift);

Shifts the contents of the histogram hist in pixel-space by the passed shift. If shift is positive, the contents are shifted to the right; if it is negative, they are shifted to the left. The bin structure is retained, the bins outside the shifted range are padded with 0.

hist :

histogram to be shifted

shift :

pixel-space shift

Returns :

PHOEBE_error_code.

phoebe_hist_correlate ()

int                 phoebe_hist_correlate               (double *cfval,
                                                         PHOEBE_hist *h1,
                                                         PHOEBE_hist *h2,
                                                         double sigma1,
                                                         double sigma2,
                                                         double ll,
                                                         double ul,
                                                         double xi);

cfval :

h1 :

h2 :

sigma1 :

sigma2 :

ll :

ul :

xi :

Returns :


phoebe_hist_pad ()

int                 phoebe_hist_pad                     (PHOEBE_hist *hist,
                                                         double val);

hist :

val :

Returns :


phoebe_hist_crop ()

int                 phoebe_hist_crop                    (PHOEBE_hist *hist,
                                                         double ll,
                                                         double ul);

hist :

ll :

ul :

Returns :


phoebe_hist_compare ()

bool                phoebe_hist_compare                 (PHOEBE_hist *hist1,
                                                         PHOEBE_hist *hist2);

Compares the contents of histograms hist1 and hist2. All ranges and values are compared by evaluating the absolute difference between the elements and comparing that to PHOEBE_NUMERICAL_ACCURACY.

hist1 :

histogram 1 to be compared

hist2 :

histogram 2 to be compared

Returns :

TRUE if the histograms are the same, FALSE otherwise.

phoebe_hist_resample ()

int                 phoebe_hist_resample                (PHOEBE_hist *out,
                                                         PHOEBE_hist *in,
                                                         PHOEBE_hist_rebin_type type);

out :

in :

type :

Returns :


phoebe_hist_rebin ()

int                 phoebe_hist_rebin                   (PHOEBE_hist *out,
                                                         PHOEBE_hist *in,
                                                         PHOEBE_hist_rebin_type type);

out :

in :

type :

Returns :


PHOEBE_ld

typedef struct {
	char *set;
	char *name;
	char *reftable;
	PHOEBE_vector *lin_x;
	PHOEBE_vector *log_x;
	PHOEBE_vector *log_y;
	PHOEBE_vector *sqrt_x;
	PHOEBE_vector *sqrt_y;
} PHOEBE_ld;


PHOEBE_passband

typedef struct {
	int          id;
	char        *set;
	char        *name;
	double       effwl;
	PHOEBE_hist *tf;
	PHOEBE_ld   *ld;
} PHOEBE_passband;

int id;

ID number of the passband

char *set;

Filter-set of the passband, i.e. "Cousins"

char *name;

Passband identifier, i.e. "Rc"

double effwl;

Effective wavelength of the passband.

PHOEBE_hist *tf;

Passband transmission function

PHOEBE_ld *ld;

Limb darkening table (attached optionally)

enum PHOEBE_curve_type

typedef enum PHOEBE_curve_type {
	PHOEBE_CURVE_UNDEFINED,
	PHOEBE_CURVE_LC,
	PHOEBE_CURVE_RV
} PHOEBE_curve_type;

PHOEBE_CURVE_UNDEFINED

The type of the curve is unknown.

PHOEBE_CURVE_LC

A light curve.

PHOEBE_CURVE_RV

A radial velocity curve.

phoebe_curve_type_get_name ()

int                 phoebe_curve_type_get_name          (PHOEBE_curve_type ctype,
                                                         char **name);

ctype :

name :

Returns :


enum PHOEBE_column_type

typedef enum PHOEBE_column_type {
	PHOEBE_COLUMN_UNDEFINED,
	PHOEBE_COLUMN_HJD,
	PHOEBE_COLUMN_PHASE,
	PHOEBE_COLUMN_MAGNITUDE,
	PHOEBE_COLUMN_FLUX,
	PHOEBE_COLUMN_PRIMARY_RV,
	PHOEBE_COLUMN_SECONDARY_RV,
	PHOEBE_COLUMN_SIGMA,
	PHOEBE_COLUMN_WEIGHT,
	PHOEBE_COLUMN_INVALID
} PHOEBE_column_type;

Various sorts of data that can be found in files usable by Phoebe.


phoebe_column_type_get_name ()

int                 phoebe_column_type_get_name         (PHOEBE_column_type ctype,
                                                         char **name);

ctype :

name :

Returns :


phoebe_column_get_type ()

int                 phoebe_column_get_type              (PHOEBE_column_type *type,
                                                         const char *string);

Parses the passed string and converts it to the enumerated type of the column (PHOEBE_column_type).

type :

placeholder for the enumerated column type

string :

string representation of the column type

Returns :

PHOEBE_error_code.

enum PHOEBE_data_flag

typedef enum PHOEBE_data_flag {
	PHOEBE_DATA_REGULAR,
	PHOEBE_DATA_ALIASED,
	PHOEBE_DATA_DELETED,
	PHOEBE_DATA_OMITTED
} PHOEBE_data_flag;


PHOEBE_curve

typedef struct {
	PHOEBE_curve_type  type;
	PHOEBE_passband   *passband;
	PHOEBE_vector     *indep;
	PHOEBE_vector     *dep;
	PHOEBE_vector     *weight;
	PHOEBE_array      *flag;
	PHOEBE_column_type itype;
	PHOEBE_column_type dtype;
	PHOEBE_column_type wtype;
	char              *filename;
	double             sigma;
} PHOEBE_curve;

PHOEBE_curve_type type;

Type of the curve.

PHOEBE_passband *passband;

Passband of the curve.

PHOEBE_vector *indep;

Elements of the independant variable vector.

PHOEBE_vector *dep;

Elements of the dependant variable vector.

PHOEBE_vector *weight;

Elements of the weight vector.

PHOEBE_array *flag;

data flag of the enumerated PHOEBE_data_flag type

PHOEBE_column_type itype;

Column type of the independant variable.

PHOEBE_column_type dtype;

Column type of the dependant variable.

PHOEBE_column_type wtype;

Column type of the weights.

char *filename;

Absolute path to the file containing the curve.

double sigma;

Sigma value of the curve.

phoebe_curve_new ()

PHOEBE_curve*       phoebe_curve_new                    ();

Returns :


phoebe_curve_new_from_file ()

PHOEBE_curve*       phoebe_curve_new_from_file          (char *filename);

filename :

Returns :


phoebe_curve_new_from_pars ()

PHOEBE_curve*       phoebe_curve_new_from_pars          (PHOEBE_curve_type ctype,
                                                         int index);

ctype :

index :

Returns :


phoebe_curve_duplicate ()

PHOEBE_curve*       phoebe_curve_duplicate              (PHOEBE_curve *curve);

curve :

Returns :


phoebe_curve_alloc ()

int                 phoebe_curve_alloc                  (PHOEBE_curve *curve,
                                                         int dim);

curve :

dim :

Returns :


phoebe_curve_realloc ()

int                 phoebe_curve_realloc                (PHOEBE_curve *curve,
                                                         int dim);

Reallocates storage memory for PHOEBE_curve curve.

curve :

PHOEBE_curve to reallocate.

dim :

the new size of curve.

Returns :

PHOEBE_error_code. Error codes: ERROR_CURVE_INVALID_DIMENSION SUCCESS

phoebe_curve_compute ()

int                 phoebe_curve_compute                (PHOEBE_curve *curve,
                                                         PHOEBE_vector *nodes,
                                                         int index,
                                                         PHOEBE_column_type itype,
                                                         PHOEBE_column_type dtype);

Computes the index-th model light curve or RV curve in nodes. The computation is governed by the enumerated choices of itype and dtype.

curve :

a pointer to the initialized PHOEBE_curve

nodes :

a vector of nodes in which the curve should be computed

index :

curve index

itype :

requested independent data type (see PHOEBE_column_type)

dtype :

requested dependent data type (see PHOEBE_column_type)

Returns :

PHOEBE_error_code.

phoebe_curve_transform ()

int                 phoebe_curve_transform              (PHOEBE_curve *curve,
                                                         PHOEBE_column_type itype,
                                                         PHOEBE_column_type dtype,
                                                         PHOEBE_column_type wtype);

Transforms curve columns to requested types.

curve :

PHOEBE_curve to be transformed

itype :

requested independent variable (time or phase)

dtype :

requested dependent variable (flux, magnitude, RV)

wtype :

requested weight variable (standard weight, standard deviation, none)

Returns :

PHOEBE_error_code.

phoebe_curve_alias ()

int                 phoebe_curve_alias                  (PHOEBE_curve *curve,
                                                         double phmin,
                                                         double phmax);

This function redimensiones the array of data phases by aliasing points to outside the [-0.5, 0.5] range. If the new interval is narrower, the points are omitted, otherwise they are aliased.

curve :

curve to be aliased

phmin :

start phase

phmax :

end phase

Returns :

PHOEBE_error_code.

phoebe_curve_set_properties ()

int                 phoebe_curve_set_properties         (PHOEBE_curve *curve,
                                                         PHOEBE_curve_type type,
                                                         char *filename,
                                                         PHOEBE_passband *passband,
                                                         PHOEBE_column_type itype,
                                                         PHOEBE_column_type dtype,
                                                         PHOEBE_column_type wtype,
                                                         double sigma);

curve :

type :

filename :

passband :

itype :

dtype :

wtype :

sigma :

Returns :


phoebe_curve_free ()

int                 phoebe_curve_free                   (PHOEBE_curve *curve);

curve :

Returns :


enum PHOEBE_spectrum_dispersion

typedef enum PHOEBE_spectrum_dispersion {
	PHOEBE_SPECTRUM_DISPERSION_LINEAR,
	PHOEBE_SPECTRUM_DISPERSION_LOG,
	PHOEBE_SPECTRUM_DISPERSION_NONE
} PHOEBE_spectrum_dispersion;

Spectrum dispersion tells us how dx is connected to dlambda. If the dispersion is linear, then dx is proportional to dlambda. If it is log, dx is proportional to dlambda/lambda. If there is no dispersion function, that means that there is no simple transformation from wavelength space to pixel space. In that case everything must be done according to histogram ranges.


PHOEBE_spectrum

typedef struct {
	double  R;
	double  Rs;
	PHOEBE_spectrum_dispersion disp;
	PHOEBE_hist *data;
} PHOEBE_spectrum;

The spectrum structure is defined here, but the manipulation functions reside in phoebe_spectra files.


enum PHOEBE_minimizer_type

typedef enum PHOEBE_minimizer_type {
	PHOEBE_MINIMIZER_NMS,
	PHOEBE_MINIMIZER_DC
} PHOEBE_minimizer_type;

The available minimizers.

PHOEBE_MINIMIZER_NMS

The Nead-Medler minimizer.

PHOEBE_MINIMIZER_DC

The differential-corrections minimizer.

phoebe_minimizer_type_get_name ()

int                 phoebe_minimizer_type_get_name      (PHOEBE_minimizer_type minimizer,
                                                         char **name);

minimizer :

name :

Returns :


PHOEBE_minimizer_feedback

typedef struct {
	PHOEBE_minimizer_type algorithm;
	bool             converged;
	double           cputime;
	int              iters;
	double           cfval;
	PHOEBE_array    *qualifiers;
	PHOEBE_vector   *initvals;
	PHOEBE_vector   *newvals;
	PHOEBE_vector   *ferrors;
	PHOEBE_vector   *chi2s;
	PHOEBE_vector   *wchi2s;
	PHOEBE_matrix   *cormat;
} PHOEBE_minimizer_feedback;

PHOEBE_minimizer_type algorithm;

Minimizer (algorithm) type

bool converged;

double cputime;

CPU time required for algorithm execution

int iters;

Number of performed iterations

double cfval;

Cost function value (combined chi2)

PHOEBE_array *qualifiers;

A list of TBA qualifiers

PHOEBE_vector *initvals;

A list of initial parameter values

PHOEBE_vector *newvals;

A list of new parameter values

PHOEBE_vector *ferrors;

A list of formal error estimates

PHOEBE_vector *chi2s;

A list of passband chi2 values

PHOEBE_vector *wchi2s;

A list of weighted passband chi2 values

PHOEBE_matrix *cormat;

Correlation matrix

phoebe_minimizer_feedback_new ()

PHOEBE_minimizer_feedback* phoebe_minimizer_feedback_new
                                                        ();

Returns :


phoebe_minimizer_feedback_duplicate ()

PHOEBE_minimizer_feedback* phoebe_minimizer_feedback_duplicate
                                                        (PHOEBE_minimizer_feedback *feedback);

feedback :

Returns :


phoebe_minimizer_feedback_alloc ()

int                 phoebe_minimizer_feedback_alloc     (PHOEBE_minimizer_feedback *feedback,
                                                         int tba,
                                                         int cno);

feedback :

tba :

cno :

Returns :


phoebe_minimizer_feedback_accept ()

int                 phoebe_minimizer_feedback_accept    (PHOEBE_minimizer_feedback *feedback);

Traverses through all the parameters stored in the feedback structure and copies the values to the currently active parameter table. After all the values have been updated, the function satisfies all constraints as well.

feedback :

minimizer feedback with new values of parameters.

Returns :

PHOEBE_error_code.

phoebe_minimizer_feedback_free ()

int                 phoebe_minimizer_feedback_free      (PHOEBE_minimizer_feedback *feedback);

feedback :

Returns :


phoebe_spectrum_duplicate ()

PHOEBE_spectrum*    phoebe_spectrum_duplicate           (PHOEBE_spectrum *spectrum);

Makes a duplicate copy of spectrum.

spectrum :

Returns :


phoebe_value_duplicate ()

PHOEBE_value        phoebe_value_duplicate              (PHOEBE_type type,
                                                         PHOEBE_value val);

type :

val :

Returns :