SEAMS Namespace Reference

Namespaces
namespace	anonymous_namespace{apr_aprepro.cc}
namespace	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
struct	symrec
struct	Symtable

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_FtoC (double F)
double	do_CtoF (double C)
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_pow (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_erf (double x)
double	do_erfc (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_cbrt (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_tgamma (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_version ()
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_dumpsym_json ()
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_format (double var, char *format)
const char *	do_execute (char *string)
const char *	do_rescan (char *string)
const char *	do_import (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_principal (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)
array *	do_sym_tensor_from_string (const char *string, const char *delm)
const char *	do_Units (char *type)
const char *	do_print_array (array *my_array_data)
void	gl_setwidth (size_t w)
char *	getline_int (const char *prompt)
void	gl_histadd (const char *buf)
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)
const char *	get_temp_filename ()
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
const init	arith_0_fncts []
const init_d	arith_fncts []
const init_a	arith_a_fncts []
const init_dd	arith_dd_fncts []
const init_dddd	arith_dddd_fncts []
const init_cc	arith_cc_fncts []
const init_ccc	arith_ccc_fncts []
const init_c	arith_c_fncts []
const init_cd	arith_cd_fncts []
const init_ddd	arith_ddd_fncts []
const init_dddddd	arith_dddddd_fncts []
const str_init	string_fncts []
const str_c_init	string_c_fncts []
const str_d_init	string_d_fncts []
const str_dc_init	string_dc_fncts []
const str_dcc_init	string_dcc_fncts []
const str_ccc_init	string_ccc_fncts []
const str_cc_init	string_cc_fncts []
const str_a_init	string_a_fncts []
const array_c_init	array_c_fncts []
const array_cd_init	array_cd_fncts []
const array_cc_init	array_cc_fncts []
const array_ddd_init	array_ddd_fncts []
const array_dd_init	array_dd_fncts []
const array_d_init	array_d_fncts []
const array_a_init	array_a_fncts []
const var_init	variables []
const 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()

void SEAMS::conv_string

(

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

double SEAMS::do_cbrt

(

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

double SEAMS::do_CtoF

(

double

C

)

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

const char * SEAMS::do_dumpsym_json

(

)

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

double SEAMS::do_erf

(

double

x

)

do_erfc()

double SEAMS::do_erfc

(

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

const char * SEAMS::do_format	(	double	var,
		char *	format )

do_FtoC()

double SEAMS::do_FtoC

(

double

F

)

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

const char * SEAMS::do_import

(

char *

string

)

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

double SEAMS::do_pow	(	double	x,
		double	y )

do_principal()

array * SEAMS::do_principal

(

const array *

a

)

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

array * SEAMS::do_sym_tensor_from_string	(	const char *	string,
		const char *	delm )

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

double SEAMS::do_tgamma

(

double

val

)

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

const char * SEAMS::do_version

(

)

do_word_count()

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

get_temp_filename()

const char * SEAMS::get_temp_filename

(

)

getline_int()

char * SEAMS::getline_int

(

const char *

prompt

)

gl_histadd()

void SEAMS::gl_histadd

(

const char *

buf

)

gl_setwidth()

void SEAMS::gl_setwidth

(

size_t

w

)

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 char *

function

)

math_error() [2/2]

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

new_string() [1/2]

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

new_string() [2/2]

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

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 char *

s

)

yyerror() [2/2]

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

Variable Documentation

aprepro

Aprepro * SEAMS::aprepro = nullptr

arith_0_fncts

const init SEAMS::arith_0_fncts[]

Initial value:

= {
      {"seconds", do_time, "seconds()", "Seconds since epoch (useful for srand())."},
      {nullptr, nullptr, nullptr, nullptr}}

arith_a_fncts

const 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}}

arith_c_fncts

const 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}}

arith_cc_fncts

const 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}}

arith_ccc_fncts

const 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}}

arith_cd_fncts

const init_cd SEAMS::arith_cd_fncts[]

Initial value:

= {{"option", do_option, "option(?,?)", "Internal"},
                                    {nullptr, nullptr, nullptr, nullptr}}

arith_dd_fncts

const 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 "},
      {"pow", do_pow, "pow(x,y)", "x^y "},
      {"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}}

arith_ddd_fncts

const 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}}

arith_dddd_fncts

const 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}}

arith_dddddd_fncts

const 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}}

arith_fncts

const init_d SEAMS::arith_fncts[]

array_a_fncts

const array_a_init SEAMS::array_a_fncts[]

Initial value:

= {
      {"transpose", do_transpose, "transpose(array)", "Return the transpose of input array"},
      {"principal_stress", do_principal, "principal_stress(array)",
       "Calculate principal stresses of symmetric 3x3 stress tensor (array)."},
      {nullptr, nullptr, nullptr, nullptr}}

array_c_fncts

const 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}}

array_cc_fncts

const 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."},
      {"sym_tensor_from_string", do_sym_tensor_from_string, "sym_tensor_from_string(string, delim)",
       "Create a 3x3 symmetric array from the data in a delimited string."
       " The six array values are\n\t\t\tseparated by one or more of the characters in the "
       "string variable delim. Order is xx, yy, zz, xy, yz, xz."},
      {nullptr, nullptr, nullptr, nullptr}}

array_cd_fncts

const 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}}

array_d_fncts

const 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}}

array_dd_fncts

const 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}}

array_ddd_fncts

const 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}}

echo

bool SEAMS::echo = true

string_a_fncts

const 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}}

string_c_fncts

const str_c_init SEAMS::string_c_fncts[]

string_cc_fncts

const str_cc_init SEAMS::string_cc_fncts[]

Initial value:

= {
 
 
 
 
      {nullptr, nullptr, nullptr, nullptr}}

string_ccc_fncts

const 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}}

string_d_fncts

const str_d_init SEAMS::string_d_fncts[]

string_dc_fncts

const str_dc_init SEAMS::string_dc_fncts[]

Initial value:

= {
      {"format", do_format, "format(variable, output_format)",
       "Print `variable` using the format specified in `output_format`"},
      {nullptr, nullptr, nullptr, nullptr}}

string_dcc_fncts

const 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}}

string_fncts

const str_init SEAMS::string_fncts[]

Initial value:

= {
      {"DUMP", do_dumpsym, "DUMP()",
       "Output a list of all user-defined variables and their value."},
      {"DUMP_JSON", do_dumpsym_json, "DUMP_JSON()",
       "Output a list of all user-defined variables and their value in JSON format."},
      {"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."},
      {"version", do_version, "version()",
       "Return the version string (See also _VERSION variable)"},
      {nullptr, nullptr, nullptr, nullptr}}

svariables

const svar_init SEAMS::svariables[]

Initial value:

= {{"_FORMAT", "%.10g"}, 
                                  {"_UNITS_SYSTEM", "none"},
                                  {nullptr, nullptr}}

variables

const 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}
  }