Aprepro 5.0x

Namespaces | Classes | Functions | Variables
SEAMS Namespace Reference

## Namespaces
| anonymous_namespace{apr_units.cc}

## Classes
class | Aprepro
struct | aprepro_options
struct | array
struct | file_rec
struct | history_data
class | Parser
| A Bison parser. More...
class | Scanner
class | Stats
struct | symrec

## Functions
double | array_interpolate (const array *arr, double row, double col)
double | array_value (array *arr, double row, double col)
array * | array_add (const array *a, const array *b)
array * | array_sub (const array *a, const array *b)
array * | array_scale (const array *a, double s)
array * | array_mult (const array *a, const array *b)
double | do_time ()
double | do_int (double x)
double | do_nint (double x)
double | do_dist (double x1, double y1, double x2, double y2)
double | do_angle (double x1, double y1, double x2, double y2)
double | do_angled (double x1, double y1, double x2, double y2)
double | do_hypot (double x, double y)
double | do_max (double x, double y)
double | do_min (double x, double y)
double | do_d2r (double x)
double | do_r2d (double x)
double | do_sind (double x)
double | do_sin (double x)
double | do_cosd (double x)
double | do_cos (double x)
double | do_tand (double x)
double | do_tan (double x)
double | do_atan2d (double x, double y)
double | do_atan2 (double x, double y)
double | do_atand (double x)
double | do_atan (double x)
double | do_asind (double x)
double | do_asin (double x)
double | do_acosd (double x)
double | do_acos (double x)
double | do_srand (double seed)
double | do_rand (double xl, double xh)
double | do_rand_normal (double mean, double stddev)
double | do_rand_lognormal (double mean, double stddev)
double | do_rand_weibull (double alpha, double beta)
double | do_sign (double x, double y)
double | do_dim (double x, double y)
double | do_fabs (double x)
double | do_ceil (double x)
double | do_cosh (double x)
double | do_exp (double x)
double | do_expm1 (double x)
double | do_floor (double x)
double | do_fmod (double x, double y)
double | do_log (double x)
double | do_log10 (double x)
double | do_sinh (double x)
double | do_sqrt (double x)
double | do_tanh (double x)
double | do_polarX (double rad, double ang)
double | do_polarY (double rad, double ang)
double | do_lgamma (double val)
double | do_juldayhms (double mon, double day, double year, double h, double mi, double se)
double | do_julday (double mon, double day, double year)
double | do_log1p (double x)
double | do_acosh (double x)
double | do_asinh (double x)
double | do_atanh (double x)
double | do_rows (const array *arr)
double | do_cols (const array *arr)
const char * | do_get_date ()
const char * | do_get_iso_date ()
const char * | do_get_time ()
const char * | do_tolower (char *string)
const char * | do_toupper (char *string)
const char * | do_tostring (double x)
const char * | do_output (char *filename)
const char * | do_append (char *filename)
double | do_word_count (char *string, char *delm)
double | do_find_word (char *word, char *string, char *delm)
const char * | do_get_word (double n, char *string, char *delm)
const char * | do_file_to_string (char *filename)
const char * | do_getenv (char *env)
double | do_strtod (char *string)
const char * | do_dumpsym ()
const char * | do_dumpfunc ()
const char * | do_dumpvar ()
const char * | do_dumpsym1 (char *pre)
const char * | do_dumpfunc1 (char *pre)
const char * | do_dumpvar1 (char *pre)
double | do_option (char *option, double value)
const char * | do_include_path (char *new_path)
const char * | do_intout (double intval)
const char * | do_execute (char *string)
const char * | do_rescan (char *string)
const char * | do_if (double x)
const char * | do_notif (double x)
const char * | do_elseif (double x)
const char * | do_str_if (char *string)
const char * | do_str_notif (char *string)
const char * | do_str_elseif (char *string)
const char * | do_switch (double x)
const char * | do_case (double x)
const char * | do_extract (char *string, char *begin, char *end)
const char * | do_get_temp_filename ()
const char * | do_error (char *error_string)
const char * | do_print_array (const array *my_array_data)
const char * | do_delete (char *string)
array * | do_make_array (double rows, double cols)
array * | do_make_array_init (double rows, double cols, double init)
array * | do_identity (double size)
array * | do_linear_array (double init, double final, double count)
array * | do_transpose (const array *a)
array * | do_csv_array1 (const char *filename)
array * | do_csv_array (const char *filename, double skip)
array * | do_csv_array2 (const char *filename, const char *comment)
array * | do_array_from_string (const char *string, const char *delm)
const char * | do_Units (char *type)
const char * | do_print_array (array *my_array_data)
const char * | get_temp_filename (void)
char * | pathopen (const char *file)
void | conv_string (const char *string)
void | yyerror (const char *s)
std::vector< std::string > | tokenize (const std::string &str, const std::string &separators)
bool | arg_check (SEAMS::symrec *symbol, bool is_null)
void | set_type (const SEAMS::Aprepro &apr, SEAMS::symrec *var, int type)
void | new_string (const std::string &from, char **to)
void | new_string (const char *from, char **to)
void | concat_string (const char *from1, const char *from2, char **to)
void | yyerror (const SEAMS::Aprepro &apr, const std::string &s)
void | immutable_modify (const SEAMS::Aprepro &apr, const SEAMS::symrec *var)
void | undefined_error (const SEAMS::Aprepro &apr, const std::string &var)
void | redefined_warning (const SEAMS::Aprepro &apr, const SEAMS::symrec *var)
void | warning (const SEAMS::Aprepro &apr, const std::string &s)
void | math_error (const SEAMS::Aprepro &apr, const char *function)
void | math_error (const char *function)
void | conv_string (char *string)
void | cleanup_memory ()
bool | is_directory (const std::string &filepath)
bool | check_valid_var (const char *var)

