static int push_three_float_arrays (SLindex_Type n, float *a, float *b, float *c) /*{{{*/
{
SLang_Array_Type *sl_a=NULL, *sl_b=NULL, *sl_c=NULL;
int status = -1;
if (a == NULL || b == NULL || c == NULL)
return -1;
if ((NULL == (sl_a = SLang_create_array (SLANG_FLOAT_TYPE, 0, NULL, &n, 1)))
|| NULL == (sl_b = SLang_create_array (SLANG_FLOAT_TYPE, 0, NULL, &n, 1))
|| NULL == (sl_c = SLang_create_array (SLANG_FLOAT_TYPE, 0, NULL, &n, 1)))
goto return_status;
memcpy ((char *)sl_a->data, (char *)a, n * sizeof(float));
memcpy ((char *)sl_b->data, (char *)b, n * sizeof(float));
memcpy ((char *)sl_c->data, (char *)c, n * sizeof(float));
SLang_push_array (sl_a, 1);
SLang_push_array (sl_b, 1);
SLang_push_array (sl_c, 1);
status = 0;
return_status:
if (status)
{
SLang_free_array (sl_a);
SLang_free_array (sl_b);
SLang_free_array (sl_c);
}
return status;
}
static void _fft1d (int *isign, double *scaling) /*{{{*/
{
SLang_Array_Type *re, *im;
int dims;
int ndim = 1;
re = im = NULL;
if (-1 == SLang_pop_array_of_type (&im, SLANG_DOUBLE_TYPE)
|| im == NULL
|| -1 == SLang_pop_array_of_type (&re, SLANG_DOUBLE_TYPE)
|| re == NULL
|| re->num_elements != im->num_elements
|| abs(*isign) != 1)
{
isis_vmesg (FAIL, I_ERROR, __FILE__, __LINE__, "invalid input to FFT");
goto push_values;
}
dims = (int) re->num_elements;
if (-1 == JDMfftn (ndim, &dims, (double *)re->data,
(double *)im->data, *isign, *scaling))
isis_vmesg (FAIL, I_FAILED, __FILE__, __LINE__, "computing FFT");
JDMfft_free ();
push_values:
(void) SLang_push_array (re, 1);
(void) SLang_push_array (im, 1);
}
static void read_image (int flipped)
{
int color_type;
char *file;
SLang_Ref_Type *ref = NULL;
SLang_Array_Type *at;
if ((SLang_Num_Function_Args == 2)
&& (-1 == SLang_pop_ref (&ref)))
return;
if (-1 == SLang_pop_slstring (&file))
{
file = NULL;
goto free_return;
}
if (NULL == (at = read_image_internal (file, flipped, &color_type)))
goto free_return;
if ((ref != NULL)
&& (-1 == SLang_assign_to_ref (ref, SLANG_INT_TYPE, &color_type)))
{
SLang_free_array (at);
goto free_return;
}
(void) SLang_push_array (at, 1);
free_return:
SLang_free_slstring (file);
if (ref != NULL)
SLang_free_ref (ref);
}
static void lu_solve_intrin (void)
{
Linear_System_Type t;
SLang_Array_Type *sl_b = NULL;
unsigned int *piv = NULL;
if ((-1 == pop_linear_system (&t))
|| (NULL == (piv = (unsigned int *) ISIS_MALLOC (t.n * sizeof(unsigned int)))))
{
isis_throw_exception (Isis_Error);
goto the_return;
}
if (-1 == isis_lu_solve (t.a, t.n, piv, t.b))
goto the_return;
sl_b = SLang_create_array (SLANG_DOUBLE_TYPE, 0, NULL, &t.n, 1);
if (sl_b != NULL)
{
memcpy ((char *)sl_b->data, (char *)t.b, t.n * sizeof (double));
}
the_return:
SLang_push_array (sl_b, 1);
free_linear_system (&t);
ISIS_FREE(piv);
}
static int push_values_array (Values_Array_Type *av, int allow_empty_array)
{
SLang_Array_Type *at;
char **new_values;
if (av->num == 0)
{
if (allow_empty_array == 0)
return SLang_push_null ();
SLfree ((char *) av->values);
av->values = NULL;
}
else
{
if (NULL == (new_values = (char **)SLrealloc ((char *)av->values, av->num*sizeof(char *))))
return -1;
av->values = new_values;
}
av->num_allocated = av->num;
at = SLang_create_array (SLANG_STRING_TYPE, 0, av->values, &av->num, 1);
if (at == NULL)
return -1;
av->num_allocated = 0;
av->num = 0;
av->values = NULL;
return SLang_push_array (at, 1);
}
static void intrin_atof (void)
{
char *s;
SLang_Array_Type *ats;
SLang_Array_Type *ati;
double *ip;
char **strp, **strpmax;
if (-1 == pop_array_or_string (SLANG_DOUBLE_TYPE, &s, &ats, &ati))
return;
if (s != NULL)
{
(void) SLang_push_double(_pSLang_atof(s));
SLang_free_slstring (s);
return;
}
strp = (char **) ats->data;
strpmax = strp + ats->num_elements;
ip = (double *) ati->data;
while (strp < strpmax)
{
if (*strp == NULL)
*ip++ = _pSLang_NaN;
else
*ip++ = _pSLang_atof (*strp);
strp++;
}
SLang_free_array (ats);
(void) SLang_push_array (ati, 1);
}
static int push_cols (double *d, unsigned int n, unsigned int ncols) /*{{{*/
{
SLindex_Type nrows;
unsigned int c;
if ((ncols == 0) || (d == NULL))
return -1;
nrows = n / ncols;
for (c = 0; c < ncols; c++)
{
SLang_Array_Type *at;
unsigned int k, i;
double *x;
at = SLang_create_array (SLANG_DOUBLE_TYPE, 0, NULL, &nrows, 1);
if (at == NULL)
return -1;
x = (double *) at->data;
i = 0;
for (k = c; k < n; k += ncols)
{
x[i++] = d[k];
}
SLang_push_array (at, 1);
}
return 0;
}
static void atoll_intrin (void)
{
char *s;
SLang_Array_Type *ats;
SLang_Array_Type *ati;
long long *ip;
char **strp, **strpmax;
if (-1 == pop_array_or_string (_pSLANG_LLONG_TYPE, &s, &ats, &ati))
return;
if (s != NULL)
{
(void) SLang_push_long_long (ATOLL_FUN(s));
SLang_free_slstring (s);
return;
}
strp = (char **) ats->data;
strpmax = strp + ats->num_elements;
ip = (long long *) ati->data;
while (strp < strpmax)
{
if (*strp == NULL)
*ip++ = 0;
else
*ip++ = ATOLL_FUN (*strp);
strp++;
}
SLang_free_array (ats);
(void) SLang_push_array (ati, 1);
}
static void atoi_intrin (void)
{
char *s;
SLang_Array_Type *ats;
SLang_Array_Type *ati;
int *ip;
char **strp, **strpmax;
if (-1 == pop_array_or_string (SLANG_INT_TYPE, &s, &ats, &ati))
return;
if (s != NULL)
{
(void) SLang_push_integer (atoi (s));
SLang_free_slstring (s);
return;
}
strp = (char **) ats->data;
strpmax = strp + ats->num_elements;
ip = (int *) ati->data;
while (strp < strpmax)
{
if (*strp == NULL)
*ip++ = 0;
else
*ip++ = atoi (*strp);
strp++;
}
SLang_free_array (ats);
(void) SLang_push_array (ati, 1);
}
static void get_onig_names (Name_Map_Type *map)
{
SLindex_Type i, num;
SLang_Array_Type *at;
char **names;
Name_Map_Type *table;
table = map;
while (table->name != NULL)
table++;
num = (SLindex_Type) (table - map);
if (NULL == (at = SLang_create_array (SLANG_STRING_TYPE, 0, NULL, &num, 1)))
return;
table = map;
names = (char **)at->data;
for (i = 0; i < num; i++)
{
if (NULL == (names[i] = SLang_create_slstring (table->name)))
{
SLang_free_array (at);
return;
}
table++;
}
(void) SLang_push_array (at, 1);
}
static void assoc_get_keys (SLang_Assoc_Array_Type *a)
{
SLang_Array_Type *at;
SLindex_Type i, num;
char **data;
_pSLAssoc_Array_Element_Type *e, *emax;
/* Note: If support for threads is added, then we need to modify this
* algorithm to prevent another thread from modifying the array.
* However, that should be handled in inner_interp.
*/
num = a->num_occupied - a->num_deleted;
if (NULL == (at = SLang_create_array (SLANG_STRING_TYPE, 0, NULL, &num, 1)))
return;
data = (char **)at->data;
e = a->elements;
emax = e + a->table_len;
i = 0;
while (e < emax)
{
if ((e->key != NULL) && (e->key != Deleted_Key))
{
/* Next cannot fail because it is an slstring */
data [i] = _pSLstring_dup_hashed_string (e->key, e->hash);
i++;
}
e++;
}
(void) SLang_push_array (at, 1);
}
static int do_binary_function (double (*f)(double, double))
{
SLtype type;
Array_Or_Scalar_Type a_ast, b_ast, c_ast;
if (-1 == pop_2_arrays_or_scalar (&a_ast, &b_ast))
return -1;
c_ast.is_float = (a_ast.is_float && b_ast.is_float);
c_ast.at = NULL;
c_ast.num = 1;
c_ast.inc = 0;
if (c_ast.is_float)
{
type = SLANG_FLOAT_TYPE;
c_ast.fptr = &c_ast.f;
}
else
{
type = SLANG_DOUBLE_TYPE;
c_ast.dptr = &c_ast.d;
}
if ((a_ast.at != NULL) || (b_ast.at != NULL))
{
if (NULL == (c_ast.at = create_from_tmp_array (a_ast.at, b_ast.at, type)))
{
free_array_or_scalar (&a_ast);
free_array_or_scalar (&b_ast);
return -1;
}
c_ast.fptr = (float *) c_ast.at->data;
c_ast.dptr = (double *) c_ast.at->data;
c_ast.num = c_ast.at->num_elements;
c_ast.inc = 1;
}
if (a_ast.is_float)
{
if (b_ast.is_float)
(void) do_ff_fun (f, &a_ast, &b_ast, &c_ast);
else
(void) do_fd_fun (f, &a_ast, &b_ast, &c_ast);
}
else if (b_ast.is_float)
(void) do_df_fun (f, &a_ast, &b_ast, &c_ast);
else
(void) do_dd_fun (f, &a_ast, &b_ast, &c_ast);
free_array_or_scalar (&a_ast);
free_array_or_scalar (&b_ast);
if (c_ast.at != NULL)
return SLang_push_array (c_ast.at, 1);
if (c_ast.is_float)
return SLang_push_float (c_ast.f);
return SLang_push_double (c_ast.d);
}
static void prand_array (double *rate, SLindex_Type *num) /*{{{*/
{
SLang_Array_Type *at = NULL;
double *ai;
SLindex_Type i, n;
n = *num;
if (n == 0)
return;
else if (n == 1)
{
SLang_push_double (prand (*rate));
return;
}
if (NULL == (at = SLang_create_array (SLANG_DOUBLE_TYPE, 0, NULL, &n, 1)))
{
isis_vmesg (INTR, I_FAILED, __FILE__, __LINE__, "creating array of random values");
return;
}
ai = (double *) at->data;
for (i = 0; i < n; i++)
{
ai[i] = prand (*rate);
}
SLang_push_array (at, 1);
}
static void rand_array (SLindex_Type num, double (*rand_fun)(void)) /*{{{*/
{
SLang_Array_Type *at = NULL;
double *ad;
SLindex_Type i;
if (num <= 0)
return;
else if (num == 1)
{
SLang_push_double ((*rand_fun)());
return;
}
if (NULL == (at = SLang_create_array (SLANG_DOUBLE_TYPE, 0, NULL, &num, 1)))
{
isis_vmesg (INTR, I_FAILED, __FILE__, __LINE__, "creating array of random values");
return;
}
ad = (double *) at->data;
for (i = 0; i < num; i++)
ad[i] = (*rand_fun) ();
SLang_push_array (at, 1);
}
static int do_binary_function_c (int (*f)(double, double,VOID_STAR), VOID_STAR cd)
{
Array_Or_Scalar_Type a_ast, b_ast, c_ast;
if (-1 == pop_2_arrays_or_scalar (&a_ast, &b_ast))
return -1;
c_ast.at = NULL;
c_ast.num = 1;
c_ast.inc = 0;
c_ast.cptr = &c_ast.c;
if ((a_ast.at != NULL) || (b_ast.at != NULL))
{
if (a_ast.at != NULL)
c_ast.at = SLang_create_array1 (SLANG_CHAR_TYPE, 0, NULL, a_ast.at->dims, a_ast.at->num_dims, 1);
else
c_ast.at = SLang_create_array1 (SLANG_CHAR_TYPE, 0, NULL, b_ast.at->dims, b_ast.at->num_dims, 1);
if (c_ast.at == NULL)
{
free_array_or_scalar (&a_ast);
free_array_or_scalar (&b_ast);
return -1;
}
c_ast.cptr = (char *) c_ast.at->data;
c_ast.num = c_ast.at->num_elements;
c_ast.inc = 1;
}
if (a_ast.is_float)
{
if (b_ast.is_float)
(void) do_c_ff_fun (f, cd, &a_ast, &b_ast, &c_ast);
else
(void) do_c_fd_fun (f, cd, &a_ast, &b_ast, &c_ast);
}
else if (b_ast.is_float)
(void) do_c_df_fun (f, cd, &a_ast, &b_ast, &c_ast);
else
(void) do_c_dd_fun (f, cd, &a_ast, &b_ast, &c_ast);
free_array_or_scalar (&a_ast);
free_array_or_scalar (&b_ast);
if (c_ast.at != NULL)
return SLang_push_array (c_ast.at, 1);
return SLang_push_char (c_ast.c);
}
static void prand_vec (void) /*{{{*/
{
SLang_Array_Type *rate = NULL;
double *r;
SLindex_Type i, n;
if (-1 == SLang_pop_array_of_type (&rate, SLANG_DOUBLE_TYPE)
|| rate == NULL)
{
SLang_free_array (rate); rate = NULL;
SLang_push_array (rate, 1);
return;
}
n = rate->num_elements;
r = (double *)rate->data;
for (i = 0; i < n; i++)
{
r[i] = prand (r[i]);
}
SLang_push_array (rate, 1);
}
static void termios_get_cc (struct termios *s)
{
SLang_Array_Type *at;
SLindex_Type dims = NCCS;
int i;
unsigned char *at_data;
at = SLang_create_array (SLANG_UCHAR_TYPE, 0, NULL, &dims, 1);
if (at == NULL)
return;
at_data = (unsigned char *) at->data;
for (i = 0; i < NCCS; i++)
at_data[i] = (unsigned char) s->c_cc[i];
(void) SLang_push_array (at, 1);
}
static void nint_intrin (void)
{
double x;
SLang_Array_Type *at, *bt;
int (*at_to_int_fun)(SLang_Array_Type *, SLang_Array_Type *);
if (SLang_peek_at_stack () != SLANG_ARRAY_TYPE)
{
if (-1 == SLang_pop_double (&x))
return;
(void) SLang_push_int (do_nint (x));
return;
}
switch (SLang_peek_at_stack1 ())
{
case -1:
return;
case SLANG_INT_TYPE:
return;
case SLANG_FLOAT_TYPE:
if (-1 == SLang_pop_array_of_type (&at, SLANG_FLOAT_TYPE))
return;
at_to_int_fun = float_to_nint;
break;
case SLANG_DOUBLE_TYPE:
default:
if (-1 == SLang_pop_array_of_type (&at, SLANG_DOUBLE_TYPE))
return;
at_to_int_fun = double_to_nint;
break;
}
if (NULL == (bt = SLang_create_array1 (SLANG_INT_TYPE, 0, NULL, at->dims, at->num_dims, 1)))
{
SLang_free_array (at);
return;
}
if (0 == (*at_to_int_fun) (at, bt))
(void) SLang_push_array (bt, 0);
SLang_free_array (bt);
SLang_free_array (at);
}
int _pSLstring_list_push (_pSLString_List_Type *p, int delete_list)
{
SLang_Array_Type *at;
if ((p == NULL)
|| (p->buf == NULL))
{
int ret = SLang_push_null ();
if (delete_list)
_pSLstring_list_delete (p);
return ret;
}
if (NULL == (at = string_list_to_array (p, delete_list)))
return -1;
return SLang_push_array (at, 1);
}
static void assoc_get_values (SLang_Assoc_Array_Type *a)
{
SLang_Array_Type *at;
SLindex_Type num;
char *dest_data;
SLtype type;
SLang_Class_Type *cl;
unsigned int sizeof_type;
_pSLAssoc_Array_Element_Type *e, *emax;
/* Note: If support for threads is added, then we need to modify this
* algorithm to prevent another thread from modifying the array.
* However, that should be handled in inner_interp.
*/
num = a->num_occupied - a->num_deleted;
type = a->type;
cl = _pSLclass_get_class (type);
sizeof_type = cl->cl_sizeof_type;
if (NULL == (at = SLang_create_array (type, 0, NULL, &num, 1)))
return;
dest_data = (char *)at->data;
e = a->elements;
emax = e + a->table_len;
while (e < emax)
{
if ((e->key != NULL) && (e->key != Deleted_Key))
{
if (-1 == transfer_element (cl, (VOID_STAR) dest_data, &e->value))
{
SLang_free_array (at);
return;
}
dest_data += sizeof_type;
}
e++;
}
(void) SLang_push_array (at, 1);
}
static void intrin_apropos (void)
{
int num_args;
char *pat;
char *namespace_name;
unsigned int flags;
SLang_Array_Type *at;
num_args = SLang_Num_Function_Args;
if (-1 == SLang_pop_uinteger (&flags))
return;
if (-1 == SLang_pop_slstring (&pat))
return;
namespace_name = NULL;
at = NULL;
if (num_args == 3)
{
if (-1 == SLang_pop_slstring (&namespace_name))
goto free_and_return;
}
at = _pSLang_apropos (namespace_name, pat, flags);
if (num_args == 3)
{
(void) SLang_push_array (at, 0);
goto free_and_return;
}
/* Maintain compatibility with old version of the function. That version
* did not take three arguments and returned everything to the stack.
* Yuk.
*/
(void) push_string_array_elements (at);
free_and_return:
/* NULLs ok */
SLang_free_slstring (namespace_name);
SLang_free_slstring (pat);
SLang_free_array (at);
}
static void nth_match (Onig_Type *o, int *np)
{
unsigned int start, stop;
SLang_Array_Type *at;
SLindex_Type two = 2;
int *data;
if (-1 == get_nth_start_stop (o, (unsigned int) *np, &start, &stop))
{
SLang_push_null ();
return;
}
if (NULL == (at = SLang_create_array (SLANG_INT_TYPE, 0, NULL, &two, 1)))
return;
data = (int *)at->data;
data[0] = (int)start;
data[1] = (int)stop;
(void) SLang_push_array (at, 1);
}
static int push_c_string_array (char **argv, int argc)
{
SLang_Array_Type *at;
char **strs;
int i;
if (NULL == (at = SLang_create_array (SLANG_STRING_TYPE, 1, NULL, &argc, 1)))
return -1;
strs = (char **) at->data;
for (i = 0; i < argc; i++)
{
if (NULL == (strs[i] = SLang_create_slstring (argv[i])))
{
SLang_free_array (at);
return -1;
}
}
return SLang_push_array (at, 1);
}
static int apply_line_modifier (Model_t *m, Model_Info_Type *info, DB_line_t *line, double *emis) /*{{{*/
{
Plasma_State_Type lm_state;
lm_state.temperature = m->temperature;
lm_state.ndensity = m->density;
SLang_start_arg_list ();
SLang_push_array (info->line_emis_modifier_params, 0);
SLang_push_int (line->indx);
if (-1 == SLang_push_cstruct ((VOID_STAR)&lm_state, Plasma_State_Layout))
return -1;
SLang_push_double (*emis);
if (info->line_emis_modifier_args != NULL)
isis_push_args (info->line_emis_modifier_args);
if (info->line_emis_modifier_qualifiers == NULL)
{
SLang_end_arg_list ();
if (-1 == SLexecute_function (info->line_emis_modifier))
return -1;
}
else
{
if ((-1 == SLang_push_function (info->line_emis_modifier))
|| (-1 == SLang_push_struct (info->line_emis_modifier_qualifiers)))
return -1;
SLang_end_arg_list ();
if (-1 == SLang_execute_function ("_isis->do_eval_with_qualifiers"))
return -1;
}
if (-1 == SLang_pop_double (emis))
return -1;
return 0;
}
static void sl_ssl_get_cert(void){
SLssl_Type *ssl;
SLang_MMT_Type *sslmmt;
STACK_OF(X509) *cert;
unsigned char **buf;
SLang_BString_Type **certout;
SLang_Array_Type *arr;
SLindex_Type nelem;
int len,i;
if (NULL==(sslmmt=SLang_pop_mmt(SLssl_Type_Id)))
return;
ssl=(SLssl_Type *)SLang_object_from_mmt(sslmmt);
cert=SSL_get_peer_cert_chain((SSL *)ssl->ssl);
if (cert==NULL)
return NULL;
nelem=(SLindex_Type)sk_X509_num(cert);
// now we have chain of certs, create array of pointers and the
// array to hold them
buf = (unsigned char **)malloc(nelem*sizeof(unsigned char *));
arr = SLang_create_array(SLANG_BSTRING_TYPE,0,NULL,&nelem,1);
// array data structure is of bstring type
certout = (SLang_BString_Type **)arr->data;
for (i=0;i<nelem;i++){
buf[i] = NULL;
len = i2d_X509(sk_X509_value(cert,i), &(buf[i]));
certout[i] = SLbstring_create(buf[i],len);
}
SLang_push_array(arr,1);
// free the X509 stack
sk_X509_pop_free(cert,X509_free);
}
int Plot_symbol_points (SLindex_Type n, float *x, float *y, int *symbol) /*{{{*/
{
SLang_Array_Type *sl_sym=NULL;
int status = -1;
if (pli_undefined())
return -1;
if (PLI->plot_symbol_points == NULL)
{
isis_vmesg (FAIL, I_FAILED, __FILE__, __LINE__,
"plot: plot_symbol_points operation is not supported");
return -1;
}
if (NULL == (sl_sym = SLang_create_array (SLANG_INT_TYPE, 0, NULL, &n, 1)))
return -1;
memcpy ((char *)sl_sym->data, (char *)symbol, n * sizeof(int));
SLang_start_arg_list ();
status = push_two_float_arrays (n, x, y);
SLang_push_array (sl_sym, 1);
SLang_end_arg_list ();
if ((status < 0) || (-1 == SLexecute_function (PLI->plot_symbol_points)))
{
isis_vmesg (FAIL, I_FAILED, __FILE__, __LINE__, "failed plotting points");
return -1;
}
if (-1 == SLang_pop_integer (&status))
{
isis_vmesg (FAIL, I_ERROR, __FILE__, __LINE__, "failed plotting points");
return -1;
}
return status;
}
static void rline_get_history_intrinsic (void)
{
SLindex_Type i, num;
RL_History_Type *h;
char **data;
SLang_Array_Type *at;
if (Active_Rline_Info == NULL)
{
SLang_push_null ();
return;
}
num = 0;
h = Active_Rline_Info->root;
while (h != NULL)
{
h = h->next;
num++;
}
if (NULL == (at = SLang_create_array (SLANG_STRING_TYPE, 0, NULL, &num, 1)))
return;
data = (char **)at->data;
h = Active_Rline_Info->root;
for (i = 0; i < num; i++)
{
if (NULL == (data[i] = SLang_create_slstring (h->buf)))
{
SLang_free_array (at);
return;
}
h = h->next;
}
(void) SLang_push_array (at, 1);
}
static void svd_solve_intrin (void)
{
Linear_System_Type t;
SLang_Array_Type *sl_b = NULL;
if (-1 == pop_linear_system (&t))
{
isis_throw_exception (Isis_Error);
goto the_return;
}
if (-1 == isis_svd_solve (t.a, t.n, t.b))
goto the_return;
sl_b = SLang_create_array (SLANG_DOUBLE_TYPE, 0, NULL, &t.n, 1);
if (sl_b != NULL)
{
memcpy ((char *)sl_b->data, (char *)t.b, t.n * sizeof (double));
}
the_return:
SLang_push_array (sl_b, 1);
free_linear_system (&t);
}
static void intrin_get_namespaces (void)
{
SLang_push_array (_pSLns_list_namespaces (), 1);
}
static void make_2d_histogram (int *reverse) /*{{{*/
{
SLang_Array_Type *grid_x, *grid_y, *sl_x, *sl_y, *b;
SLang_Array_Type *rev;
double *x, *y, *bx, *by;
double xmax, ymax;
SLindex_Type *num;
SLindex_Type dims[2];
SLindex_Type i, n, nx, ny, nbins;
SLindex_Type *r = NULL;
grid_x = grid_y = sl_x = sl_y = b = rev = NULL;
if (-1 == pop_two_darrays (&grid_x, &grid_y))
goto push_result;
/* need at least 1 point */
if ((-1 == pop_two_darrays (&sl_x, &sl_y))
|| (sl_x->num_elements != sl_y->num_elements)
|| (sl_x->num_elements < 1))
goto push_result;
n = sl_x->num_elements;
nx = grid_x->num_elements;
ny = grid_y->num_elements;
if (*reverse == 0)
r = NULL;
else
{
if (NULL == (r = (SLindex_Type *) ISIS_MALLOC (n * sizeof (SLindex_Type))))
{
isis_throw_exception (Isis_Error);
goto push_result;
}
for (i = 0; i < n; i++)
{
r[i] = -1;
}
}
dims[0] = nx;
dims[1] = ny;
nbins = dims[0] * dims[1];
if (NULL == (b = SLang_create_array (SLANG_INT_TYPE, 0, NULL, dims, 2)))
{
isis_throw_exception (Isis_Error);
goto push_result;
}
num = (SLindex_Type *)b->data;
memset ((char *)num, 0, nbins * sizeof(SLindex_Type));
bx = (double *)sl_x->data;
by = (double *)sl_y->data;
x = (double *)grid_x->data;
y = (double *)grid_y->data;
xmax = x[nx-1];
ymax = y[ny-1];
for (i = 0; i < n; i++)
{
double b_x = bx[i];
double b_y = by[i];
SLindex_Type ix, iy, k;
if (b_x >= xmax)
ix = nx-1;
else if ((ix = find_bin (b_x, x, x+1, nx-1)) < 0)
continue;
if (b_y >= ymax)
iy = ny-1;
else if ((iy = find_bin (b_y, y, y+1, ny-1)) < 0)
continue;
k = iy + ny * ix;
num[k] += 1;
if (r != NULL) r[i] = k;
}
if ((r != NULL)
&& (NULL == (rev = convert_reverse_indices (r, n, nx*ny))))
goto push_result;
push_result:
SLang_free_array (sl_x);
SLang_free_array (sl_y);
SLang_free_array (grid_x);
SLang_free_array (grid_y);
ISIS_FREE(r);
SLang_push_array (b, 1);
SLang_push_array (rev, 1);
}