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.

phoebe_type_get_name ()

char*               phoebe_type_get_name                (PHOEBE_type type);

PHOEBE_vector

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

phoebe_vector_new ()

PHOEBE_vector*      phoebe_vector_new                   ();

Initializes a vector for allocation.

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.

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.

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.

phoebe_vector_duplicate ()

PHOEBE_vector*      phoebe_vector_duplicate             (PHOEBE_vector *vec);

Makes a duplicate copy of PHOEBE_vector vec.

phoebe_vector_alloc ()

int                 phoebe_vector_alloc                 (PHOEBE_vector *vec,
                                                         int dimension);

Allocates storage memory for a PHOEBE_vector of dimension.

phoebe_vector_realloc ()

int                 phoebe_vector_realloc               (PHOEBE_vector *vec,
                                                         int dimension);

Reallocates storage memory for a PHOEBE_vector of dimension.

phoebe_vector_pad ()

int                 phoebe_vector_pad                   (PHOEBE_vector *vec,
                                                         double value);

Pads all components of vec with value.

phoebe_vector_free ()

int                 phoebe_vector_free                  (PHOEBE_vector *vec);

Frees the storage memory allocated for PHOEBE_vector vec.

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.

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.

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.

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.

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].

phoebe_vector_offset ()

int                 phoebe_vector_offset                (PHOEBE_vector *vec,
                                                         double offset);

Adds offset to all elements of PHOEBE_vector vec.

phoebe_vector_sum ()

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

Computes a sum of all vector elements.

phoebe_vector_mean ()

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

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

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.

phoebe_vector_standard_deviation ()

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

Computes standard deviation (sigma) of vector elements.

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.

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.

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.

phoebe_vector_submit ()

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

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

phoebe_vector_norm ()

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

Returns the norm of PHOEBE_vector vec.

phoebe_vector_dim ()

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

Returns the dimension of vec.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

phoebe_vector_remove_element ()

int                 phoebe_vector_remove_element        (PHOEBE_vector *vec,
                                                         int index);

Removes the index-th element from PHOEBE_vector vec.

PHOEBE_matrix

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

phoebe_matrix_new ()

PHOEBE_matrix*      phoebe_matrix_new                   ();

Initializes an unallocated 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].

phoebe_matrix_free ()

int                 phoebe_matrix_free                  (PHOEBE_matrix *matrix);

Frees the storage memory allocated for matrix.

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.

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.

PHOEBE_array

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

phoebe_array_new ()

PHOEBE_array*       phoebe_array_new                    (PHOEBE_type type);

phoebe_array_new_from_qualifier ()

PHOEBE_array*       phoebe_array_new_from_qualifier     (char *qualifier);

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.

phoebe_array_alloc ()

int                 phoebe_array_alloc                  (PHOEBE_array *array,
                                                         int dimension);

phoebe_array_realloc ()

int                 phoebe_array_realloc                (PHOEBE_array *array,
                                                         int dimension);

phoebe_array_duplicate ()

PHOEBE_array*       phoebe_array_duplicate              (PHOEBE_array *array);

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.

phoebe_array_free ()

int                 phoebe_array_free                   (PHOEBE_array *array);

phoebe_vector_new_from_array ()

PHOEBE_vector*      phoebe_vector_new_from_array        (PHOEBE_array *array);

Converts the array of doubles into PHOEBE_vector.

PHOEBE_hist

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

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_new ()

PHOEBE_hist*        phoebe_hist_new                     ();

phoebe_hist_new_from_arrays ()

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

phoebe_hist_new_from_file ()

PHOEBE_hist*        phoebe_hist_new_from_file           (char *filename);

phoebe_hist_duplicate ()

PHOEBE_hist*        phoebe_hist_duplicate               (PHOEBE_hist *hist);

phoebe_hist_alloc ()

int                 phoebe_hist_alloc                   (PHOEBE_hist *hist,
                                                         int bins);

phoebe_hist_realloc ()

int                 phoebe_hist_realloc                 (PHOEBE_hist *hist,
                                                         int bins);

phoebe_hist_free ()

int                 phoebe_hist_free                    (PHOEBE_hist *hist);

phoebe_hist_set_ranges ()

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

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.

phoebe_hist_get_bin_centers ()

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

phoebe_hist_get_bin ()

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

phoebe_hist_evaluate ()

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

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.

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.

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);

phoebe_hist_pad ()

int                 phoebe_hist_pad                     (PHOEBE_hist *hist,
                                                         double val);

phoebe_hist_crop ()

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

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.

phoebe_hist_resample ()

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

phoebe_hist_rebin ()

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

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;

enum PHOEBE_curve_type

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

phoebe_curve_type_get_name ()

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

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);

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).

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_new ()

PHOEBE_curve*       phoebe_curve_new                    ();

phoebe_curve_new_from_file ()

PHOEBE_curve*       phoebe_curve_new_from_file          (char *filename);

phoebe_curve_new_from_pars ()

PHOEBE_curve*       phoebe_curve_new_from_pars          (PHOEBE_curve_type ctype,
                                                         int index);

phoebe_curve_duplicate ()

PHOEBE_curve*       phoebe_curve_duplicate              (PHOEBE_curve *curve);

phoebe_curve_alloc ()

int                 phoebe_curve_alloc                  (PHOEBE_curve *curve,
                                                         int dim);

phoebe_curve_realloc ()

int                 phoebe_curve_realloc                (PHOEBE_curve *curve,
                                                         int dim);

Reallocates storage memory for PHOEBE_curve curve.

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.

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.

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.

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);

phoebe_curve_free ()

int                 phoebe_curve_free                   (PHOEBE_curve *curve);

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_type_get_name ()

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

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_feedback_new ()

PHOEBE_minimizer_feedback* phoebe_minimizer_feedback_new
                                                        ();

phoebe_minimizer_feedback_duplicate ()

PHOEBE_minimizer_feedback* phoebe_minimizer_feedback_duplicate
                                                        (PHOEBE_minimizer_feedback *feedback);

phoebe_minimizer_feedback_alloc ()

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

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.

phoebe_minimizer_feedback_free ()

int                 phoebe_minimizer_feedback_free      (PHOEBE_minimizer_feedback *feedback);

phoebe_spectrum_duplicate ()

PHOEBE_spectrum*    phoebe_spectrum_duplicate           (PHOEBE_spectrum *spectrum);

Makes a duplicate copy of spectrum.

phoebe_value_duplicate ()

PHOEBE_value        phoebe_value_duplicate              (PHOEBE_type type,
                                                         PHOEBE_value val);