## Variables
Aprepro * | aprepro = nullptr
bool | echo = true
double | cof []
init | arith_0_fncts []
init_d | arith_fncts []
init_a | arith_a_fncts []
init_dd | arith_dd_fncts []
init_dddd | arith_dddd_fncts []
init_cc | arith_cc_fncts []
init_ccc | arith_ccc_fncts []
init_c | arith_c_fncts []
init_cd | arith_cd_fncts []
init_ddd | arith_ddd_fncts []
init_dddddd | arith_dddddd_fncts []
str_init | string_fncts []
str_c_init | string_c_fncts []
str_d_init | string_d_fncts []
str_dcc_init | string_dcc_fncts []
str_ccc_init | string_ccc_fncts []
str_cc_init | string_cc_fncts []
str_a_init | string_a_fncts []
array_c_init | array_c_fncts []
array_cd_init | array_cd_fncts []
array_cc_init | array_cc_fncts []
array_ddd_init | array_ddd_fncts []
array_dd_init | array_dd_fncts []
array_d_init | array_d_fncts []
array_a_init | array_a_fncts []
var_init | variables []
svar_init | svariables []

## Detailed Description

The SEAMS namespace is used to encapsulate the three parser classes SEAMS::Parser, SEAMS::Scanner and SEAMS::Aprepro

## Function Documentation

## ◆ arg_check()

bool SEAMS::arg_check | ( | SEAMS::symrec * | symbol,
|  | bool | is_null
| ) |  |

## ◆ array_add()

array * SEAMS::array_add | ( | const array * | a,
|  | const array * | b
| ) |  |

## ◆ array_interpolate()

double SEAMS::array_interpolate | ( | const array * | arr,
|  | double | row,
|  | double | col
| ) |  |

## ◆ array_mult()

array * SEAMS::array_mult | ( | const array * | a,
|  | const array * | b
| ) |  |

## ◆ array_scale()

array * SEAMS::array_scale | ( | const array * | a,
|  | double | s
| ) |  |

## ◆ array_sub()

array * SEAMS::array_sub | ( | const array * | a,
|  | const array * | b
| ) |  |

## ◆ array_value()

double SEAMS::array_value | ( | array * | arr,
|  | double | row,
|  | double | col
| ) |  |

## ◆ check_valid_var()

bool SEAMS::check_valid_var | ( | const char * | var | ) |

## ◆ cleanup_memory()

void SEAMS::cleanup_memory | ( |  | ) |

## ◆ concat_string()

void SEAMS::concat_string | ( | const char * | from1,
|  | const char * | from2,
|  | char ** | to
| ) |  |

## ◆ conv_string() [1/2]

void SEAMS::conv_string | ( | char * | string | ) |

## ◆ conv_string() [2/2]

void SEAMS::conv_string | ( | const char * | string | ) |

## ◆ do_acos()

double SEAMS::do_acos | ( | double | x | ) |

## ◆ do_acosd()

double SEAMS::do_acosd | ( | double | x | ) |

## ◆ do_acosh()

double SEAMS::do_acosh | ( | double | x | ) |

## ◆ do_angle()

double SEAMS::do_angle | ( | double | x1,
|  | double | y1,
|  | double | x2,
|  | double | y2
| ) |  |

## ◆ do_angled()

double SEAMS::do_angled | ( | double | x1,
|  | double | y1,
|  | double | x2,
|  | double | y2
| ) |  |

## ◆ do_append()

const char * SEAMS::do_append | ( | char * | filename | ) |

## ◆ do_array_from_string()

array * SEAMS::do_array_from_string | ( | const char * | string,
|  | const char * | delm
| ) |  |

## ◆ do_asin()

double SEAMS::do_asin | ( | double | x | ) |

