int equal_p(object o1, object o2) {
if (eqv_p(o1,o2)) return 1;
if (PAIR_P(o1)) {
return PAIR_P(o2)&&equal_p(CAR(o1),CAR(o2))&&equal_p(CDR(o1),CDR(o2));
} else if (VECTOR_P(o1)) {
if (VECTOR_P(o2)) {
long max = VECTOR_LENGTH(o1);
if (max == VECTOR_LENGTH(o2)) {
object *e1 = VECTOR_ELEMENTS(o1), *e2 = VECTOR_ELEMENTS(o2);
long i;
for (i=0; i<max; i++)
if (!equal_p(e1[i],e2[i]))
return 0;
return 1;
}
}
} else if (STRING_P(o1)) {
if (STRING_P(o2)) {
long max = STRING_LENGTH(o1);
if (max == STRING_LENGTH(o2)) {
char *p1 = STRING_VALUE(o1);
char *p2 = STRING_VALUE(o2);
while (*p1 && *p2) {
if (*p1++ != *p2++) return 0;
}
return (*p1 == *p2);
}
}
}
return 0;
}
static VALUE rb_gsl_spline_init(VALUE obj, VALUE xxa, VALUE yya)
{
rb_gsl_spline *sp = NULL;
gsl_spline *p = NULL;
gsl_vector *xa = NULL, *ya = NULL;
size_t i, size;
int flagx = 0, flagy = 0;
double *ptr1 = NULL, *ptr2 = NULL;
#ifdef HAVE_NARRAY_H
struct NARRAY *nax = NULL, *nay = NULL;
#endif
Data_Get_Struct(obj, rb_gsl_spline, sp);
p = sp->s;
if (TYPE(xxa) == T_ARRAY) {
size = RARRAY_LEN(xxa);
xa = gsl_vector_alloc(size);
for (i = 0; i < size; i++) gsl_vector_set(xa, i, NUM2DBL(rb_ary_entry(xxa, i)));
ptr1 = xa->data;
flagx = 1;
} else if (VECTOR_P(xxa)) {
Data_Get_Struct(xxa, gsl_vector, xa);
size = xa->size;
ptr1 = xa->data;
#ifdef HAVE_NARRAY_H
} else if (NA_IsNArray(xxa)) {
GetNArray(xxa, nax);
size = nax->total;
ptr1 = (double *) nax->ptr;
#endif
} else {
rb_raise(rb_eTypeError, "not a vector");
}
if (TYPE(yya) == T_ARRAY) {
ya = gsl_vector_alloc(size);
for (i = 0; i < size; i++) gsl_vector_set(ya, i, NUM2DBL(rb_ary_entry(yya, i)));
ptr2 = ya->data;
flagy = 1;
#ifdef HAVE_NARRAY_H
} else if (NA_IsNArray(yya)) {
GetNArray(yya, nay);
ptr2 = (double *) nay->ptr;
#endif
} else if (VECTOR_P(yya)) {
Data_Get_Struct(yya, gsl_vector, ya);
ptr2 = ya->data;
} else {
rb_raise(rb_eTypeError, "not a vector");
}
gsl_spline_init(p, ptr1, ptr2, size);
if (flagx == 1) gsl_vector_free(xa);
if (flagy == 1) gsl_vector_free(ya);
return obj;
}
static VALUE rb_gsl_rational_div(VALUE obj, VALUE other)
{
gsl_rational *r = NULL, *r2 = NULL, *rnew = NULL;
gsl_poly *p;
size_t i;
Data_Get_Struct(obj, gsl_rational, r);
if (RATIONAL_P(other)) {
Data_Get_Struct(other, gsl_rational, r2);
rnew = gsl_rational_div(r, r2);
} else if (VECTOR_P(other)) {
Data_Get_Struct(other, gsl_vector, p);
rnew = gsl_rational_div_poly(r, p);
} else {
switch (TYPE(other)) {
case T_ARRAY:
p = gsl_vector_alloc(RARRAY_LEN(other));
for (i = 0; i < p->size; i++)
gsl_vector_set(p, i, NUM2DBL(rb_ary_entry(other, i)));
rnew = gsl_rational_div_poly(r, p);
gsl_vector_free(p);
break;
case T_FLOAT:
case T_FIXNUM:
rnew = gsl_rational_new(r->pnum, r->pden);
gsl_vector_scale(rnew->pnum, 1.0/NUM2DBL(other));
break;
default:
rb_raise(rb_eTypeError, "wrong argument type %s",
rb_class2name(CLASS_OF(other)));
break;
}
}
return Data_Wrap_Struct(cgsl_rational, gsl_rational_mark, gsl_rational_free, rnew);
}
double* get_vector_ptr(VALUE ary, size_t *stride, size_t *n)
{
gsl_vector *v = NULL;
gsl_vector_complex *vc = NULL;
gsl_matrix *m;
if (VECTOR_P(ary)) {
Data_Get_Struct(ary, gsl_vector, v);
*stride = v->stride;
*n = v->size;
return v->data;
} else if (VECTOR_COMPLEX_P(ary)) {
Data_Get_Struct(ary, gsl_vector_complex, vc);
*stride = vc->stride;
*n = vc->size*2;
return vc->data;
} else if (MATRIX_P(ary)) {
Data_Get_Struct(ary, gsl_matrix, m);
*stride = 1;
*n = m->size1*m->size2;
return m->data;
#ifdef HAVE_NARRAY_H
} else if (NA_IsNArray(ary)) {
VALUE ary2;
*n = NA_TOTAL(ary);
*stride = 1;
ary2 = na_change_type(ary, NA_DFLOAT);
return NA_PTR_TYPE(ary2,double*);
#endif
#ifdef HAVE_NMATRIX_H
} else if (NM_IsNMatrix(ary)) {
/* singleton */
static VALUE rb_gsl_poly_make_rational(VALUE obj, VALUE other)
{
gsl_rational *rnew = NULL;
gsl_poly *p, *p2;
size_t i;
Data_Get_Struct(obj, gsl_poly, p);
if (VECTOR_P(other)) {
Data_Get_Struct(other, gsl_vector, p2);
rnew = gsl_rational_new(p, p2);
} else {
switch (TYPE(other)) {
case T_ARRAY:
p2 = gsl_vector_alloc(RARRAY_LEN(other));
for (i = 0; i < p2->size; i++)
gsl_vector_set(p2, i, NUM2DBL(rb_ary_entry(other, i)));
rnew = gsl_rational_new(p, p2);
gsl_vector_free(p2);
break;
case T_FLOAT:
case T_FIXNUM:
p2 = make_vector_clone(p);
gsl_vector_scale(p2, 1.0/NUM2DBL(other));
return Data_Wrap_Struct(cgsl_poly, 0, gsl_vector_free, p2);
break;
default:
rb_raise(rb_eTypeError, "wrong argument type %s",
rb_class2name(CLASS_OF(other)));
break;
}
}
return Data_Wrap_Struct(cgsl_rational, gsl_rational_mark, gsl_rational_free, rnew);
}
static VALUE rb_ool_conmin_minimizer_set(int argc, VALUE *argv, VALUE obj)
{
ool_conmin_minimizer *m;
ool_conmin_function *F;
ool_conmin_constraint *C;
gsl_vector *v;
ool_conmin_pgrad_parameters Pp;
ool_conmin_spg_parameters Ps;
ool_conmin_gencan_parameters Pg;
void *P;
Data_Get_Struct(obj, ool_conmin_minimizer, m);
switch (argc) {
case 3:
if (CLASS_OF(argv[0]) != cool_conmin_function)
rb_raise(rb_eTypeError, "Wrong argument type 0 (OOL::Conmin::Function expected)");
if (CLASS_OF(argv[1]) != cool_conmin_constraint)
rb_raise(rb_eTypeError, "Wrong argument type 1 (OOL::Conmin::Constraint expected)");
if (!VECTOR_P(argv[2]))
rb_raise(rb_eTypeError, "Wrong argument type 2 (GSL::Vector expected)");
Data_Get_Struct(argv[0], ool_conmin_function, F);
Data_Get_Struct(argv[1], ool_conmin_constraint, C);
Data_Get_Struct(argv[2], gsl_vector, v);
P = get_parameter(m->type, &Pp, &Ps, &Pg, Qnil);
ool_conmin_minimizer_set(m, F, C, v, P);
break;
case 4:
if (CLASS_OF(argv[0]) != cool_conmin_function)
rb_raise(rb_eTypeError, "Wrong argument type 0 (OOL::Conmin::Function expected)");
if (CLASS_OF(argv[1]) != cool_conmin_constraint)
rb_raise(rb_eTypeError, "Wrong argument type 1 (OOL::Conmin::Constraint expected)");
if (!VECTOR_P(argv[2]))
rb_raise(rb_eTypeError, "Wrong argument type 2 (GSL::Vector expected)");
if (!rb_obj_is_kind_of(argv[3], rb_cArray) && argv[3] != Qnil)
rb_raise(rb_eTypeError, "Wrong argument type 3 (Array expected)");
Data_Get_Struct(argv[0], ool_conmin_function, F);
Data_Get_Struct(argv[1], ool_conmin_constraint, C);
Data_Get_Struct(argv[2], gsl_vector, v);
P = get_parameter(m->type, &Pp, &Ps, &Pg, argv[3]);
ool_conmin_minimizer_set(m, F, C, v, P);
break;
default:
rb_raise(rb_eArgError, "Wrong number of arguments (%d for 3 or 4)", argc);
}
return obj;
}
SCHEME_OBJECT *
faslhdr_utilities_end (fasl_header_t * h)
{
if (((__FASLHDR_UTILITIES_END (h)) == 0)
&& (VECTOR_P (FASLHDR_UTILITIES_VECTOR (h))))
(__FASLHDR_UTILITIES_END (h))
= (VECTOR_LOC ((FASLHDR_UTILITIES_VECTOR (h)),
(VECTOR_LENGTH (FASLHDR_UTILITIES_VECTOR (h)))));
return (__FASLHDR_UTILITIES_END (h));
}
static VALUE rb_gsl_odeiv_step_apply(int argc, VALUE *argv, VALUE obj)
{
gsl_odeiv_step *s = NULL;
gsl_odeiv_system *sys = NULL;
gsl_vector *y = NULL, *yerr = NULL;
gsl_vector *vtmp1 = NULL, *vtmp2 = NULL;
double *dydt_in = NULL, *dydt_out = NULL;
double t, h;
switch (argc) {
case 5:
break;
case 7:
if (VECTOR_P(argv[5])) {
Data_Get_Struct(argv[5], gsl_vector, vtmp2);
if (vtmp2) dydt_out = vtmp2->data;
}
/* no break */
case 6:
if (VECTOR_P(argv[4])) {
Data_Get_Struct(argv[4], gsl_vector, vtmp1);
if (vtmp1) dydt_in = vtmp1->data;
}
break;
default:
rb_raise(rb_eArgError, "wrong number of arguments (%d for 5, 6 or 7)", argc);
break;
}
Need_Float(argv[0]); Need_Float(argv[1]);
CHECK_VECTOR(argv[2]); CHECK_VECTOR(argv[3]);
CHECK_SYSTEM(argv[argc-1]);
Data_Get_Struct(obj, gsl_odeiv_step, s);
t = NUM2DBL(argv[0]);
h = NUM2DBL(argv[1]);
Data_Get_Struct(argv[2], gsl_vector, y);
Data_Get_Struct(argv[3], gsl_vector, yerr);
Data_Get_Struct(argv[argc-1], gsl_odeiv_system, sys);
return INT2FIX(gsl_odeiv_step_apply(s, t, h, y->data, yerr->data,
dydt_in, dydt_out, sys));
}
static VALUE rb_gsl_math_eval(double (*func)(const double), VALUE xx)
{
VALUE x, ary;
size_t i, size;
#ifdef HAVE_NARRAY_H
struct NARRAY *na;
double *ptr1, *ptr2;
#endif
if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx);
switch (TYPE(xx)) {
case T_FIXNUM:
case T_BIGNUM:
case T_FLOAT:
return rb_float_new((*func)(NUM2DBL(xx)));
break;
case T_ARRAY:
size = RARRAY_LEN(xx);
ary = rb_ary_new2(size);
for (i = 0; i < size; i++) {
x = rb_ary_entry(xx, i);
Need_Float(x);
rb_ary_store(ary, i, rb_float_new((*func)(RFLOAT_VALUE(x))));
}
return ary;
break;
default:
#ifdef HAVE_NARRAY_H
if (NA_IsNArray(xx)) {
GetNArray(xx, na);
ptr1 = (double*) na->ptr;
size = na->total;
ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx));
ptr2 = NA_PTR_TYPE(ary, double*);
for (i = 0; i < size; i++) ptr2[i] = (*func)(ptr1[i]);
return ary;
}
#endif
if (VECTOR_P(xx)) {
return vector_eval_create(xx, func);
} else if (MATRIX_P(xx)) {
return matrix_eval_create(xx, func);
} else {
rb_raise(rb_eTypeError, "wrong argument type %s (Array or Vector or Matrix expected)", rb_class2name(CLASS_OF(xx)));
}
break;
}
/* never reach here */
return Qnil;
}
static void
attempt_termination_backout (int code)
{
outf_flush_error(); /* NOT flush_fatal */
if ((WITHIN_CRITICAL_SECTION_P ())
|| (code == TERM_HALT)
|| (! (VECTOR_P (fixed_objects))))
return;
{
SCHEME_OBJECT Term_Vector
= (VECTOR_REF (fixed_objects, Termination_Proc_Vector));
if ((! (VECTOR_P (Term_Vector)))
|| (((long) (VECTOR_LENGTH (Term_Vector))) <= code))
return;
{
SCHEME_OBJECT Handler = (VECTOR_REF (Term_Vector, code));
if (Handler == SHARP_F)
return;
Will_Push (CONTINUATION_SIZE
+ STACK_ENV_EXTRA_SLOTS
+ ((code == TERM_NO_ERROR_HANDLER) ? 5 : 4));
SET_RC (RC_HALT);
SET_EXP (LONG_TO_UNSIGNED_FIXNUM (code));
SAVE_CONT ();
if (code == TERM_NO_ERROR_HANDLER)
STACK_PUSH (LONG_TO_UNSIGNED_FIXNUM (death_blow));
PUSH_VAL (); /* Arg 3 */
PUSH_ENV (); /* Arg 2 */
PUSH_EXP (); /* Arg 1 */
STACK_PUSH (Handler); /* The handler function */
PUSH_APPLY_FRAME_HEADER ((code == TERM_NO_ERROR_HANDLER) ? 4 : 3);
Pushed ();
abort_to_interpreter (PRIM_NO_TRAP_APPLY);
}
}
}
static void
edwin_auto_save (void)
{
static SCHEME_OBJECT position;
static struct interpreter_state_s new_state;
position =
((VECTOR_P (fixed_objects))
? (VECTOR_REF (fixed_objects, FIXOBJ_EDWIN_AUTO_SAVE))
: EMPTY_LIST);
while (PAIR_P (position))
{
SCHEME_OBJECT entry = (PAIR_CAR (position));
position = (PAIR_CDR (position));
if ((PAIR_P (entry))
&& (GROUP_P (PAIR_CAR (entry)))
&& (STRING_P (PAIR_CDR (entry)))
&& ((GROUP_MODIFIED_P (PAIR_CAR (entry))) == SHARP_T))
{
SCHEME_OBJECT group = (PAIR_CAR (entry));
char * namestring = (STRING_POINTER (PAIR_CDR (entry)));
unsigned long length;
unsigned char * start = (GROUP_TEXT (group, (&length)));
unsigned char * end = (start + length);
unsigned char * gap_start = (start + (GROUP_GAP_START (group)));
unsigned char * gap_end = (start + (GROUP_GAP_END (group)));
if ((start < gap_start) || (gap_end < end))
{
bind_interpreter_state (&new_state);
if ((setjmp (interpreter_catch_env)) == 0)
{
Tchannel channel;
outf_error ("Auto-saving file \"%s\"\n", namestring);
outf_flush_error ();
channel = (OS_open_output_file (namestring));
if (start < gap_start)
OS_channel_write (channel, start, (gap_start - start));
if (gap_end < end)
OS_channel_write (channel, gap_end, (end - gap_end));
OS_channel_close (channel);
}
unbind_interpreter_state (&new_state);
}
}
}
}
static VALUE rb_gsl_rational_mul(VALUE obj, VALUE other)
{
gsl_rational *r = NULL, *r2 = NULL, *rnew = NULL;
gsl_poly *p;
int flag = 0;
Data_Get_Struct(obj, gsl_rational, r);
if (RATIONAL_P(other)) {
Data_Get_Struct(other, gsl_rational, r2);
rnew = gsl_rational_mul(r, r2);
} else if (VECTOR_P(other)) {
Data_Get_Struct(other, gsl_vector, p);
rnew = gsl_rational_mul_poly(r, p);
} else {
p = get_poly_get(other, &flag);
rnew = gsl_rational_mul_poly(r, p);
gsl_vector_free(p);
}
return Data_Wrap_Struct(cgsl_rational, gsl_rational_mark, gsl_rational_free, rnew);
}
static VALUE jac_eval3(VALUE xx, VALUE aa, VALUE bb, double (*f)(double, double, double))
{
gsl_vector *x, *y;
double a, b;
size_t i, len;
VALUE ary;
a = NUM2DBL(aa);
b = NUM2DBL(bb);
if (VECTOR_P(xx)) {
Data_Get_Struct(xx, gsl_vector, x);
y = gsl_vector_alloc(x->size);
for (i = 0; i < x->size; i++) {
gsl_vector_set(y, i, (*f)(gsl_vector_get(x, i), a, b));
}
return Data_Wrap_Struct(VECTOR_ROW_COL(CLASS_OF(xx)), 0, gsl_vector_free, y);
} else if (TYPE(xx) == T_ARRAY) {
// len = RARRAY(xx)->len;
len = RARRAY_LEN(xx);
ary = rb_ary_new2(len);
for (i = 0; i < len; i++) {
rb_ary_store(ary, i, rb_float_new((*f)(NUM2DBL(rb_ary_entry(xx, i)), a, b)));
}
return ary;
#ifdef HAVE_NARRAY_H
} else if (NA_IsNArray(xx)) {
double *ptr1, *ptr2;
struct NARRAY *na;
GetNArray(xx, na);
len = na->total;
ptr1 = (double*) na->ptr;
ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx));
ptr2 = NA_PTR_TYPE(ary, double*);
for (i = 0; i < len; i++) {
ptr2[i] = (*f)(ptr1[i], a, b);
}
return ary;
#endif
} else {
return rb_float_new((*f)(NUM2DBL(xx), a, b));
static void
delete_temp_files (void)
{
static SCHEME_OBJECT position;
static struct interpreter_state_s new_state;
position =
((VECTOR_P (fixed_objects))
? (VECTOR_REF (fixed_objects, FIXOBJ_FILES_TO_DELETE))
: EMPTY_LIST);
while (PAIR_P (position))
{
SCHEME_OBJECT entry = (PAIR_CAR (position));
position = (PAIR_CDR (position));
if (STRING_P (entry))
{
bind_interpreter_state (&new_state);
if ((setjmp (interpreter_catch_env)) == 0)
OS_file_remove (STRING_POINTER (entry));
unbind_interpreter_state (&new_state);
}
}
}
static VALUE rb_gsl_math_eval2(double (*func)(const double, const double), VALUE xx,
VALUE yy)
{
VALUE x, y, ary;
size_t i, j, size;
gsl_vector *v = NULL, *v2 = NULL, *vnew = NULL;
gsl_matrix *m = NULL, *m2 = NULL, *mnew = NULL;
if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx);
switch (TYPE(xx)) {
case T_FIXNUM:
case T_BIGNUM:
case T_FLOAT:
Need_Float(yy);
return rb_float_new((*func)(NUM2DBL(xx), NUM2DBL(yy)));
break;
case T_ARRAY:
Check_Type(yy, T_ARRAY);
size = RARRAY_LEN(xx);
// if (size != RARRAY(yy)->len) rb_raise(rb_eRuntimeError, "array sizes are different.");
if ((int) size != RARRAY_LEN(yy)) rb_raise(rb_eRuntimeError, "array sizes are different.");
ary = rb_ary_new2(size);
for (i = 0; i < size; i++) {
x = rb_ary_entry(xx, i);
y = rb_ary_entry(yy, i);
Need_Float(x); Need_Float(y);
// rb_ary_store(ary, i, rb_float_new((*func)(RFLOAT(x)->value, RFLOAT(y)->value)));
rb_ary_store(ary, i, rb_float_new((*func)(NUM2DBL(x), NUM2DBL(y))));
}
return ary;
break;
default:
#ifdef HAVE_NARRAY_H
if (NA_IsNArray(xx)) {
struct NARRAY *nax, *nay;
double *ptr1, *ptr2, *ptr3;
GetNArray(xx, nax);
GetNArray(yy, nay);
ptr1 = (double*) nax->ptr;
ptr2 = (double*) nay->ptr;
size = nax->total;
ary = na_make_object(NA_DFLOAT, nax->rank, nax->shape, CLASS_OF(xx));
ptr3 = NA_PTR_TYPE(ary, double*);
for (i = 0; i < size; i++) ptr3[i] = (*func)(ptr1[i], ptr2[i]);
return ary;
}
#endif
if (VECTOR_P(xx)) {
CHECK_VECTOR(yy);
Data_Get_Struct(xx, gsl_vector, v);
Data_Get_Struct(yy, gsl_vector, v2);
vnew = gsl_vector_alloc(v->size);
for (i = 0; i < v->size; i++) {
gsl_vector_set(vnew, i, (*func)(gsl_vector_get(v, i), gsl_vector_get(v2, i)));
}
return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew);
} else if (MATRIX_P(xx)) {
CHECK_MATRIX(yy);
Data_Get_Struct(xx, gsl_matrix, m);
Data_Get_Struct(yy, gsl_matrix, m2);
mnew = gsl_matrix_alloc(m->size1, m->size2);
for (i = 0; i < m->size1; i++) {
for (j = 0; j < m->size2; j++) {
gsl_matrix_set(mnew, i, j, (*func)(gsl_matrix_get(m, i, j), gsl_matrix_get(m2, i, j)));
}
}
return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);
} else {
rb_raise(rb_eTypeError,
"wrong argument type %s "
"(Array or Vector or Matrix expected)", rb_class2name(CLASS_OF(xx)));
}
break;
}
/* never reach here */
return Qnil;
}
static VALUE rb_gsl_wavelet_transform0(int argc, VALUE *argv, VALUE obj,
int sss)
{
gsl_wavelet *w = NULL;
gsl_vector *v = NULL, *vnew;
gsl_wavelet_direction dir = forward;
gsl_wavelet_workspace *work = NULL;
int itmp, flag = 0;
// local variable "status" declared and set, but never used
//int status;
double *ptr1, *ptr2;
size_t n, stride;
int naflag = 0;
VALUE ary, ret;
#ifdef HAVE_NARRAY_H
struct NARRAY *na1 = NULL;
#endif
switch (TYPE(obj)) {
case T_MODULE:
case T_CLASS:
case T_OBJECT:
if (argc < 2) rb_raise(rb_eArgError, "too few arguments");
CHECK_WAVELET(argv[0]);
if (MATRIX_P(argv[1])) {
return rb_gsl_wavelet2d(argc, argv, obj,
gsl_wavelet2d_transform_matrix, sss);
}
if (VECTOR_P(argv[1])) {
Data_Get_Struct(argv[0], gsl_wavelet, w);
Data_Get_Struct(argv[1], gsl_vector, v);
ret = argv[1];
ptr1 = v->data;
n = v->size;
stride = v->stride;
#ifdef HAVE_NARRAY_H
} else if (NA_IsNArray(argv[1])) {
GetNArray(argv[1], na1);
ret = argv[1];
ptr1 = (double*) na1->ptr;
n = na1->total;
naflag = 1;
stride = 1;
#endif
} else {
rb_raise(rb_eTypeError, "wrong argument type (Vector expected)");
}
itmp = 2;
break;
default:
if (argc < 1) rb_raise(rb_eArgError, "too few arguments");
if (MATRIX_P(argv[0])) {
return rb_gsl_wavelet2d(argc, argv, obj,
gsl_wavelet2d_transform_matrix, sss);
}
if (VECTOR_P(obj)) {
CHECK_WAVELET(argv[0]);
Data_Get_Struct(argv[0], gsl_wavelet, w);
Data_Get_Struct(obj, gsl_vector, v);
ret = obj;
ptr1 = v->data;
n = v->size;
stride = v->stride;
} else if (VECTOR_P(argv[0])) {
CHECK_WAVELET(obj);
Data_Get_Struct(obj, gsl_wavelet, w);
Data_Get_Struct(argv[0], gsl_vector, v);
ret = argv[0];
ptr1 = v->data;
n = v->size;
stride = v->stride;
#ifdef HAVE_NARRAY_H
} else if (NA_IsNArray(obj)) {
CHECK_WAVELET(argv[0]);
Data_Get_Struct(argv[0], gsl_wavelet, w);
GetNArray(obj, na1);
ret = obj;
ptr1 = (double*) na1->ptr;
n = na1->total;
naflag = 1;
stride = 1;
} else if (NA_IsNArray(argv[0])) {
CHECK_WAVELET(obj);
Data_Get_Struct(obj, gsl_wavelet, w);
GetNArray(argv[0], na1);
ret = argv[0];
ptr1 = (double*) na1->ptr;
n = na1->total;
naflag = 1;
stride = 1;
#endif
} else {
rb_raise(rb_eTypeError, "wrong argument type");
}
itmp = 1;
break;
}
switch (argc - itmp) {
case 2:
CHECK_FIXNUM(argv[itmp]);
CHECK_WORKSPACE(argv[itmp+1]);
dir = FIX2INT(argv[itmp]);
Data_Get_Struct(argv[itmp+1], gsl_wavelet_workspace, work);
break;
case 1:
if (TYPE(argv[itmp]) == T_FIXNUM) {
dir = FIX2INT(argv[itmp]);
work = gsl_wavelet_workspace_alloc(v->size);
flag = 1;
} else if (rb_obj_is_kind_of(argv[itmp], cgsl_wavelet_workspace)) {
Data_Get_Struct(argv[itmp], gsl_wavelet_workspace, work);
} else {
rb_raise(rb_eTypeError, "wrong argument type");
}
break;
case 0:
work = gsl_wavelet_workspace_alloc(v->size);
flag = 1;
break;
default:
rb_raise(rb_eArgError, "too many arguments");
break;
}
if (naflag == 0) {
if (sss == RB_GSL_DWT_COPY) {
vnew = gsl_vector_alloc(v->size);
gsl_vector_memcpy(vnew, v);
ary = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew);
ptr2 = vnew->data;
} else {
ary = ret;
ptr2 = ptr1;
}
} else {
#ifdef HAVE_NARRAY_H
if (sss == RB_GSL_DWT_COPY) {
ary = na_make_object(NA_DFLOAT, na1->rank, na1->shape, cNArray);
ptr2 = NA_PTR_TYPE(ary, double*);
memcpy(ptr2, ptr1, sizeof(double)*n);
} else {
/*
* Calculates a function at x, and returns the rusult.
*/
static VALUE rb_gsl_function_eval(VALUE obj, VALUE x)
{
gsl_function *F = NULL;
VALUE ary, proc, params, result, arynew, x2;
gsl_vector *v = NULL, *vnew = NULL;
gsl_matrix *m = NULL, *mnew = NULL;
size_t i, j, n;
Data_Get_Struct(obj, gsl_function, F);
ary = (VALUE) F->params;
proc = rb_ary_entry(ary, 0);
params = rb_ary_entry(ary, 1);
if (CLASS_OF(x) == rb_cRange) x = rb_gsl_range2ary(x);
switch (TYPE(x)) {
case T_FIXNUM:
case T_BIGNUM:
case T_FLOAT:
if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x);
else result = rb_funcall(proc, RBGSL_ID_call, 2, x, params);
return result;
break;
case T_ARRAY:
// n = RARRAY(x)->len;
n = RARRAY_LEN(x);
arynew = rb_ary_new2(n);
for (i = 0; i < n; i++) {
x2 = rb_ary_entry(x, i);
Need_Float(x2);
if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x2);
else result = rb_funcall(proc, RBGSL_ID_call, 2, x2, params);
rb_ary_store(arynew, i, result);
}
return arynew;
break;
default:
#ifdef HAVE_NARRAY_H
if (NA_IsNArray(x)) {
double *ptr1, *ptr2;
struct NARRAY *na;
GetNArray(x, na);
ptr1 = (double *) na->ptr;
n = na->total;
ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(x));
ptr2 = NA_PTR_TYPE(ary, double*);
for (i = 0; i < n; i++) {
x2 = rb_float_new(ptr1[i]);
if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x2);
else result = rb_funcall(proc, RBGSL_ID_call, 2, x2, params);
ptr2[i] = NUM2DBL(result);
}
return ary;
}
#endif
#ifdef HAVE_NMATRIX_H
if (NM_IsNMatrix(x)) {
double *ptr1, *ptr2;
NM_DENSE_STORAGE *nm;
nm = NM_STORAGE_DENSE(x);
ptr1 = (double *) nm->elements;
n = NM_DENSE_COUNT(x);
ary = rb_nmatrix_dense_create(FLOAT64, nm->shape, nm->dim, nm->elements, n);
ptr2 = (double*)NM_DENSE_ELEMENTS(ary);
for (i = 0; i < n; i++) {
x2 = rb_float_new(ptr1[i]);
if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x2);
else result = rb_funcall(proc, RBGSL_ID_call, 2, x2, params);
ptr2[i] = NUM2DBL(result);
}
return ary;
}
#endif
if (VECTOR_P(x)) {
Data_Get_Struct(x, gsl_vector, v);
vnew = gsl_vector_alloc(v->size);
for (i = 0; i < v->size; i++) {
x2 = rb_float_new(gsl_vector_get(v, i));
if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x2);
else result = rb_funcall(proc, RBGSL_ID_call, 2, x2, params);
gsl_vector_set(vnew, i, NUM2DBL(result));
}
return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew);
} else if (MATRIX_P(x)) {
Data_Get_Struct(x, gsl_matrix, m);
mnew = gsl_matrix_alloc(m->size1, m->size2);
for (i = 0; i < m->size1; i++) {
for (j = 0; j < m->size2; j++) {
x2 = rb_float_new(gsl_matrix_get(m, i, j));
if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x2);
else result = rb_funcall(proc, RBGSL_ID_call, 2, x2, params);
gsl_matrix_set(mnew, i, j, NUM2DBL(result));
}
}
return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);
} else {
rb_raise(rb_eTypeError, "wrong argument type");
}
break;
}
/* never reach here */
return Qnil;
}
static VALUE rb_gsl_cheb_eval_n_err(VALUE obj, VALUE nn, VALUE xx)
{
gsl_cheb_series *p = NULL;
double result, err;
VALUE x, ary, aerr;
size_t n, order, i, j;
gsl_vector *v, *vnew, *verr;
gsl_matrix *m, *mnew, *merr;
CHECK_FIXNUM(nn);
order = FIX2INT(nn);
Data_Get_Struct(obj, gsl_cheb_series, p);
if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx);
switch (TYPE(xx)) {
case T_FIXNUM:
case T_BIGNUM:
case T_FLOAT:
gsl_cheb_eval_n_err(p, order, NUM2DBL(xx), &result, &err);
return rb_ary_new3(2, rb_float_new(result), rb_float_new(err));
break;
case T_ARRAY:
// n = RARRAY(xx)->len;
n = RARRAY_LEN(xx);
ary = rb_ary_new2(n);
aerr = rb_ary_new2(n);
for (i = 0; i < n; i++) {
x = rb_ary_entry(xx, i);
Need_Float(xx);
gsl_cheb_eval_n_err(p, order, NUM2DBL(x), &result, &err);
rb_ary_store(ary, i, rb_float_new(result));
rb_ary_store(aerr, i, rb_float_new(err));
}
return rb_ary_new3(2, ary, aerr);
break;
default:
#ifdef HAVE_NARRAY_H
if (NA_IsNArray(xx)) {
struct NARRAY *na;
double *ptr1, *ptr2, *ptr3;
GetNArray(xx, na);
ptr1 = (double*) na->ptr;
n = na->total;
ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx));
aerr = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx));
ptr2 = NA_PTR_TYPE(ary,double*);
ptr3 = NA_PTR_TYPE(aerr,double*);
for (i = 0; i < n; i++) {
gsl_cheb_eval_n_err(p, order, ptr1[i], &result, &err);
ptr2[i] = result;
ptr3[i] = err;
}
return rb_ary_new3(2, ary, aerr);
}
#endif
if (VECTOR_P(xx)) {
Data_Get_Struct(xx, gsl_vector, v);
vnew = gsl_vector_alloc(v->size);
verr = gsl_vector_alloc(v->size);
for (i = 0; i < v->size; i++) {
gsl_cheb_eval_n_err(p, order, gsl_vector_get(v, i), &result, &err);
gsl_vector_set(vnew, i, result);
gsl_vector_set(verr, i, err);
}
return rb_ary_new3(2,
Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew),
Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, verr));
} else if (MATRIX_P(xx)) {
Data_Get_Struct(xx, gsl_matrix, m);
mnew = gsl_matrix_alloc(m->size1, m->size2);
merr = gsl_matrix_alloc(m->size1, m->size2);
for (i = 0; i < m->size1; i++) {
for (j = 0; j < m->size2; j++) {
gsl_cheb_eval_n_err(p, order, gsl_matrix_get(m, i, j), &result, &err);
gsl_matrix_set(mnew, i, j, result);
gsl_matrix_set(merr, i, j, err);
}
}
return rb_ary_new3(2,
Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew),
Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, merr));
} else {
rb_raise(rb_eTypeError, "wrong argument type");
}
break;
}
return Qnil; /* never reach here */
}
static VALUE rb_gsl_pow_int(VALUE obj, VALUE xx, VALUE nn)
{
VALUE x, ary, argv[2];
size_t i, j, size;
int n;
gsl_vector *v = NULL, *vnew = NULL;
gsl_matrix *m = NULL, *mnew = NULL;
if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx);
switch (TYPE(xx)) {
case T_FIXNUM:
case T_BIGNUM:
case T_FLOAT:
return rb_float_new(gsl_pow_int(NUM2DBL(xx), FIX2INT(nn)));
break;
case T_ARRAY:
CHECK_FIXNUM(nn);
n = FIX2INT(nn);
size = RARRAY_LEN(xx);
ary = rb_ary_new2(size);
for (i = 0; i < size; i++) {
x = rb_ary_entry(xx, i);
Need_Float(x);
// rb_ary_store(ary, i, rb_float_new(gsl_pow_int(RFLOAT(x)->value, n)));
rb_ary_store(ary, i, rb_float_new(gsl_pow_int(NUM2DBL(x), n)));
}
return ary;
break;
default:
#ifdef HAVE_NARRAY_H
if (NA_IsNArray(xx)) {
struct NARRAY *na;
double *ptr1, *ptr2;
CHECK_FIXNUM(nn);
n = FIX2INT(nn);
GetNArray(xx, na);
ptr1 = (double*) na->ptr;
size = na->total;
ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx));
ptr2 = NA_PTR_TYPE(ary, double*);
for (i = 0; i < size; i++) ptr2[i] = gsl_pow_int(ptr1[i], n);
return ary;
}
#endif
if (VECTOR_P(xx)) {
CHECK_FIXNUM(nn);
n = FIX2INT(nn);
Data_Get_Struct(xx, gsl_vector, v);
vnew = gsl_vector_alloc(v->size);
for (i = 0; i < v->size; i++) {
gsl_vector_set(vnew, i, gsl_pow_int(gsl_vector_get(v, i), n));
}
return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew);
} else if (MATRIX_P(xx)) {
CHECK_FIXNUM(nn);
n = FIX2INT(nn);
Data_Get_Struct(xx, gsl_matrix, m);
mnew = gsl_matrix_alloc(m->size1, m->size2);
for (i = 0; i < m->size1; i++) {
for (j = 0; j < m->size2; j++) {
gsl_matrix_set(mnew, i, j, gsl_pow_int(gsl_matrix_get(m, i, j), n));
}
}
return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);
} else if (COMPLEX_P(xx) || VECTOR_COMPLEX_P(xx) || MATRIX_COMPLEX_P(xx)) {
argv[0] = xx;
argv[1] = nn;
return rb_gsl_complex_pow_real(2, argv, obj);
} else {
rb_raise(rb_eTypeError, "wrong argument type %s (Array or Vector or Matrix expected)", rb_class2name(CLASS_OF(xx)));
}
break;
}
/* never reach here */
return Qnil;
}
static VALUE rb_gsl_interp_evaluate(VALUE obj, VALUE xxa, VALUE yya, VALUE xx,
double (*eval)(const gsl_interp *, const double [],
const double [], double,
gsl_interp_accel *))
{
rb_gsl_interp *rgi = NULL;
double *ptrx = NULL, *ptry = NULL;
gsl_vector *v = NULL, *vnew = NULL;
gsl_matrix *m = NULL, *mnew = NULL;
VALUE ary, x;
double val;
size_t n, i, j, size, stridex, stridey;
#ifdef HAVE_NARRAY_H
struct NARRAY *na = NULL;
double *ptrz = NULL, *ptr = NULL;
#endif
Data_Get_Struct(obj, rb_gsl_interp, rgi);
ptrx = get_vector_ptr(xxa, &stridex, &size);
if (size != rgi->p->size ){
rb_raise(rb_eTypeError, "size mismatch (xa:%d != %d)", (int) size, (int) rgi->p->size);
}
ptry = get_vector_ptr(yya, &stridey, &size);
if (size != rgi->p->size ){
rb_raise(rb_eTypeError, "size mismatch (ya:%d != %d)", (int) size, (int) rgi->p->size);
}
if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx);
switch (TYPE(xx)) {
case T_FIXNUM: case T_BIGNUM: case T_FLOAT:
Need_Float(xx);
return rb_float_new((*eval)(rgi->p, ptrx, ptry, NUM2DBL(xx), rgi->a));
break;
case T_ARRAY:
n = RARRAY(xx)->len;
ary = rb_ary_new2(n);
for (i = 0; i < n; i++) {
x = rb_ary_entry(xx, i);
Need_Float(x);
val = (*eval)(rgi->p, ptrx, ptry, NUM2DBL(x), rgi->a);
rb_ary_store(ary, i, rb_float_new(val));
}
return ary;
break;
default:
#ifdef HAVE_NARRAY_H
if (NA_IsNArray(xx)) {
GetNArray(xx, na);
ptrz = (double*) na->ptr;
ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx));
ptr = NA_PTR_TYPE(ary, double*);
for (i = 0; i < na->total; i++)
ptr[i] = (*eval)(rgi->p, ptrx, ptry, ptrz[i], rgi->a);
return ary;
}
#endif
if (VECTOR_P(xx)) {
Data_Get_Struct(xx, gsl_vector, v);
vnew = gsl_vector_alloc(v->size);
for (i = 0; i < v->size; i++) {
val = (*eval)(rgi->p, ptrx, ptry, gsl_vector_get(v, i), rgi->a);
gsl_vector_set(vnew, i, val);
}
return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew);
} else if (MATRIX_P(xx)) {
Data_Get_Struct(xx, gsl_matrix, m);
mnew = gsl_matrix_alloc(m->size1, m->size2);
for (i = 0; i < m->size1; i++) {
for (j = 0; j < m->size2; j++) {
val = (*eval)(rgi->p, ptrx, ptry, gsl_matrix_get(m, i, j), rgi->a);
gsl_matrix_set(mnew, i, j, val);
}
}
return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);
} else {
rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(xx)));
}
break;
}
/* never reach here */
return Qnil;
}
static VALUE rb_gsl_deriv_eval(VALUE obj, VALUE xx, VALUE hh,
int (*deriv)(const gsl_function *,
double, double,
double *, double *))
{
gsl_function *f = NULL;
double result, abserr, h;
VALUE x, ary, aerr;
gsl_vector *v = NULL, *vnew = NULL, *verr = NULL;
gsl_matrix *m = NULL, *mnew = NULL, *merr = NULL;
size_t n, i, j;
int status;
Need_Float(hh);
Data_Get_Struct(obj, gsl_function, f);
h = NUM2DBL(hh);
if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx);
switch (TYPE(xx)) {
case T_FIXNUM:
case T_BIGNUM:
case T_FLOAT:
status = (*deriv)(f, NUM2DBL(xx), h, &result, &abserr);
return rb_ary_new3(3, rb_float_new(result), rb_float_new(abserr), INT2FIX(status));
break;
case T_ARRAY:
// n = RARRAY(xx)->len;
n = RARRAY_LEN(xx);
ary = rb_ary_new2(n);
aerr = rb_ary_new2(n);
for (i = 0; i < n; i++) {
x = rb_ary_entry(xx, i);
Need_Float(x);
(*deriv)(f, NUM2DBL(x), h, &result, &abserr);
rb_ary_store(ary, i, rb_float_new(result));
rb_ary_store(aerr, i, rb_float_new(abserr));
}
return rb_ary_new3(2, ary, aerr);
break;
default:
#ifdef HAVE_NARRAY_H
if (NA_IsNArray(xx)) {
struct NARRAY *na;
double *ptr1, *ptr2, *ptr3;
VALUE ary2, ary3;
GetNArray(xx, na);
n = na->total;
ptr1 = (double*) na->ptr;
ary2 = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx));
ary3 = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx));
ptr2 = NA_PTR_TYPE(ary2, double*);
ptr3 = NA_PTR_TYPE(ary3, double*);
for (i = 0; i < n; i++) {
(*deriv)(f, ptr1[i], h, &result, &abserr);
ptr2[i] = result;
ptr3[i] = abserr;
}
return rb_ary_new3(2, ary2, ary3);
}
#endif
if (VECTOR_P(xx)) {
Data_Get_Struct(xx, gsl_vector, v);
vnew = gsl_vector_alloc(v->size);
verr = gsl_vector_alloc(v->size);
for (i = 0; i < v->size; i++) {
(*deriv)(f, gsl_vector_get(v, i), h, &result, &abserr);
gsl_vector_set(vnew, i, result);
gsl_vector_set(verr, i, abserr);
}
return rb_ary_new3(2,
Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew),
Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, verr));
} else if (MATRIX_P(xx)) {
Data_Get_Struct(xx, gsl_matrix, m);
mnew = gsl_matrix_alloc(m->size1, m->size2);
merr = gsl_matrix_alloc(m->size1, m->size2);
for (i = 0; i < m->size1; i++) {
for (j = 0; j < m->size2; j++) {
(*deriv)(f, gsl_matrix_get(m, i, j), h, &result, &abserr);
gsl_matrix_set(mnew, i, j, result);
gsl_matrix_set(merr, i, j, abserr);
}
}
return rb_ary_new3(2,
Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew),
Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, merr));
} else {
rb_raise(rb_eTypeError, "wrong argument type");
}
break;
}
return Qnil; /* never reach here */
}
static void
setup_trap_frame (int signo,
SIGINFO_T info,
SIGCONTEXT_T * scp,
struct trap_recovery_info * trinfo,
SCHEME_OBJECT * new_stack_pointer)
{
unsigned long saved_mask = GET_INT_MASK;
SCHEME_OBJECT handler;
SCHEME_OBJECT signal_name;
SET_INTERRUPT_MASK (0); /* To prevent GC for now. */
handler
= ((VECTOR_P (fixed_objects))
? (VECTOR_REF (fixed_objects, TRAP_HANDLER))
: SHARP_F);
if (!INTERPRETER_APPLICABLE_P (handler))
{
fprintf (stderr, "There is no trap handler for recovery!\n");
fflush (stderr);
termination_trap ();
}
signal_name =
((signo != 0)
? (char_pointer_to_string (find_signal_name (signo)))
: SHARP_F);
if (!FREE_OK_P (Free))
REQUEST_GC (0);
if (new_stack_pointer != 0)
stack_pointer = new_stack_pointer;
else
{
INITIALIZE_STACK ();
Will_Push (CONTINUATION_SIZE);
SET_RC (RC_END_OF_COMPUTATION);
SET_EXP (SHARP_F);
SAVE_CONT ();
Pushed ();
}
Will_Push (7 + CONTINUATION_SIZE);
STACK_PUSH (trinfo -> extra_trap_info);
STACK_PUSH (trinfo -> pc_info_2);
STACK_PUSH (trinfo -> pc_info_1);
STACK_PUSH (trinfo -> state);
STACK_PUSH (BOOLEAN_TO_OBJECT (new_stack_pointer != 0));
STACK_PUSH (find_signal_code_name (signo, info, scp));
STACK_PUSH (signal_name);
SET_RC (RC_HARDWARE_TRAP);
SET_EXP (long_to_integer (signo));
SAVE_CONT ();
Pushed ();
if ((new_stack_pointer != 0)
/* This may want to do it in other cases, but this may be enough. */
&& ((trinfo -> state) == STATE_COMPILED_CODE))
stop_history ();
history_register = (make_dummy_history ());
Will_Push (STACK_ENV_EXTRA_SLOTS + 2);
STACK_PUSH (signal_name);
STACK_PUSH (handler);
PUSH_APPLY_FRAME_HEADER (1);
Pushed ();
SET_INTERRUPT_MASK (saved_mask);
abort_to_interpreter (PRIM_APPLY);
}
void
Interpret (int pop_return_p)
{
long dispatch_code;
struct interpreter_state_s new_state;
/* Primitives jump back here for errors, requests to evaluate an
expression, apply a function, or handle an interrupt request. On
errors or interrupts they leave their arguments on the stack, the
primitive itself in GET_EXP. The code should do a primitive
backout in these cases, but not in others (apply, eval, etc.),
since the primitive itself will have left the state of the
interpreter ready for operation. */
bind_interpreter_state (&new_state);
dispatch_code = (setjmp (interpreter_catch_env));
preserve_signal_mask ();
fixup_float_environment ();
switch (dispatch_code)
{
case 0: /* first time */
if (pop_return_p)
goto pop_return; /* continue */
else
break; /* fall into eval */
case PRIM_APPLY:
PROCEED_AFTER_PRIMITIVE ();
goto internal_apply;
case PRIM_NO_TRAP_APPLY:
PROCEED_AFTER_PRIMITIVE ();
goto Apply_Non_Trapping;
case PRIM_APPLY_INTERRUPT:
PROCEED_AFTER_PRIMITIVE ();
PREPARE_APPLY_INTERRUPT ();
SIGNAL_INTERRUPT (PENDING_INTERRUPTS ());
case PRIM_APPLY_ERROR:
PROCEED_AFTER_PRIMITIVE ();
APPLICATION_ERROR (prim_apply_error_code);
case PRIM_DO_EXPRESSION:
SET_VAL (GET_EXP);
PROCEED_AFTER_PRIMITIVE ();
REDUCES_TO (GET_VAL);
case PRIM_NO_TRAP_EVAL:
SET_VAL (GET_EXP);
PROCEED_AFTER_PRIMITIVE ();
NEW_REDUCTION (GET_VAL, GET_ENV);
goto eval_non_trapping;
case PRIM_POP_RETURN:
PROCEED_AFTER_PRIMITIVE ();
goto pop_return;
case PRIM_RETURN_TO_C:
PROCEED_AFTER_PRIMITIVE ();
unbind_interpreter_state (interpreter_state);
return;
case PRIM_NO_TRAP_POP_RETURN:
PROCEED_AFTER_PRIMITIVE ();
goto pop_return_non_trapping;
case PRIM_INTERRUPT:
back_out_of_primitive ();
SIGNAL_INTERRUPT (PENDING_INTERRUPTS ());
case PRIM_ABORT_TO_C:
back_out_of_primitive ();
unbind_interpreter_state (interpreter_state);
return;
case ERR_ARG_1_WRONG_TYPE:
back_out_of_primitive ();
Do_Micro_Error (ERR_ARG_1_WRONG_TYPE, true);
goto internal_apply;
case ERR_ARG_2_WRONG_TYPE:
back_out_of_primitive ();
Do_Micro_Error (ERR_ARG_2_WRONG_TYPE, true);
goto internal_apply;
case ERR_ARG_3_WRONG_TYPE:
back_out_of_primitive ();
Do_Micro_Error (ERR_ARG_3_WRONG_TYPE, true);
goto internal_apply;
default:
back_out_of_primitive ();
Do_Micro_Error (dispatch_code, true);
goto internal_apply;
}
do_expression:
/* GET_EXP has an Scode item in it that should be evaluated and the
result left in GET_VAL.
A "break" after the code for any operation indicates that all
processing for this operation has been completed, and the next
step will be to pop a return code off the stack and proceed at
pop_return. This is sometimes called "executing the
continuation" since the return code can be considered the
continuation to be performed after the operation.
An operation can terminate with a REDUCES_TO or REDUCES_TO_NTH
macro. This indicates that the value of the current Scode item
is the value returned when the new expression is evaluated.
Therefore no new continuation is created and processing continues
at do_expression with the new expression in GET_EXP.
Finally, an operation can terminate with a DO_NTH_THEN macro.
This indicates that another expression must be evaluated and them
some additional processing will be performed before the value of
this S-Code item available. Thus a new continuation is created
and placed on the stack (using SAVE_CONT), the new expression is
placed in the GET_EXP, and processing continues at do_expression.
*/
/* Handling of Eval Trapping.
If we are handling traps and there is an Eval Trap set, turn off
all trapping and then go to internal_apply to call the user
supplied eval hook with the expression to be evaluated and the
environment. */
#ifdef COMPILE_STEPPER
if (trapping
&& (!WITHIN_CRITICAL_SECTION_P ())
&& ((FETCH_EVAL_TRAPPER ()) != SHARP_F))
{
trapping = false;
Will_Push (4);
PUSH_ENV ();
PUSH_EXP ();
STACK_PUSH (FETCH_EVAL_TRAPPER ());
PUSH_APPLY_FRAME_HEADER (2);
Pushed ();
goto Apply_Non_Trapping;
}
#endif /* COMPILE_STEPPER */
eval_non_trapping:
#ifdef EVAL_UCODE_HOOK
EVAL_UCODE_HOOK ();
#endif
switch (OBJECT_TYPE (GET_EXP))
{
case TC_BIG_FIXNUM: /* The self evaluating items */
case TC_BIG_FLONUM:
case TC_CHARACTER_STRING:
case TC_CHARACTER:
case TC_COMPILED_CODE_BLOCK:
case TC_COMPLEX:
case TC_CONTROL_POINT:
case TC_DELAYED:
case TC_ENTITY:
case TC_ENVIRONMENT:
case TC_EXTENDED_PROCEDURE:
case TC_FIXNUM:
case TC_HUNK3_A:
case TC_HUNK3_B:
case TC_INTERNED_SYMBOL:
case TC_LIST:
case TC_NON_MARKED_VECTOR:
case TC_NULL:
case TC_PRIMITIVE:
case TC_PROCEDURE:
case TC_QUAD:
case TC_RATNUM:
case TC_REFERENCE_TRAP:
case TC_RETURN_CODE:
case TC_UNINTERNED_SYMBOL:
case TC_CONSTANT:
case TC_VECTOR:
case TC_VECTOR_16B:
case TC_VECTOR_1B:
default:
SET_VAL (GET_EXP);
break;
case TC_ACCESS:
Will_Push (CONTINUATION_SIZE);
PUSH_NTH_THEN (RC_EXECUTE_ACCESS_FINISH, ACCESS_ENVIRONMENT);
case TC_ASSIGNMENT:
Will_Push (CONTINUATION_SIZE + 1);
PUSH_ENV ();
PUSH_NTH_THEN (RC_EXECUTE_ASSIGNMENT_FINISH, ASSIGN_VALUE);
case TC_BROKEN_HEART:
Microcode_Termination (TERM_BROKEN_HEART);
case TC_COMBINATION:
{
long length = ((VECTOR_LENGTH (GET_EXP)) - 1);
Will_Push (length + 2 + CONTINUATION_SIZE);
stack_pointer = (STACK_LOC (-length));
STACK_PUSH (MAKE_OBJECT (TC_MANIFEST_NM_VECTOR, length));
/* The finger: last argument number */
Pushed ();
if (length == 0)
{
PUSH_APPLY_FRAME_HEADER (0); /* Frame size */
DO_NTH_THEN (RC_COMB_APPLY_FUNCTION, COMB_FN_SLOT);
}
PUSH_ENV ();
DO_NTH_THEN (RC_COMB_SAVE_VALUE, (length + 1));
}
case TC_COMBINATION_1:
Will_Eventually_Push (CONTINUATION_SIZE + STACK_ENV_FIRST_ARG + 1);
PUSH_ENV ();
DO_NTH_THEN (RC_COMB_1_PROCEDURE, COMB_1_ARG_1);
case TC_COMBINATION_2:
Will_Eventually_Push (CONTINUATION_SIZE + STACK_ENV_FIRST_ARG + 2);
PUSH_ENV ();
DO_NTH_THEN (RC_COMB_2_FIRST_OPERAND, COMB_2_ARG_2);
case TC_COMMENT:
REDUCES_TO_NTH (COMMENT_EXPRESSION);
case TC_CONDITIONAL:
Will_Push (CONTINUATION_SIZE + 1);
PUSH_ENV ();
PUSH_NTH_THEN (RC_CONDITIONAL_DECIDE, COND_PREDICATE);
#ifdef CC_SUPPORT_P
case TC_COMPILED_ENTRY:
dispatch_code = (enter_compiled_expression ());
goto return_from_compiled_code;
#endif
case TC_DEFINITION:
Will_Push (CONTINUATION_SIZE + 1);
PUSH_ENV ();
PUSH_NTH_THEN (RC_EXECUTE_DEFINITION_FINISH, DEFINE_VALUE);
case TC_DELAY:
/* Deliberately omitted: EVAL_GC_CHECK (2); */
SET_VAL (MAKE_POINTER_OBJECT (TC_DELAYED, Free));
(Free[THUNK_ENVIRONMENT]) = GET_ENV;
(Free[THUNK_PROCEDURE]) = (MEMORY_REF (GET_EXP, DELAY_OBJECT));
Free += 2;
break;
case TC_DISJUNCTION:
Will_Push (CONTINUATION_SIZE + 1);
PUSH_ENV ();
PUSH_NTH_THEN (RC_DISJUNCTION_DECIDE, OR_PREDICATE);
case TC_EXTENDED_LAMBDA:
/* Deliberately omitted: EVAL_GC_CHECK (2); */
SET_VAL (MAKE_POINTER_OBJECT (TC_EXTENDED_PROCEDURE, Free));
(Free[PROCEDURE_LAMBDA_EXPR]) = GET_EXP;
(Free[PROCEDURE_ENVIRONMENT]) = GET_ENV;
Free += 2;
break;
case TC_IN_PACKAGE:
Will_Push (CONTINUATION_SIZE);
PUSH_NTH_THEN (RC_EXECUTE_IN_PACKAGE_CONTINUE, IN_PACKAGE_ENVIRONMENT);
case TC_LAMBDA:
case TC_LEXPR:
/* Deliberately omitted: EVAL_GC_CHECK (2); */
SET_VAL (MAKE_POINTER_OBJECT (TC_PROCEDURE, Free));
(Free[PROCEDURE_LAMBDA_EXPR]) = GET_EXP;
(Free[PROCEDURE_ENVIRONMENT]) = GET_ENV;
Free += 2;
break;
case TC_MANIFEST_NM_VECTOR:
EVAL_ERROR (ERR_EXECUTE_MANIFEST_VECTOR);
case TC_PCOMB0:
/* The argument to Will_Eventually_Push is determined by how
much will be on the stack if we back out of the primitive. */
Will_Eventually_Push (CONTINUATION_SIZE + STACK_ENV_FIRST_ARG);
Finished_Eventual_Pushing (CONTINUATION_SIZE + STACK_ENV_FIRST_ARG);
SET_EXP (OBJECT_NEW_TYPE (TC_PRIMITIVE, GET_EXP));
goto primitive_internal_apply;
case TC_PCOMB1:
Will_Eventually_Push (CONTINUATION_SIZE + STACK_ENV_FIRST_ARG + 1);
DO_NTH_THEN (RC_PCOMB1_APPLY, PCOMB1_ARG_SLOT);
case TC_PCOMB2:
Will_Eventually_Push (CONTINUATION_SIZE + STACK_ENV_FIRST_ARG + 2);
PUSH_ENV ();
DO_NTH_THEN (RC_PCOMB2_DO_1, PCOMB2_ARG_2_SLOT);
case TC_PCOMB3:
Will_Eventually_Push (CONTINUATION_SIZE + STACK_ENV_FIRST_ARG + 3);
PUSH_ENV ();
DO_NTH_THEN (RC_PCOMB3_DO_2, PCOMB3_ARG_3_SLOT);
case TC_SCODE_QUOTE:
SET_VAL (MEMORY_REF (GET_EXP, SCODE_QUOTE_OBJECT));
break;
case TC_SEQUENCE_2:
Will_Push (CONTINUATION_SIZE + 1);
PUSH_ENV ();
PUSH_NTH_THEN (RC_SEQ_2_DO_2, SEQUENCE_1);
case TC_SEQUENCE_3:
Will_Push (CONTINUATION_SIZE + 1);
PUSH_ENV ();
PUSH_NTH_THEN (RC_SEQ_3_DO_2, SEQUENCE_1);
case TC_SYNTAX_ERROR:
EVAL_ERROR (ERR_SYNTAX_ERROR);
case TC_THE_ENVIRONMENT:
SET_VAL (GET_ENV);
break;
case TC_VARIABLE:
{
SCHEME_OBJECT val = GET_VAL;
SCHEME_OBJECT name = (GET_VARIABLE_SYMBOL (GET_EXP));
long temp = (lookup_variable (GET_ENV, name, (&val)));
if (temp != PRIM_DONE)
{
/* Back out of the evaluation. */
if (temp == PRIM_INTERRUPT)
{
PREPARE_EVAL_REPEAT ();
SIGNAL_INTERRUPT (PENDING_INTERRUPTS ());
}
EVAL_ERROR (temp);
}
SET_VAL (val);
}
}
/* Now restore the continuation saved during an earlier part of the
EVAL cycle and continue as directed. */
pop_return:
#ifdef COMPILE_STEPPER
if (trapping
&& (!WITHIN_CRITICAL_SECTION_P ())
&& ((FETCH_RETURN_TRAPPER ()) != SHARP_F))
{
Will_Push (3);
trapping = false;
PUSH_VAL ();
STACK_PUSH (FETCH_RETURN_TRAPPER ());
PUSH_APPLY_FRAME_HEADER (1);
Pushed ();
goto Apply_Non_Trapping;
}
#endif /* COMPILE_STEPPER */
pop_return_non_trapping:
#ifdef POP_RETURN_UCODE_HOOK
POP_RETURN_UCODE_HOOK ();
#endif
RESTORE_CONT ();
#ifdef ENABLE_DEBUGGING_TOOLS
if (!RETURN_CODE_P (GET_RET))
{
PUSH_VAL (); /* For possible stack trace */
SAVE_CONT ();
Microcode_Termination (TERM_BAD_STACK);
}
#endif
/* Dispatch on the return code. A BREAK here will cause
a "goto pop_return" to occur, since this is the most
common occurrence.
*/
switch (OBJECT_DATUM (GET_RET))
{
case RC_COMB_1_PROCEDURE:
POP_ENV ();
PUSH_VAL (); /* Arg. 1 */
STACK_PUSH (SHARP_F); /* Operator */
PUSH_APPLY_FRAME_HEADER (1);
Finished_Eventual_Pushing (CONTINUATION_SIZE);
DO_ANOTHER_THEN (RC_COMB_APPLY_FUNCTION, COMB_1_FN);
case RC_COMB_2_FIRST_OPERAND:
POP_ENV ();
PUSH_VAL ();
PUSH_ENV ();
DO_ANOTHER_THEN (RC_COMB_2_PROCEDURE, COMB_2_ARG_1);
case RC_COMB_2_PROCEDURE:
POP_ENV ();
PUSH_VAL (); /* Arg 1, just calculated */
STACK_PUSH (SHARP_F); /* Function */
PUSH_APPLY_FRAME_HEADER (2);
Finished_Eventual_Pushing (CONTINUATION_SIZE);
DO_ANOTHER_THEN (RC_COMB_APPLY_FUNCTION, COMB_2_FN);
case RC_COMB_APPLY_FUNCTION:
END_SUBPROBLEM ();
goto internal_apply_val;
case RC_COMB_SAVE_VALUE:
{
long Arg_Number;
POP_ENV ();
Arg_Number = ((OBJECT_DATUM (STACK_REF (STACK_COMB_FINGER))) - 1);
(STACK_REF (STACK_COMB_FIRST_ARG + Arg_Number)) = GET_VAL;
(STACK_REF (STACK_COMB_FINGER))
= (MAKE_OBJECT (TC_MANIFEST_NM_VECTOR, Arg_Number));
/* DO NOT count on the type code being NMVector here, since
the stack parser may create them with #F here! */
if (Arg_Number > 0)
{
PUSH_ENV ();
DO_ANOTHER_THEN
(RC_COMB_SAVE_VALUE, ((COMB_ARG_1_SLOT - 1) + Arg_Number));
}
/* Frame Size */
STACK_PUSH (MEMORY_REF (GET_EXP, 0));
DO_ANOTHER_THEN (RC_COMB_APPLY_FUNCTION, COMB_FN_SLOT);
}
#ifdef CC_SUPPORT_P
#define DEFINE_COMPILER_RESTART(return_code, entry) \
case return_code: \
{ \
dispatch_code = (entry ()); \
goto return_from_compiled_code; \
}
DEFINE_COMPILER_RESTART
(RC_COMP_INTERRUPT_RESTART, comp_interrupt_restart);
DEFINE_COMPILER_RESTART
(RC_COMP_LOOKUP_TRAP_RESTART, comp_lookup_trap_restart);
DEFINE_COMPILER_RESTART
(RC_COMP_ASSIGNMENT_TRAP_RESTART, comp_assignment_trap_restart);
DEFINE_COMPILER_RESTART
(RC_COMP_OP_REF_TRAP_RESTART, comp_op_lookup_trap_restart);
DEFINE_COMPILER_RESTART
(RC_COMP_CACHE_REF_APPLY_RESTART, comp_cache_lookup_apply_restart);
DEFINE_COMPILER_RESTART
(RC_COMP_SAFE_REF_TRAP_RESTART, comp_safe_lookup_trap_restart);
DEFINE_COMPILER_RESTART
(RC_COMP_UNASSIGNED_TRAP_RESTART, comp_unassigned_p_trap_restart);
DEFINE_COMPILER_RESTART
(RC_COMP_LINK_CACHES_RESTART, comp_link_caches_restart);
DEFINE_COMPILER_RESTART
(RC_COMP_ERROR_RESTART, comp_error_restart);
case RC_REENTER_COMPILED_CODE:
dispatch_code = (return_to_compiled_code ());
goto return_from_compiled_code;
#endif
case RC_CONDITIONAL_DECIDE:
END_SUBPROBLEM ();
POP_ENV ();
REDUCES_TO_NTH
((GET_VAL == SHARP_F) ? COND_ALTERNATIVE : COND_CONSEQUENT);
case RC_DISJUNCTION_DECIDE:
/* Return predicate if it isn't #F; else do ALTERNATIVE */
END_SUBPROBLEM ();
POP_ENV ();
if (GET_VAL != SHARP_F)
goto pop_return;
REDUCES_TO_NTH (OR_ALTERNATIVE);
case RC_END_OF_COMPUTATION:
{
/* Signals bottom of stack */
interpreter_state_t previous_state;
previous_state = (interpreter_state -> previous_state);
if (previous_state == NULL_INTERPRETER_STATE)
{
termination_end_of_computation ();
/*NOTREACHED*/
}
else
{
dstack_position = interpreter_catch_dstack_position;
interpreter_state = previous_state;
return;
}
}
case RC_EVAL_ERROR:
/* Should be called RC_REDO_EVALUATION. */
POP_ENV ();
REDUCES_TO (GET_EXP);
case RC_EXECUTE_ACCESS_FINISH:
{
SCHEME_OBJECT val;
long code;
code = (lookup_variable (GET_VAL,
(MEMORY_REF (GET_EXP, ACCESS_NAME)),
(&val)));
if (code == PRIM_DONE)
SET_VAL (val);
else if (code == PRIM_INTERRUPT)
{
PREPARE_POP_RETURN_INTERRUPT (RC_EXECUTE_ACCESS_FINISH, GET_VAL);
SIGNAL_INTERRUPT (PENDING_INTERRUPTS ());
}
else
POP_RETURN_ERROR (code);
}
END_SUBPROBLEM ();
break;
case RC_EXECUTE_ASSIGNMENT_FINISH:
{
SCHEME_OBJECT variable = (MEMORY_REF (GET_EXP, ASSIGN_NAME));
SCHEME_OBJECT old_val;
long code;
POP_ENV ();
if (TC_VARIABLE == (OBJECT_TYPE (variable)))
code = (assign_variable (GET_ENV,
(GET_VARIABLE_SYMBOL (variable)),
GET_VAL,
(&old_val)));
else
code = ERR_BAD_FRAME;
if (code == PRIM_DONE)
SET_VAL (old_val);
else
{
PUSH_ENV ();
if (code == PRIM_INTERRUPT)
{
PREPARE_POP_RETURN_INTERRUPT
(RC_EXECUTE_ASSIGNMENT_FINISH, GET_VAL);
SIGNAL_INTERRUPT (PENDING_INTERRUPTS ());
}
else
POP_RETURN_ERROR (code);
}
}
END_SUBPROBLEM ();
break;
case RC_EXECUTE_DEFINITION_FINISH:
{
SCHEME_OBJECT name = (MEMORY_REF (GET_EXP, DEFINE_NAME));
SCHEME_OBJECT value = GET_VAL;
long result;
POP_ENV ();
result = (define_variable (GET_ENV, name, value));
if (result == PRIM_DONE)
{
END_SUBPROBLEM ();
SET_VAL (name);
break;
}
PUSH_ENV ();
if (result == PRIM_INTERRUPT)
{
PREPARE_POP_RETURN_INTERRUPT (RC_EXECUTE_DEFINITION_FINISH,
value);
SIGNAL_INTERRUPT (PENDING_INTERRUPTS ());
}
SET_VAL (value);
POP_RETURN_ERROR (result);
}
case RC_EXECUTE_IN_PACKAGE_CONTINUE:
if (ENVIRONMENT_P (GET_VAL))
{
END_SUBPROBLEM ();
SET_ENV (GET_VAL);
REDUCES_TO_NTH (IN_PACKAGE_EXPRESSION);
}
POP_RETURN_ERROR (ERR_BAD_FRAME);
case RC_HALT:
Microcode_Termination (TERM_TERM_HANDLER);
case RC_HARDWARE_TRAP:
{
/* This just reinvokes the handler */
SCHEME_OBJECT info = (STACK_REF (0));
SCHEME_OBJECT handler = SHARP_F;
SAVE_CONT ();
if (VECTOR_P (fixed_objects))
handler = (VECTOR_REF (fixed_objects, TRAP_HANDLER));
if (handler == SHARP_F)
{
outf_fatal ("There is no trap handler for recovery!\n");
termination_trap ();
/*NOTREACHED*/
}
Will_Push (STACK_ENV_EXTRA_SLOTS + 2);
STACK_PUSH (info);
STACK_PUSH (handler);
PUSH_APPLY_FRAME_HEADER (1);
Pushed ();
}
goto internal_apply;
/* internal_apply, the core of the application mechanism.
Branch here to perform a function application.
At this point the top of the stack contains an application
frame which consists of the following elements (see sdata.h):
- A header specifying the frame length.
- A procedure.
- The actual (evaluated) arguments.
No registers (except the stack pointer) are meaning full at
this point. Before interrupts or errors are processed, some
registers are cleared to avoid holding onto garbage if a
garbage collection occurs. */
case RC_INTERNAL_APPLY_VAL:
internal_apply_val:
(APPLY_FRAME_PROCEDURE ()) = GET_VAL;
case RC_INTERNAL_APPLY:
internal_apply:
#ifdef COMPILE_STEPPER
if (trapping
&& (!WITHIN_CRITICAL_SECTION_P ())
&& ((FETCH_APPLY_TRAPPER ()) != SHARP_F))
{
unsigned long frame_size = (APPLY_FRAME_SIZE ());
(* (STACK_LOC (0))) = (FETCH_APPLY_TRAPPER ());
PUSH_APPLY_FRAME_HEADER (frame_size);
trapping = false;
}
#endif /* COMPILE_STEPPER */
Apply_Non_Trapping:
if (PENDING_INTERRUPTS_P)
{
unsigned long interrupts = (PENDING_INTERRUPTS ());
PREPARE_APPLY_INTERRUPT ();
SIGNAL_INTERRUPT (interrupts);
}
perform_application:
#ifdef APPLY_UCODE_HOOK
APPLY_UCODE_HOOK ();
#endif
{
SCHEME_OBJECT Function = (APPLY_FRAME_PROCEDURE ());
apply_dispatch:
switch (OBJECT_TYPE (Function))
{
case TC_ENTITY:
{
unsigned long frame_size = (APPLY_FRAME_SIZE ());
SCHEME_OBJECT data = (MEMORY_REF (Function, ENTITY_DATA));
if ((VECTOR_P (data))
&& (frame_size < (VECTOR_LENGTH (data)))
&& ((VECTOR_REF (data, frame_size)) != SHARP_F)
&& ((VECTOR_REF (data, 0))
== (VECTOR_REF (fixed_objects, ARITY_DISPATCHER_TAG))))
{
Function = (VECTOR_REF (data, frame_size));
(APPLY_FRAME_PROCEDURE ()) = Function;
goto apply_dispatch;
}
(STACK_REF (0)) = (MEMORY_REF (Function, ENTITY_OPERATOR));
PUSH_APPLY_FRAME_HEADER (frame_size);
/* This must be done to prevent an infinite push loop by
an entity whose handler is the entity itself or some
other such loop. Of course, it will die if stack overflow
interrupts are disabled. */
STACK_CHECK (0);
goto internal_apply;
}
case TC_PROCEDURE:
{
unsigned long frame_size = (APPLY_FRAME_SIZE ());
Function = (MEMORY_REF (Function, PROCEDURE_LAMBDA_EXPR));
{
SCHEME_OBJECT formals
= (MEMORY_REF (Function, LAMBDA_FORMALS));
if ((frame_size != (VECTOR_LENGTH (formals)))
&& (((OBJECT_TYPE (Function)) != TC_LEXPR)
|| (frame_size < (VECTOR_LENGTH (formals)))))
APPLICATION_ERROR (ERR_WRONG_NUMBER_OF_ARGUMENTS);
}
if (GC_NEEDED_P (frame_size + 1))
{
PREPARE_APPLY_INTERRUPT ();
IMMEDIATE_GC (frame_size + 1);
}
{
SCHEME_OBJECT * end = (Free + 1 + frame_size);
SCHEME_OBJECT env
= (MAKE_POINTER_OBJECT (TC_ENVIRONMENT, Free));
(*Free++) = (MAKE_OBJECT (TC_MANIFEST_VECTOR, frame_size));
(void) STACK_POP ();
while (Free < end)
(*Free++) = (STACK_POP ());
SET_ENV (env);
REDUCES_TO (MEMORY_REF (Function, LAMBDA_SCODE));
}
}
case TC_CONTROL_POINT:
if ((APPLY_FRAME_SIZE ()) != 2)
APPLICATION_ERROR (ERR_WRONG_NUMBER_OF_ARGUMENTS);
SET_VAL (* (APPLY_FRAME_ARGS ()));
unpack_control_point (Function);
RESET_HISTORY ();
goto pop_return;
/* After checking the number of arguments, remove the
frame header since primitives do not expect it.
NOTE: This code must match the application code which
follows primitive_internal_apply. */
case TC_PRIMITIVE:
if (!IMPLEMENTED_PRIMITIVE_P (Function))
APPLICATION_ERROR (ERR_UNIMPLEMENTED_PRIMITIVE);
{
unsigned long n_args = (APPLY_FRAME_N_ARGS ());
/* Note that the first test below will fail for lexpr
primitives. */
if (n_args != (PRIMITIVE_ARITY (Function)))
{
if ((PRIMITIVE_ARITY (Function)) != LEXPR_PRIMITIVE_ARITY)
APPLICATION_ERROR (ERR_WRONG_NUMBER_OF_ARGUMENTS);
SET_LEXPR_ACTUALS (n_args);
}
stack_pointer = (APPLY_FRAME_ARGS ());
SET_EXP (Function);
APPLY_PRIMITIVE_FROM_INTERPRETER (Function);
POP_PRIMITIVE_FRAME (n_args);
goto pop_return;
}
case TC_EXTENDED_PROCEDURE:
{
SCHEME_OBJECT lambda;
SCHEME_OBJECT temp;
unsigned long nargs;
unsigned long nparams;
unsigned long formals;
unsigned long params;
unsigned long auxes;
long rest_flag;
long size;
long i;
SCHEME_OBJECT * scan;
nargs = (POP_APPLY_FRAME_HEADER ());
lambda = (MEMORY_REF (Function, PROCEDURE_LAMBDA_EXPR));
Function = (MEMORY_REF (lambda, ELAMBDA_NAMES));
nparams = ((VECTOR_LENGTH (Function)) - 1);
Function = (Get_Count_Elambda (lambda));
formals = (Elambda_Formals_Count (Function));
params = ((Elambda_Opts_Count (Function)) + formals);
rest_flag = (Elambda_Rest_Flag (Function));
auxes = (nparams - (params + rest_flag));
if ((nargs < formals) || (!rest_flag && (nargs > params)))
{
PUSH_APPLY_FRAME_HEADER (nargs);
APPLICATION_ERROR (ERR_WRONG_NUMBER_OF_ARGUMENTS);
}
/* size includes the procedure slot, but not the header. */
size = (params + rest_flag + auxes + 1);
if (GC_NEEDED_P
(size + 1
+ ((nargs > params)
? (2 * (nargs - params))
: 0)))
{
PUSH_APPLY_FRAME_HEADER (nargs);
PREPARE_APPLY_INTERRUPT ();
IMMEDIATE_GC
(size + 1
+ ((nargs > params)
? (2 * (nargs - params))
: 0));
}
scan = Free;
temp = (MAKE_POINTER_OBJECT (TC_ENVIRONMENT, scan));
(*scan++) = (MAKE_OBJECT (TC_MANIFEST_VECTOR, size));
if (nargs <= params)
{
for (i = (nargs + 1); (--i) >= 0; )
(*scan++) = (STACK_POP ());
for (i = (params - nargs); (--i) >= 0; )
(*scan++) = DEFAULT_OBJECT;
if (rest_flag)
(*scan++) = EMPTY_LIST;
for (i = auxes; (--i) >= 0; )
(*scan++) = UNASSIGNED_OBJECT;
}
else
{
/* rest_flag must be true. */
SCHEME_OBJECT list
= (MAKE_POINTER_OBJECT (TC_LIST, (scan + size)));
for (i = (params + 1); (--i) >= 0; )
(*scan++) = (STACK_POP ());
(*scan++) = list;
for (i = auxes; (--i) >= 0; )
(*scan++) = UNASSIGNED_OBJECT;
/* Now scan == OBJECT_ADDRESS (list) */
for (i = (nargs - params); (--i) >= 0; )
{
(*scan++) = (STACK_POP ());
(*scan) = MAKE_POINTER_OBJECT (TC_LIST, (scan + 1));
scan += 1;
}
(scan[-1]) = EMPTY_LIST;
}
Free = scan;
SET_ENV (temp);
REDUCES_TO (Get_Body_Elambda (lambda));
}
#ifdef CC_SUPPORT_P
case TC_COMPILED_ENTRY:
{
guarantee_cc_return (1 + (APPLY_FRAME_SIZE ()));
dispatch_code = (apply_compiled_procedure ());
return_from_compiled_code:
switch (dispatch_code)
{
case PRIM_DONE:
goto pop_return;
case PRIM_APPLY:
goto internal_apply;
case PRIM_INTERRUPT:
SIGNAL_INTERRUPT (PENDING_INTERRUPTS ());
case PRIM_APPLY_INTERRUPT:
PREPARE_APPLY_INTERRUPT ();
SIGNAL_INTERRUPT (PENDING_INTERRUPTS ());
case ERR_INAPPLICABLE_OBJECT:
case ERR_WRONG_NUMBER_OF_ARGUMENTS:
APPLICATION_ERROR (dispatch_code);
default:
Do_Micro_Error (dispatch_code, true);
goto internal_apply;
}
}
#endif
default:
APPLICATION_ERROR (ERR_INAPPLICABLE_OBJECT);
}
}
case RC_JOIN_STACKLETS:
unpack_control_point (GET_EXP);
break;
case RC_NORMAL_GC_DONE:
SET_VAL (GET_EXP);
/* Paranoia */
if (GC_NEEDED_P (gc_space_needed))
termination_gc_out_of_space ();
gc_space_needed = 0;
EXIT_CRITICAL_SECTION ({ SAVE_CONT (); });
break;
case RC_PCOMB1_APPLY:
END_SUBPROBLEM ();
PUSH_VAL (); /* Argument value */
Finished_Eventual_Pushing (CONTINUATION_SIZE + STACK_ENV_FIRST_ARG);
SET_EXP (MEMORY_REF (GET_EXP, PCOMB1_FN_SLOT));
primitive_internal_apply:
#ifdef COMPILE_STEPPER
if (trapping
&& (!WITHIN_CRITICAL_SECTION_P ())
&& ((FETCH_APPLY_TRAPPER ()) != SHARP_F))
{
Will_Push (3);
PUSH_EXP ();
STACK_PUSH (FETCH_APPLY_TRAPPER ());
PUSH_APPLY_FRAME_HEADER (1 + (PRIMITIVE_N_PARAMETERS (GET_EXP)));
Pushed ();
trapping = false;
goto Apply_Non_Trapping;
}
#endif /* COMPILE_STEPPER */
/* NOTE: This code must match the code in the TC_PRIMITIVE
case of internal_apply.
This code is simpler because:
1) The arity was checked at syntax time.
2) We don't have to deal with "lexpr" primitives.
3) We don't need to worry about unimplemented primitives because
unimplemented primitives will cause an error at invocation. */
{
SCHEME_OBJECT primitive = GET_EXP;
APPLY_PRIMITIVE_FROM_INTERPRETER (primitive);
POP_PRIMITIVE_FRAME (PRIMITIVE_ARITY (primitive));
break;
}
case RC_PCOMB2_APPLY:
END_SUBPROBLEM ();
PUSH_VAL (); /* Value of arg. 1 */
Finished_Eventual_Pushing (CONTINUATION_SIZE + STACK_ENV_FIRST_ARG);
SET_EXP (MEMORY_REF (GET_EXP, PCOMB2_FN_SLOT));
goto primitive_internal_apply;
case RC_PCOMB2_DO_1:
POP_ENV ();
PUSH_VAL (); /* Save value of arg. 2 */
DO_ANOTHER_THEN (RC_PCOMB2_APPLY, PCOMB2_ARG_1_SLOT);
case RC_PCOMB3_APPLY:
END_SUBPROBLEM ();
PUSH_VAL (); /* Save value of arg. 1 */
Finished_Eventual_Pushing (CONTINUATION_SIZE + STACK_ENV_FIRST_ARG);
SET_EXP (MEMORY_REF (GET_EXP, PCOMB3_FN_SLOT));
goto primitive_internal_apply;
case RC_PCOMB3_DO_1:
{
SCHEME_OBJECT Temp = (STACK_POP ()); /* Value of arg. 3 */
POP_ENV ();
STACK_PUSH (Temp); /* Save arg. 3 again */
PUSH_VAL (); /* Save arg. 2 */
DO_ANOTHER_THEN (RC_PCOMB3_APPLY, PCOMB3_ARG_1_SLOT);
}
case RC_PCOMB3_DO_2:
SET_ENV (STACK_REF (0));
PUSH_VAL (); /* Save value of arg. 3 */
DO_ANOTHER_THEN (RC_PCOMB3_DO_1, PCOMB3_ARG_2_SLOT);
case RC_POP_RETURN_ERROR:
case RC_RESTORE_VALUE:
SET_VAL (GET_EXP);
break;
/* The following two return codes are both used to restore a
saved history object. The difference is that the first does
not copy the history object while the second does. In both
cases, the GET_EXP contains the history object and the
next item to be popped off the stack contains the offset back
to the previous restore history return code. */
case RC_RESTORE_DONT_COPY_HISTORY:
{
prev_restore_history_offset = (OBJECT_DATUM (STACK_POP ()));
(void) STACK_POP ();
history_register = (OBJECT_ADDRESS (GET_EXP));
break;
}
case RC_RESTORE_HISTORY:
{
if (!restore_history (GET_EXP))
{
SAVE_CONT ();
Will_Push (CONTINUATION_SIZE);
SET_EXP (GET_VAL);
SET_RC (RC_RESTORE_VALUE);
SAVE_CONT ();
Pushed ();
IMMEDIATE_GC (HEAP_AVAILABLE);
}
prev_restore_history_offset = (OBJECT_DATUM (STACK_POP ()));
(void) STACK_POP ();
if (prev_restore_history_offset > 0)
(STACK_LOCATIVE_REFERENCE (STACK_BOTTOM,
(-prev_restore_history_offset)))
= (MAKE_RETURN_CODE (RC_RESTORE_HISTORY));
break;
}
case RC_RESTORE_INT_MASK:
SET_INTERRUPT_MASK (UNSIGNED_FIXNUM_TO_LONG (GET_EXP));
if (GC_NEEDED_P (0))
REQUEST_GC (0);
if (PENDING_INTERRUPTS_P)
{
SET_RC (RC_RESTORE_VALUE);
SET_EXP (GET_VAL);
SAVE_CONT ();
SIGNAL_INTERRUPT (PENDING_INTERRUPTS ());
}
break;
case RC_STACK_MARKER:
/* Frame consists of the return code followed by two objects.
The first object has already been popped into GET_EXP,
so just pop the second argument. */
stack_pointer = (STACK_LOCATIVE_OFFSET (stack_pointer, 1));
break;
case RC_SEQ_2_DO_2:
END_SUBPROBLEM ();
POP_ENV ();
REDUCES_TO_NTH (SEQUENCE_2);
case RC_SEQ_3_DO_2:
SET_ENV (STACK_REF (0));
DO_ANOTHER_THEN (RC_SEQ_3_DO_3, SEQUENCE_2);
case RC_SEQ_3_DO_3:
END_SUBPROBLEM ();
POP_ENV ();
REDUCES_TO_NTH (SEQUENCE_3);
case RC_SNAP_NEED_THUNK:
/* Don't snap thunk twice; evaluation of the thunk's body might
have snapped it already. */
if ((MEMORY_REF (GET_EXP, THUNK_SNAPPED)) == SHARP_T)
SET_VAL (MEMORY_REF (GET_EXP, THUNK_VALUE));
else
{
MEMORY_SET (GET_EXP, THUNK_SNAPPED, SHARP_T);
MEMORY_SET (GET_EXP, THUNK_VALUE, GET_VAL);
}
break;
default:
POP_RETURN_ERROR (ERR_INAPPLICABLE_CONTINUATION);
}
static VALUE rb_gsl_cheb_eval(VALUE obj, VALUE xx)
{
gsl_cheb_series *p = NULL;
VALUE x, ary;
size_t i, j, n;
gsl_vector *v = NULL, *vnew = NULL;
gsl_matrix *m = NULL, *mnew = NULL;
Data_Get_Struct(obj, gsl_cheb_series, p);
if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx);
switch (TYPE(xx)) {
case T_FIXNUM:
case T_BIGNUM:
case T_FLOAT:
return rb_float_new(gsl_cheb_eval(p, NUM2DBL(xx)));
break;
case T_ARRAY:
// n = RARRAY(xx)->len;
n = RARRAY_LEN(xx);
ary = rb_ary_new2(n);
for (i = 0; i < n; i++) {
x = rb_ary_entry(xx, i);
Need_Float(xx);
rb_ary_store(ary, i, rb_float_new(gsl_cheb_eval(p, NUM2DBL(x))));
}
return ary;
break;
default:
#ifdef HAVE_NARRAY_H
if (NA_IsNArray(xx)) {
struct NARRAY *na;
double *ptr1, *ptr2;
GetNArray(xx, na);
ptr1 = (double*) na->ptr;
n = na->total;
ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx));
ptr2 = NA_PTR_TYPE(ary,double*);
for (i = 0; i < n; i++) ptr2[i] = gsl_cheb_eval(p, ptr1[i]);
return ary;
}
#endif
if (VECTOR_P(xx)) {
Data_Get_Struct(xx, gsl_vector, v);
vnew = gsl_vector_alloc(v->size);
for (i = 0; i < v->size; i++) {
gsl_vector_set(vnew, i, gsl_cheb_eval(p, gsl_vector_get(v, i)));
}
return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew);
} else if (MATRIX_P(xx)) {
Data_Get_Struct(xx, gsl_matrix, m);
mnew = gsl_matrix_alloc(m->size1, m->size2);
for (i = 0; i < m->size1; i++) {
for (j = 0; j < m->size2; j++) {
gsl_matrix_set(mnew, i, j, gsl_cheb_eval(p, gsl_matrix_get(m, i, j)));
}
}
return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);
} else {
rb_raise(rb_eTypeError, "wrong argument type");
}
break;
}
return Qnil; /* never reach here */
}
static VALUE rb_gsl_spline_evaluate(VALUE obj, VALUE xx,
double (*eval)(const gsl_spline *, double,
gsl_interp_accel *))
{
rb_gsl_spline *rgs = NULL;
gsl_vector *v = NULL, *vnew = NULL;
gsl_matrix *m = NULL, *mnew = NULL;
VALUE ary, x;
double val;
size_t n, i, j;
#ifdef HAVE_NARRAY_H
double *ptr1 = NULL, *ptr2 = NULL;
struct NARRAY *na = NULL;
#endif
Data_Get_Struct(obj, rb_gsl_spline, rgs);
if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx);
switch (TYPE(xx)) {
case T_FIXNUM: case T_BIGNUM: case T_FLOAT:
Need_Float(xx);
return rb_float_new((*eval)(rgs->s, NUM2DBL(xx), rgs->a));
break;
case T_ARRAY:
n = RARRAY_LEN(xx);
ary = rb_ary_new2(n);
for (i = 0; i < n; i++) {
x = rb_ary_entry(xx, i);
Need_Float(x);
val = (*eval)(rgs->s, NUM2DBL(x), rgs->a);
rb_ary_store(ary, i, rb_float_new(val));
}
return ary;
break;
default:
#ifdef HAVE_NARRAY_H
if (NA_IsNArray(xx)) {
GetNArray(xx, na);
ptr1 = (double *) na->ptr;
n = na->total;
ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx));
ptr2 = NA_PTR_TYPE(ary, double*);
for (i = 0; i < n; i++)
ptr2[i] = (*eval)(rgs->s, ptr1[i], rgs->a);
return ary;
}
#endif
if (VECTOR_P(xx)) {
Data_Get_Struct(xx, gsl_vector, v);
vnew = gsl_vector_alloc(v->size);
for (i = 0; i < v->size; i++) {
val = (*eval)(rgs->s, gsl_vector_get(v, i), rgs->a);
gsl_vector_set(vnew, i, val);
}
return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew);
} else if (MATRIX_P(xx)) {
Data_Get_Struct(xx, gsl_matrix, m);
mnew = gsl_matrix_alloc(m->size1, m->size2);
for (i = 0; i < m->size1; i++) {
for (j = 0; j < m->size2; j++) {
val = (*eval)(rgs->s, gsl_matrix_get(m, i, j), rgs->a);
gsl_matrix_set(mnew, i, j, val);
}
}
return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);
} else {
rb_raise(rb_eTypeError, "wrong argument type %s", rb_class2name(CLASS_OF(xx)));
}
break;
}
/* never reach here */
return Qnil;
}
static VALUE rb_gsl_graph_step(int argc, VALUE *argv, VALUE obj)
{
#ifdef HAVE_GNU_GRAPH
gsl_graph *g = NULL;
gsl_vector *x = NULL, *y = NULL;
size_t i, size;
FILE *fp;
char command[1024];
Data_Get_Struct(obj, gsl_graph, g);
gsl_graph_set_command(g, command);
switch (argc) {
case 3:
Check_Type(argv[2], T_STRING);
sprintf(command, "%s %s", command, STR2CSTR(argv[2]));
/* no break */
case 2:
if (TYPE(argv[1]) == T_STRING) {
sprintf(command, "%s %s", command, STR2CSTR(argv[1]));
} else if (VECTOR_P(argv[1])) {
g->ydata = argv[1];
} else {
rb_raise(rb_eTypeError, "wrong argument type %s (Vector or String expected)",
rb_class2name(CLASS_OF(argv[1])));
}
/* no break */
case 1:
if (TYPE(argv[0]) == T_STRING) {
sprintf(command, "%s %s", command, STR2CSTR(argv[0]));
} else if (VECTOR_P(argv[0])) {
g->xdata = argv[0];
} else {
rb_raise(rb_eTypeError, "wrong argument type %s (Vector or String expected)",
rb_class2name(CLASS_OF(argv[0])));
}
break;
default:
rb_raise(rb_eArgError, "wrong number of argumeuts (%d for 1-3)", argc);
break;
}
if (VECTOR_P(g->xdata)) Data_Get_Struct(g->xdata, gsl_vector, x);
if (VECTOR_P(g->ydata)) Data_Get_Struct(g->ydata, gsl_vector, y);
if (x == NULL)
rb_raise(rb_eRuntimeError, "data is not given");
size = x->size;
fp = popen(command, "w");
if (fp == NULL) rb_raise(rb_eIOError, "GNU graph not found.");
for (i = 0; i < size; i++) {
if (y == NULL) {
fprintf(fp, "%d %g\n%d %g\n", (int) i, gsl_vector_get(x, i),
(int) (i+1), gsl_vector_get(x, i));
} else {
if (i != size-1)
fprintf(fp, "%g %g\n%g %g\n", gsl_vector_get(x, i), gsl_vector_get(y, i),
gsl_vector_get(x, i+1), gsl_vector_get(y, i));
else
fprintf(fp, "%g %g\n%g %g", gsl_vector_get(x, i), gsl_vector_get(y, i),
2.0*gsl_vector_get(x, i)-gsl_vector_get(x, i-1), gsl_vector_get(y, i));
}
}
fflush(fp);
pclose(fp);
fp = NULL;
return Qtrue;
#else
rb_raise(rb_eNoMethodError, "GNU plotutils required");
return Qfalse;
#endif
}
/**
* arguments:
* - Plm_array(x) : lmax = w->lmax, A new vector is created
* - Plm_array(x, result) : lmax = w->lmax, the given vector is used
* - Plm_array(lmax, x) : A new vector is created
* - Plm_array(lmax, x, result) : Same as C Plm_array()
* - Plm_array(x, result, deriv) : lmax = w->lmax, calcurate Plm_deriv_array(lmax, x, result, deriv)
* - Plm_array(lmax, x, result, deriv) : Same as C alf_Plm_deriv_array
*/
static VALUE rb_alf_Plm_array(int argc, VALUE *argv, VALUE obj)
{
alf_workspace *w = NULL;
gsl_vector *res = NULL, *deriv = NULL;
int lmax;
double x;
VALUE ret;
Data_Get_Struct(obj, alf_workspace, w);
switch (argc) {
case 1:
x = NUM2DBL(argv[0]);
lmax = w->lmax;
res = gsl_vector_alloc(alf_array_size(lmax));
ret = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, res);
break;
case 2: // Plm_array(x, result) or Plm_array(lmax, x)
if (VECTOR_P(argv[1])) {
x = NUM2DBL(argv[0]);
Data_Get_Struct(argv[1], gsl_vector, res);
lmax = w->lmax;
if (res->size < alf_array_size(lmax)) {
rb_raise(rb_eRuntimeError, "Vector length is too small. (%d for >= %d\n", (int) res->size,
(int) alf_array_size(lmax));
}
ret = argv[1];
} else {
lmax = FIX2INT(argv[0]);
x = NUM2DBL(argv[1]);
res = gsl_vector_alloc(alf_array_size(lmax));
ret = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, res);
}
break;
case 3: // Plm_array(lmax, x, result) or Plm_array(x, result, deriv)
if (VECTOR_P(argv[1])) {
CHECK_VECTOR(argv[2]);
lmax = w->lmax;
x = NUM2DBL(argv[0]);
Data_Get_Struct(argv[1], gsl_vector, res);
Data_Get_Struct(argv[2], gsl_vector, deriv);
ret = argv[1];
} else {
lmax = FIX2INT(argv[0]);
x = NUM2DBL(argv[1]);
CHECK_VECTOR(argv[2]);
Data_Get_Struct(argv[2], gsl_vector, res);
if (res->size < alf_array_size(lmax)) {
rb_raise(rb_eRuntimeError, "Vector length is too small. (%d for >= %d\n", (int) res->size,
(int) alf_array_size(lmax));
}
ret = argv[2];
}
break;
case 4:
CHECK_VECTOR(argv[2]); CHECK_VECTOR(argv[3])
lmax = FIX2INT(argv[0]);
x = NUM2DBL(argv[1]);
Data_Get_Struct(argv[2], gsl_vector, res);
Data_Get_Struct(argv[3], gsl_vector, deriv);
ret = argv[2];
break;
default:
rb_raise(rb_eArgError, "Wrong number of argumentso (%d for 1-3)\n", argc);
}
if (argc == 4 && deriv != NULL) alf_Plm_deriv_array(lmax, x, res->data, deriv->data, w);
else alf_Plm_array(lmax, x, res->data, w);
return ret;
}