## ◆ do_asind()

double SEAMS::do_asind | ( | double | x | ) |

## ◆ do_asinh()

double SEAMS::do_asinh | ( | double | x | ) |

## ◆ do_atan()

double SEAMS::do_atan | ( | double | x | ) |

## ◆ do_atan2()

double SEAMS::do_atan2 | ( | double | x,
|  | double | y
| ) |  |

## ◆ do_atan2d()

double SEAMS::do_atan2d | ( | double | x,
|  | double | y
| ) |  |

## ◆ do_atand()

double SEAMS::do_atand | ( | double | x | ) |

## ◆ do_atanh()

double SEAMS::do_atanh | ( | double | x | ) |

## ◆ do_case()

const char * SEAMS::do_case | ( | double | x | ) |

## ◆ do_ceil()

double SEAMS::do_ceil | ( | double | x | ) |

## ◆ do_cols()

double SEAMS::do_cols | ( | const array * | arr | ) |

## ◆ do_cos()

double SEAMS::do_cos | ( | double | x | ) |

## ◆ do_cosd()

double SEAMS::do_cosd | ( | double | x | ) |

## ◆ do_cosh()

double SEAMS::do_cosh | ( | double | x | ) |

## ◆ do_csv_array()

array * SEAMS::do_csv_array | ( | const char * | filename,
|  | double | skip
| ) |  |

## ◆ do_csv_array1()

array * SEAMS::do_csv_array1 | ( | const char * | filename | ) |

## ◆ do_csv_array2()

array * SEAMS::do_csv_array2 | ( | const char * | filename,
|  | const char * | comment
| ) |  |

## ◆ do_d2r()

double SEAMS::do_d2r | ( | double | x | ) |

## ◆ do_delete()

const char * SEAMS::do_delete | ( | char * | string | ) |

## ◆ do_dim()

double SEAMS::do_dim | ( | double | x,
|  | double | y
| ) |  |

## ◆ do_dist()

double SEAMS::do_dist | ( | double | x1,
|  | double | y1,
|  | double | x2,
|  | double | y2
| ) |  |

## ◆ do_dumpfunc()

const char * SEAMS::do_dumpfunc | ( |  | ) |

## ◆ do_dumpfunc1()

const char * SEAMS::do_dumpfunc1 | ( | char * | pre | ) |

## ◆ do_dumpsym()

const char * SEAMS::do_dumpsym | ( |  | ) |

## ◆ do_dumpsym1()

const char * SEAMS::do_dumpsym1 | ( | char * | pre | ) |

## ◆ do_dumpvar()

const char * SEAMS::do_dumpvar | ( |  | ) |

## ◆ do_dumpvar1()

const char * SEAMS::do_dumpvar1 | ( | char * | pre | ) |

## ◆ do_elseif()

const char * SEAMS::do_elseif | ( | double | x | ) |

## ◆ do_error()

const char * SEAMS::do_error | ( | char * | error_string | ) |

## ◆ do_execute()

const char * SEAMS::do_execute | ( | char * | string | ) |

## ◆ do_exp()

double SEAMS::do_exp | ( | double | x | ) |

## ◆ do_expm1()

double SEAMS::do_expm1 | ( | double | x | ) |

## ◆ do_extract()

const char * SEAMS::do_extract | ( | char * | string,
|  | char * | begin,
|  | char * | end
| ) |  |

## ◆ do_fabs()

double SEAMS::do_fabs | ( | double | x | ) |

## ◆ do_file_to_string()

const char * SEAMS::do_file_to_string | ( | char * | filename | ) |

## ◆ do_find_word()

double SEAMS::do_find_word | ( | char * | word,
|  | char * | string,
|  | char * | delm
| ) |  |

## ◆ do_floor()

double SEAMS::do_floor | ( | double | x | ) |

## ◆ do_fmod()

double SEAMS::do_fmod | ( | double | x,
|  | double | y
| ) |  |

## ◆ do_get_date()

const char * SEAMS::do_get_date | ( |  | ) |

## ◆ do_get_iso_date()

const char * SEAMS::do_get_iso_date | ( |  | ) |

## ◆ do_get_temp_filename()

const char * SEAMS::do_get_temp_filename | ( |  | ) |

## ◆ do_get_time()

const char * SEAMS::do_get_time | ( |  | ) |

## ◆ do_get_word()

const char * SEAMS::do_get_word | ( | double | n,
|  | char * | string,
|  | char * | delm
| ) |  |

## ◆ do_getenv()

const char * SEAMS::do_getenv | ( | char * | env | ) |

## ◆ do_hypot()

double SEAMS::do_hypot | ( | double | x,
|  | double | y
| ) |  |

## ◆ do_identity()

array * SEAMS::do_identity | ( | double | size | ) |

## ◆ do_if()

const char * SEAMS::do_if | ( | double | x | ) |

## ◆ do_include_path()

const char * SEAMS::do_include_path | ( | char * | new_path | ) |

## ◆ do_int()

double SEAMS::do_int | ( | double | x | ) |

## ◆ do_intout()

const char * SEAMS::do_intout | ( | double | intval | ) |

## ◆ do_julday()

double SEAMS::do_julday | ( | double | mon,
|  | double | day,
|  | double | year
| ) |  |

## ◆ do_juldayhms()

double SEAMS::do_juldayhms | ( | double | mon,
|  | double | day,
|  | double | year,
|  | double | h,
|  | double | mi,
|  | double | se
| ) |  |

## ◆ do_lgamma()

double SEAMS::do_lgamma | ( | double | val | ) |

## ◆ do_linear_array()

array * SEAMS::do_linear_array | ( | double | init,
|  | double | final,
|  | double | count
| ) |  |

## ◆ do_log()

double SEAMS::do_log | ( | double | x | ) |

## ◆ do_log10()

double SEAMS::do_log10 | ( | double | x | ) |

## ◆ do_log1p()

double SEAMS::do_log1p | ( | double | x | ) |

## ◆ do_make_array()

array * SEAMS::do_make_array | ( | double | rows,
|  | double | cols
| ) |  |

## ◆ do_make_array_init()

array * SEAMS::do_make_array_init | ( | double | rows,
|  | double | cols,
|  | double | init
| ) |  |

## ◆ do_max()

double SEAMS::do_max | ( | double | x,
|  | double | y
| ) |  |

## ◆ do_min()

double SEAMS::do_min | ( | double | x,
|  | double | y
| ) |  |

## ◆ do_nint()

double SEAMS::do_nint | ( | double | x | ) |

## ◆ do_notif()

const char * SEAMS::do_notif | ( | double | x | ) |

## ◆ do_option()

double SEAMS::do_option | ( | char * | option,
|  | double | value
| ) |  |

## ◆ do_output()

const char * SEAMS::do_output | ( | char * | filename | ) |

## ◆ do_polarX()

double SEAMS::do_polarX | ( | double | rad,
|  | double | ang
| ) |  |

## ◆ do_polarY()

double SEAMS::do_polarY | ( | double | rad,
|  | double | ang
| ) |  |

## ◆ do_print_array() [1/2]

const char* SEAMS::do_print_array | ( | array * | my_array_data | ) |

## ◆ do_print_array() [2/2]

const char * SEAMS::do_print_array | ( | const array * | my_array_data | ) |

## ◆ do_r2d()

double SEAMS::do_r2d | ( | double | x | ) |

## ◆ do_rand()

double SEAMS::do_rand | ( | double | xl,
|  | double | xh
| ) |  |

## ◆ do_rand_lognormal()

double SEAMS::do_rand_lognormal | ( | double | mean,
|  | double | stddev
| ) |  |

## ◆ do_rand_normal()

double SEAMS::do_rand_normal | ( | double | mean,
|  | double | stddev
| ) |  |

## ◆ do_rand_weibull()

double SEAMS::do_rand_weibull | ( | double | alpha,
|  | double | beta
| ) |  |

## ◆ do_rescan()

const char * SEAMS::do_rescan | ( | char * | string | ) |

## ◆ do_rows()

double SEAMS::do_rows | ( | const array * | arr | ) |

## ◆ do_sign()

double SEAMS::do_sign | ( | double | x,
|  | double | y
| ) |  |

## ◆ do_sin()

double SEAMS::do_sin | ( | double | x | ) |

## ◆ do_sind()

double SEAMS::do_sind | ( | double | x | ) |

## ◆ do_sinh()

double SEAMS::do_sinh | ( | double | x | ) |

## ◆ do_sqrt()

double SEAMS::do_sqrt | ( | double | x | ) |

## ◆ do_srand()

double SEAMS::do_srand | ( | double | seed | ) |

## ◆ do_str_elseif()

const char * SEAMS::do_str_elseif | ( | char * | string | ) |

## ◆ do_str_if()

const char * SEAMS::do_str_if | ( | char * | string | ) |

## ◆ do_str_notif()

const char * SEAMS::do_str_notif | ( | char * | string | ) |

## ◆ do_strtod()

double SEAMS::do_strtod | ( | char * | string | ) |

## ◆ do_switch()

const char * SEAMS::do_switch | ( | double | x | ) |

## ◆ do_tan()

double SEAMS::do_tan | ( | double | x | ) |

## ◆ do_tand()

double SEAMS::do_tand | ( | double | x | ) |

## ◆ do_tanh()

double SEAMS::do_tanh | ( | double | x | ) |

## ◆ do_time()

double SEAMS::do_time | ( |  | ) |

## ◆ do_tolower()

const char * SEAMS::do_tolower | ( | char * | string | ) |

## ◆ do_tostring()

const char * SEAMS::do_tostring | ( | double | x | ) |

## ◆ do_toupper()

const char * SEAMS::do_toupper | ( | char * | string | ) |

## ◆ do_transpose()

array * SEAMS::do_transpose | ( | const array * | a | ) |

## ◆ do_Units()

const char * SEAMS::do_Units | ( | char * | type | ) |

## ◆ do_word_count()

double SEAMS::do_word_count | ( | char * | string,
|  | char * | delm
| ) |  |

## ◆ get_temp_filename()

const char * SEAMS::get_temp_filename | ( | void |  | ) |

## ◆ immutable_modify()

void SEAMS::immutable_modify | ( | const SEAMS::Aprepro & | apr,
|  | const SEAMS::symrec * | var
| ) |  |

## ◆ is_directory()

bool SEAMS::is_directory | ( | const std::string & | filepath | ) |

## ◆ math_error() [1/2]

void SEAMS::math_error | ( | const SEAMS::Aprepro & | apr,
|  | const char * | function
| ) |  |

## ◆ math_error() [2/2]

void SEAMS::math_error | ( | const char * | function | ) |

## ◆ new_string() [1/2]

void SEAMS::new_string | ( | const std::string & | from,
|  | char ** | to
| ) |  |

## ◆ new_string() [2/2]

void SEAMS::new_string | ( | const char * | from,
|  | char ** | to
| ) |  |

## ◆ pathopen()

char* SEAMS::pathopen | ( | const char * | file | ) |

## ◆ redefined_warning()

void SEAMS::redefined_warning | ( | const SEAMS::Aprepro & | apr,
|  | const SEAMS::symrec * | var
| ) |  |

## ◆ set_type()

void SEAMS::set_type | ( | const SEAMS::Aprepro & | apr,
|  | SEAMS::symrec * | var,
|  | int | type
| ) |  |

## ◆ tokenize()

std::vector< std::string > SEAMS::tokenize | ( | const std::string & | str,
|  | const std::string & | separators
| ) |  |

Take the 'str' argument and split it using the list of characters in separators as separators. Use tokens to return the result.

## ◆ undefined_error()

void SEAMS::undefined_error | ( | const SEAMS::Aprepro & | apr,
|  | const std::string & | var
| ) |  |

## ◆ warning()

void SEAMS::warning | ( | const SEAMS::Aprepro & | apr,
|  | const std::string & | s
| ) |  |

## ◆ yyerror() [1/2]

void SEAMS::yyerror | ( | const SEAMS::Aprepro & | apr,
|  | const std::string & | s
| ) |  |

## ◆ yyerror() [2/2]

void SEAMS::yyerror | ( | const char * | s | ) |

## Variable Documentation

## ◆ aprepro

Aprepro * SEAMS::aprepro = nullptr

## ◆ arith_0_fncts

init SEAMS::arith_0_fncts[]

Initial value:
= {
{"seconds", do_time, "seconds()", "Seconds since epoch (useful for srand())."},
{nullptr, nullptr, nullptr, nullptr}}
SEAMS::do_time
double do_time()
Definition: apr_builtin.cc:123

## ◆ arith_a_fncts

init_a SEAMS::arith_a_fncts[]

Initial value:
= {
{"rows", do_rows, "rows(array)", "Returns the number of rows in the array. "},
{"cols", do_cols, "cols(array)", "Returns the number of columns in the array. "},
{nullptr, nullptr, nullptr, nullptr}}
SEAMS::do_cols
double do_cols(const array *arr)
Definition: apr_builtin.cc:578
SEAMS::do_rows
double do_rows(const array *arr)
Definition: apr_builtin.cc:576

## ◆ arith_c_fncts

init_c SEAMS::arith_c_fncts[]

Initial value:
= {{"strtod", do_strtod, "strtod(svar)",
"Returns a double-precision floating-point number "
"equal to the value represented by the\n\t\t\tcharacter "
"string pointed to by svar."},
{nullptr, nullptr, nullptr, nullptr}}
SEAMS::do_strtod
double do_strtod(char *string)
Definition: apr_builtin.cc:771

## ◆ arith_cc_fncts

init_cc SEAMS::arith_cc_fncts[]

Initial value:
= {{"word_count", do_word_count, "word_count(svar,del)",
"Number of words in svar. Words are separated by one or more of the "
"characters\n\t\t\tin the "
"string variable 'del'."},
{nullptr, nullptr, nullptr, nullptr}}
SEAMS::do_word_count
double do_word_count(char *string, char *delm)
Definition: apr_builtin.cc:709

## ◆ arith_ccc_fncts

init_ccc SEAMS::arith_ccc_fncts[]

Initial value:
= {
{"find_word", do_find_word, "find_word(w,s,d)",
"Find the 1-based index of word 'w' in variable 's'. Words are separated "
"by one or more of the\n\t\t\tcharacters in the "
"string variable 'd'. Returns 0 if not found."},
{nullptr, nullptr, nullptr, nullptr}}
SEAMS::do_find_word
double do_find_word(char *word, char *string, char *delm)
Definition: apr_builtin.cc:714

## ◆ arith_cd_fncts

init_cd SEAMS::arith_cd_fncts[]

Initial value:
= {{"option", do_option, "option(?,?)", "Internal"},
{nullptr, nullptr, nullptr, nullptr}}
SEAMS::do_option
double do_option(char *option, double value)
Definition: apr_builtin.cc:815

## ◆ arith_dd_fncts

init_dd SEAMS::arith_dd_fncts[]

Initial value:
= {
{"atan2", do_atan2, "atan2(y,x)", "Inverse tangent of y/x, returns radians."},
{"atan2d", do_atan2d, "atan2d(y,x)", "Inverse tangent of y/x, returns degrees."},
{"dim", do_dim, "dim(x,y)", "x - min(x,y)"},
{"fmod", do_fmod, "fmod(x,y)", "Floating-point remainder of x/y."},
{"hypot", do_hypot, "hypot(x,y)", "sqrt(x^2+y^2)."},
{"max", do_max, "max(x,y)", "Maximum of x and y. "},
{"min", do_min, "min(x,y)", "Minimum of x and y. "},
{"polarX", do_polarX, "polarX(r,a)", "r * cos(a), a is in degrees "},
{"polarY", do_polarY, "polarY(r,a)", "r * sin(a), a is in degrees "},
{"rand", do_rand, "rand(xl,xh)", "Random value between xl and xh; uniformly distributed. "},
{"rand_normal", do_rand_normal, "rand_normal(m,s)",
"Random value normally distributed with mean m and stddev s."},
{"rand_lognormal", do_rand_lognormal, "rand_lognormal(m,s)",
"Random value with lognormal distribution with mean m and stddev s."},
{"rand_weibull", do_rand_weibull, "rand_weibull(a, b)",
"Random value with weibull distribution with alpha=a and beta=b. "},
{"sign", do_sign, "sign(x,y)", "x * sgn(y)"},
{nullptr, nullptr, nullptr, nullptr}}
SEAMS::do_dim
double do_dim(double x, double y)
Definition: apr_builtin.cc:382
SEAMS::do_polarX
double do_polarX(double rad, double ang)
Definition: apr_builtin.cc:493
SEAMS::do_max
double do_max(double x, double y)
Definition: apr_builtin.cc:210
SEAMS::do_fmod
double do_fmod(double x, double y)
Definition: apr_builtin.cc:442
SEAMS::do_min
double do_min(double x, double y)
Definition: apr_builtin.cc:218
SEAMS::do_rand_normal
double do_rand_normal(double mean, double stddev)
Definition: apr_builtin.cc:356
SEAMS::do_rand_weibull
double do_rand_weibull(double alpha, double beta)
Definition: apr_builtin.cc:368
SEAMS::do_sign
double do_sign(double x, double y)
Definition: apr_builtin.cc:374
SEAMS::do_rand_lognormal
double do_rand_lognormal(double mean, double stddev)
Definition: apr_builtin.cc:362
SEAMS::do_atan2d
double do_atan2d(double x, double y)
Definition: apr_builtin.cc:278
SEAMS::do_hypot
double do_hypot(double x, double y)
Definition: apr_builtin.cc:187
SEAMS::do_polarY
double do_polarY(double rad, double ang)
Definition: apr_builtin.cc:495
SEAMS::do_rand
double do_rand(double xl, double xh)
Definition: apr_builtin.cc:350
SEAMS::do_atan2
double do_atan2(double x, double y)
Definition: apr_builtin.cc:286

## ◆ arith_ddd_fncts

init_ddd SEAMS::arith_ddd_fncts[]

Initial value:
= {
{"julday", do_julday, "julday(mm, dd, yy)", "Julian day corresponding to mm/dd/yy. "},
{nullptr, nullptr, nullptr, nullptr}}
SEAMS::do_julday
double do_julday(double mon, double day, double year)
Definition: apr_builtin.cc:539

## ◆ arith_dddd_fncts

init_dddd SEAMS::arith_dddd_fncts[]

Initial value:
= {
{"Vangle", do_angle, "Vangle(x1,y1,x2,y2)",
"Angle (radians) between vector x1_i+y1_j and x2_i+y2_j."},
{"Vangled", do_angled, "Vangled(x1,y1,x2,y2)",
"Angle (degrees) between vector x1_i+y1_j and x2_i+y2_j."},
{"dist", do_dist, "dist(x1,y1, x2,y2)", "sqrt((x1-x2)^2 + (y1-y2)^2)"},
{nullptr, nullptr, nullptr, nullptr}}
SEAMS::do_angle
double do_angle(double x1, double y1, double x2, double y2)
Definition: apr_builtin.cc:161
SEAMS::do_angled
double do_angled(double x1, double y1, double x2, double y2)
Definition: apr_builtin.cc:173
SEAMS::do_dist
double do_dist(double x1, double y1, double x2, double y2)
Definition: apr_builtin.cc:150

## ◆ arith_dddddd_fncts

init_dddddd SEAMS::arith_dddddd_fncts[]

Initial value:
= {{"juldayhms", do_juldayhms, "juldayhms(m,d,y,h,m,s)",
"Julian day corresponding to m/d/y at h:m:s "},
{nullptr, nullptr, nullptr, nullptr}}
SEAMS::do_juldayhms
double do_juldayhms(double mon, double day, double year, double h, double mi, double se)
Definition: apr_builtin.cc:513

## ◆ arith_fncts

init_d SEAMS::arith_fncts[]

## ◆ array_a_fncts

array_a_init SEAMS::array_a_fncts[]

Initial value:
= {
{"transpose", do_transpose, "transpose(array)", "Return the transpose of input array"},
{nullptr, nullptr, nullptr, nullptr}}
SEAMS::do_transpose
array * do_transpose(const array *a)
Definition: apr_builtin.cc:1066

## ◆ array_c_fncts

array_c_init SEAMS::array_c_fncts[]

Initial value:
= {{"csv_array", do_csv_array1, "csv_array(filename)",
"Create a 2D array from the data in a csv file."},
{nullptr, nullptr, nullptr, nullptr}}
SEAMS::do_csv_array1
array * do_csv_array1(const char *filename)
Definition: apr_builtin.cc:1079

## ◆ array_cc_fncts

array_cc_init SEAMS::array_cc_fncts[]

Initial value:
= {
{"csv_array", do_csv_array2, "csv_array(filename, [skip])",
"Create a 2D array from the data in a csv file optionally skipping rows."
" If skip is integer skip that many rows; if skip is a character, skip lines beginning with "
"that character"},
{"array_from_string", do_array_from_string, "array_from_string(string, delim)",
"Create a 1D array from the data in a delimited string."
" The array double values are\n\t\t\tseparated by one or more of the characters in the "
"string "
"variable delim."},
{nullptr, nullptr, nullptr, nullptr}}
SEAMS::do_array_from_string
array * do_array_from_string(const char *string, const char *delm)
Definition: apr_builtin.cc:1176
SEAMS::do_csv_array2
array * do_csv_array2(const char *filename, const char *comment)
Definition: apr_builtin.cc:1129

## ◆ array_cd_fncts

array_cd_init SEAMS::array_cd_fncts[]

Initial value:
= {
{"csv_array", do_csv_array, "csv_array(filename, [skip])",
"Create a 2D array from the data in a csv file optionally skipping rows."
" If skip is integer\n\t\t\tskip that many rows; if skip is a character, skip lines "
"beginning with "
"that character"},
{nullptr, nullptr, nullptr, nullptr}}
SEAMS::do_csv_array
array * do_csv_array(const char *filename, double skip)
Definition: apr_builtin.cc:1081

## ◆ array_d_fncts

array_d_init SEAMS::array_d_fncts[]

Initial value:
= {
{"identity", do_identity, "identity(size)",
"Create a 2D identity array with 'size' rows and columns. Diagonal = 1.0"},
{nullptr, nullptr, nullptr, nullptr}}
SEAMS::do_identity
array * do_identity(double size)
Definition: apr_builtin.cc:1040

## ◆ array_dd_fncts

array_dd_init SEAMS::array_dd_fncts[]

Initial value:
= {
{"make_array", do_make_array, "make_array(rows, cols)",
"Create a 2D array of size 'rows' by 'cols' initialized to zero."},
{nullptr, nullptr, nullptr, nullptr}}
SEAMS::do_make_array
array * do_make_array(double rows, double cols)
Definition: apr_builtin.cc:1024

## ◆ array_ddd_fncts

array_ddd_init SEAMS::array_ddd_fncts[]

Initial value:
= {
{"linear_array", do_linear_array, "linear_array(init, final, count)",
"Create a 1D array of 'count' rows. Values linearly spaced from 'init' to 'final'."},
{"make_array", do_make_array_init, "make_array(rows, cols, init=0)",
"Create a 2D array of size 'rows' by 'cols' initialized to 'init'. 0 if not specified."},
{nullptr, nullptr, nullptr, nullptr}}
SEAMS::do_make_array_init
array * do_make_array_init(double rows, double cols, double init)
Definition: apr_builtin.cc:1030
SEAMS::do_linear_array
array * do_linear_array(double init, double final, double count)
Definition: apr_builtin.cc:1052

## ◆ cof

double SEAMS::cof[]

Initial value:
= {76.18009173, -86.50532033, 24.01409822,
-1.231739516, 0.120858003e-2, -0.536382e-5}

## ◆ echo

bool SEAMS::echo = true

## ◆ string_a_fncts

str_a_init SEAMS::string_a_fncts[]

Initial value:
= {
{"print_array", do_print_array, "print_array(array)", "Prints the data in the array."},
{nullptr, nullptr, nullptr, nullptr}}
SEAMS::do_print_array
const char * do_print_array(const array *my_array_data)
Definition: apr_builtin.cc:987

## ◆ string_c_fncts

str_c_init SEAMS::string_c_fncts[]

## ◆ string_cc_fncts

str_cc_init SEAMS::string_cc_fncts[]

Initial value:
= {
{nullptr, nullptr, nullptr, nullptr}}

## ◆ string_ccc_fncts

str_ccc_init SEAMS::string_ccc_fncts[]

Initial value:
= {
{"extract", do_extract, "extract(s, b, e)",
"Return substring [b,e). 'b' is included; 'e' is not. If 'b' not found, return empty; If "
"'e' not found,\n\t\t\treturn rest of string. If 'b' empty, start at beginning; if 'e' "
"empty, "
"return rest of string."},
{nullptr, nullptr, nullptr, nullptr}}
SEAMS::do_extract
const char * do_extract(char *string, char *begin, char *end)
Definition: apr_builtin.cc:940

## ◆ string_d_fncts

str_d_init SEAMS::string_d_fncts[]

## ◆ string_dcc_fncts

str_dcc_init SEAMS::string_dcc_fncts[]

Initial value:
= {
{"get_word", do_get_word, "get_word(n,svar,del)",
"Returns a string containing the nth word of svar. The words are separated by one or more "
"\n\t\t\tcharacters in the string variable del "},
{nullptr, nullptr, nullptr, nullptr}}
SEAMS::do_get_word
const char * do_get_word(double n, char *string, char *delm)
Definition: apr_builtin.cc:726

## ◆ string_fncts

str_init SEAMS::string_fncts[]

Initial value:
= {
{"DUMP", do_dumpsym, "DUMP()", "Output a list of all defined variables and their value."},
{"DUMP_FUNC", do_dumpfunc, "DUMP_FUNC()",
"Output a list of all double and string functions recognized by aprepro."},
{"DUMP_PREVAR", do_dumpvar, "DUMP_PREVAR()",
"Output a list of all predefined variables and their value."},
{"get_date", do_get_date, "get_date()",
"Returns a string representing the current date in the form YYYY/MM/DD."},
{"get_iso_date", do_get_iso_date, "get_iso_date()",
"Returns a string representing the current date in the form YYYYMMDD."},
{"get_time", do_get_time, "get_time()",
"Returns a string representing the current time in the form HH:MM:SS."},
{"get_temp_filename", do_get_temp_filename, "get_temp_filename()",
"Returns a string which can be used for a temporary filename without conflicting with any "
"other filenames."},
{nullptr, nullptr, nullptr, nullptr}}
SEAMS::do_dumpfunc
const char * do_dumpfunc()
Definition: apr_builtin.cc:785
SEAMS::do_get_temp_filename
const char * do_get_temp_filename()
Definition: apr_builtin.cc:971
SEAMS::do_get_iso_date
const char * do_get_iso_date()
Definition: apr_builtin.cc:596
SEAMS::do_dumpvar
const char * do_dumpvar()
Definition: apr_builtin.cc:791
SEAMS::do_dumpsym
const char * do_dumpsym()
Definition: apr_builtin.cc:779
SEAMS::do_get_time
const char * do_get_time()
Definition: apr_builtin.cc:611
SEAMS::do_get_date
const char * do_get_date()
Definition: apr_builtin.cc:581

## ◆ svariables

svar_init SEAMS::svariables[]

Initial value:
= {{"_FORMAT", "%.10g"},
{nullptr, nullptr}}

## ◆ variables

var_init SEAMS::variables[]

Initial value:
= {
{"DEG", 57.29577951308232087680},
{"RAD", 0.01745329251994329576},
{"E", 2.71828182845904523536},
{"GAMMA", 0.57721566490153286060},
{"PHI", 1.61803398874989484820},
{"TAU", 6.28318530717958623200},
{"PI", 3.14159265358979323846},
{"PI_2", 1.57079632679489661923},
{"SQRT2", 1.41421356237309504880},
{"TRUE", 1},
{"FALSE", 0},
{nullptr, 0}
}