static int
exec_seq(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
double start=1, end=-1, inc=1, tmp;
struct seq_data* d;
strm_get_args(strm, argc, args, "|fff", &start, &end, &tmp);
switch (argc) {
case 1:
end = start;
start = 1;
break;
case 3:
inc = end;
end = tmp;
break;
default:
break;
}
d = malloc(sizeof(*d));
d->n = start;
d->inc = inc;
d->end = end;
*ret = strm_stream_value(strm_stream_new(strm_producer, gen_seq, NULL, (void*)d));
return STRM_OK;
}
static int
ary_correl(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
strm_value* v;
int i, len;
double sx, sy, sxx, syy, sxy;
strm_get_args(strm, argc, args, "a", &v, &len);
sx = sy = sxx = syy = sxy = 0;
for (i=0; i<len; i++) {
strm_value data = v[i];
strm_value* dv;
double dx, dy;
if (!strm_array_p(data) || strm_ary_len(data) != 2) {
/* skip invalid data */
continue;
}
dv = strm_ary_ptr(data);
dx = strm_value_flt(dv[0]) - sx; sx += dx / (i+1);
dy = strm_value_flt(dv[1]) - sy; sy += dy / (i+1);
sxx += i * dx * dx / (i+1);
syy += i * dy * dy / (i+1);
sxy += i * dx * dy / (i+1);
}
sxx = sqrt(sxx / (len-1));
syy = sqrt(syy / (len-1));
sxy /= (len-1) * sxx * syy;
*ret = strm_flt_value(sxy);
return STRM_OK;
}
static int
str_chars(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
const char* str;
const char* s;
const char* prev = NULL;
strm_int slen;
strm_array ary;
strm_int n = 0;
strm_value* sps;
strm_int i = 0;
strm_get_args(strm, argc, args, "s", &str, &slen);
s = str;
while (*s) {
s += utf8len(s, s + slen);
n++;
}
ary = strm_ary_new(NULL, n);
sps = strm_ary_ptr(ary);
s = str;
while (*s) {
prev = s;
s += utf8len(s, s + slen);
sps[i++] = strm_str_new(prev, s - prev);
}
*ret = strm_ary_value(ary);
return STRM_OK;
}
static int
exec_filter(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
struct map_data* d = malloc(sizeof(*d));
strm_get_args(strm, argc, args, "v", &d->func);
*ret = strm_stream_value(strm_stream_new(strm_filter, iter_filter, NULL, (void*)d));
return STRM_OK;
}
static int
str_length(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
char* p;
strm_int len;
strm_get_args(strm, argc, args, "s", &p, &len);
*ret = strm_int_value(len);
return STRM_OK;
}
static int
exec_count(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
struct count_data* d;
strm_get_args(strm, argc, args, "");
d = malloc(sizeof(*d));
d->count = 0;
*ret = strm_stream_value(strm_stream_new(strm_filter, iter_count, count_finish, (void*)d));
return STRM_OK;
}
static int
exec_flatmap(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
struct map_data* d;
strm_value func;
strm_get_args(strm, argc, args, "v", &func);
d = malloc(sizeof(*d));
if (!d) return STRM_NG;
d->func = func;
*ret = strm_stream_value(strm_stream_new(strm_filter, iter_flatmap, NULL, (void*)d));
return STRM_OK;
}
static int
exec_correl(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
struct correl_data* d;
strm_get_args(strm, argc, args, "");
d = malloc(sizeof(struct correl_data));
if (!d) return STRM_NG;
d->n = 0;
d->sx = d->sy = d->sxx = d->syy = d->sxy = 0;
*ret = strm_stream_value(strm_stream_new(strm_filter, iter_correl,
correl_finish, (void*)d));
return STRM_OK;
}
static int
exec_sample(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
struct sample_data* d;
strm_int len;
strm_get_args(strm, argc, args, "i", &len);
d = malloc(sizeof(struct sample_data)+sizeof(strm_value)*len);
if (!d) return STRM_NG;
d->len = len;
d->i = 0;
*ret = strm_stream_value(strm_stream_new(strm_filter, iter_sample,
finish_sample, (void*)d));
return STRM_OK;
}
static int
exec_rbk(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
struct rbk_data *d;
khash_t(rbk) *t;
strm_value func;
strm_get_args(strm, argc, args, "v", &func);
t = kh_init(rbk);
if (!t) return STRM_NG;
d = malloc(sizeof(*d));
d->tbl = t;
d->func = func;
*ret = strm_stream_value(strm_stream_new(strm_filter, iter_rbk, rbk_finish, (void*)d));
return STRM_OK;
}
static int
str_plus(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
strm_string str1, str2, str3;
char *p;
strm_get_args(strm, argc, args, "SS", &str1, &str2);
str3 = strm_str_new(NULL, strm_str_len(str1) + strm_str_len(str2));
p = (char*)strm_str_ptr(str3);
memcpy(p, strm_str_ptr(str1), strm_str_len(str1));
memcpy(p+strm_str_len(str1), strm_str_ptr(str2), strm_str_len(str2));
p[strm_str_len(str3)] = '\0';
*ret = strm_str_value(str3);
return STRM_OK;
}
static int
exec_minmax(strm_stream* strm, int argc, strm_value* args, strm_value* ret, int min)
{
struct minmax_data* d;
strm_value func = strm_nil_value();
strm_get_args(strm, argc, args, "|v", &func);
d = malloc(sizeof(*d));
if (!d) return STRM_NG;
d->start = TRUE;
d->min = min;
d->num = 0;
d->data = strm_nil_value();
d->func = func;
*ret = strm_stream_value(strm_stream_new(strm_filter, iter_minmax, minmax_finish, (void*)d));
return STRM_OK;
}
static int
ary_flatmap(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
strm_array ary;
strm_value func;
strm_array a2;
strm_value* v2;
strm_get_args(strm, argc, args, "Av", &ary, &func);
a2 = strm_ary_new(NULL, flatmap_len(ary));
v2 = strm_ary_ptr(a2);
if (flatmap_push(strm, ary, func, &v2) == STRM_NG) {
return STRM_NG;
}
*ret = strm_ary_value(a2);
return STRM_OK;
}
static int
exec_uniq(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
struct uniq_data* d;
strm_value func = strm_nil_value();
strm_get_args(strm, argc, args, "|v", &func);
d = malloc(sizeof(*d));
if (!d) return STRM_NG;
d->last = strm_nil_value();
d->func = func;
d->init = FALSE;
*ret = strm_stream_value(strm_stream_new(strm_filter,
strm_nil_p(func) ? iter_uniq : iter_uniqf,
NULL, (void*)d));
return STRM_OK;
}
static int
exec_drop(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
struct take_data* d;
strm_int n;
strm_get_args(strm, argc, args, "i", &n);
if (n < 0) {
strm_raise(strm, "negative iteration");
return STRM_NG;
}
d = malloc(sizeof(*d));
if (!d) return STRM_NG;
d->n = n;
*ret = strm_stream_value(strm_stream_new(strm_filter, iter_drop, NULL, (void*)d));
return STRM_OK;
}
static int
exec_cycle(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
strm_array a;
strm_int n = -1;
struct cycle_data *d;
strm_get_args(strm, argc, args, "A|i", &a, &n);
if (argc == 2 && n <= 0) {
strm_raise(strm, "invalid count number");
return STRM_NG;
}
d = malloc(sizeof(*d));
d->ary = a;
d->count = n;
*ret = strm_stream_value(strm_stream_new(strm_producer, gen_cycle, fin_cycle, (void*)d));
return STRM_OK;
}
static int
exec_repeat(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
strm_value v;
strm_int n = -1;
struct repeat_data *d;
strm_get_args(strm, argc, args, "v|i", &v, &n);
if (argc == 2 && n <= 0) {
strm_raise(strm, "invalid count number");
return STRM_NG;
}
d = malloc(sizeof(*d));
d->v = v;
d->count = n;
*ret = strm_stream_value(strm_stream_new(strm_producer, gen_repeat, fin_repeat, (void*)d));
return STRM_OK;
}
static int
exec_consec(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
struct slice_data* d;
strm_int n;
strm_get_args(strm, argc, args, "i", &n);
d = malloc(sizeof(*d));
if (!d) return STRM_NG;
d->n = n;
d->i = 0;
d->buf = malloc(n*sizeof(strm_value));
if (!d->buf) {
free(d);
return STRM_NG;
}
*ret = strm_stream_value(strm_stream_new(strm_filter, iter_consec, finish_consec, (void*)d));
return STRM_OK;
}
static int
ary_each(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
strm_value* v;
strm_int len;
strm_value func;
strm_int i;
strm_value r;
strm_get_args(strm, argc, args, "av", &v, &len, &func);
for (i=0; i<len; i++) {
if (strm_funcall(strm, func, 1, &v[i], &r) == STRM_NG) {
return STRM_NG;
}
}
*ret = strm_ary_value(args[0]);
return STRM_OK;
}
static int
ary_map(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
strm_value* v;
strm_int len;
strm_value func;
strm_int i;
strm_array a2;
strm_value* v2;
strm_get_args(strm, argc, args, "av", &v, &len, &func);
a2 = strm_ary_new(NULL, len);
v2 = strm_ary_ptr(a2);
for (i=0; i<len; i++) {
if (strm_funcall(strm, func, 1, &v[i], &v2[i]) == STRM_NG) {
return STRM_NG;
}
}
*ret = strm_ary_value(a2);
return STRM_OK;
}
static int
exec_reduce(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
struct reduce_data* d;
strm_value v1, v2;
strm_get_args(strm, argc, args, "v|v", &v1, &v2);
d = malloc(sizeof(*d));
if (!d) return STRM_NG;
if (argc == 2) {
d->init = TRUE;
d->acc = v1;
d->func = v2;
}
else {
d->init = FALSE;
d->acc = strm_nil_value();
d->func = v1;
}
*ret = strm_stream_value(strm_stream_new(strm_filter, iter_reduce, reduce_finish, (void*)d));
return STRM_OK;
}
static int
exec_var_stdev(strm_stream* strm, int argc, strm_value* args, strm_value* ret, int stdev)
{
struct stdev_data* d;
strm_value func;
strm_get_args(strm, argc, args, "|v", &func);
d = malloc(sizeof(struct stdev_data));
if (!d) return STRM_NG;
d->num = 0;
d->s1 = d->s2 = 0.0;
if (argc == 0) {
*ret = strm_stream_value(strm_stream_new(strm_filter, iter_stdev,
stdev ? stdev_finish : var_finish, (void*)d));
}
else {
d->func = func;
*ret = strm_stream_value(strm_stream_new(strm_filter, iter_stdevf,
stdev ? stdev_finish : var_finish, (void*)d));
}
return STRM_OK;
}
static int
ary_sum_avg(strm_stream* strm, int argc, strm_value* args, strm_value* ret, int avg)
{
int i, len;
strm_value* v;
double sum = 0;
double c = 0;
strm_value func;
strm_get_args(strm, argc, args, "a|v", &v, &len, &func);
if (argc == 0) {
for (i=0; i<len; i++) {
double y = strm_value_flt(v[i]) - c;
double t = sum + y;
c = (t - sum) - y;
sum = t;
}
}
else {
for (i=0; i<len; i++) {
strm_value val;
double f, y, t;
val = convert_number(strm, v[i], func);
f = strm_value_flt(val);
y = f - c;
t = sum + y;
c = (t - sum) - y;
sum = t;
}
}
if (avg) {
*ret = strm_flt_value(sum/len);
}
else {
*ret = strm_flt_value(sum);
}
return STRM_OK;
}
static int
ary_var_stdev(strm_stream* strm, int argc, strm_value* args, strm_value* ret, int stdev)
{
strm_value func;
strm_value* v;
int i, len;
double s1, s2;
strm_get_args(strm, argc, args, "a|v", &v, &len, &func);
s1 = s2 = 0.0;
if (argc == 0) {
for (i=0; i<len; i++) {
double x = strm_value_flt(v[i]);
x -= s1;
s1 += x/(i+1);
s2 += i * x * x / (i+1);
}
}
else {
for (i=0; i<len; i++) {
strm_value val;
double x;
val = convert_number(strm, v[i], func);
x = strm_value_flt(val);
x -= s1;
s1 += x/(i+1);
s2 += i * x * x / (i+1);
}
}
s2 = s2 / (i-1);
if (stdev) {
s2 = sqrt(s2);
}
*ret = strm_flt_value(s2);
return STRM_OK;
}
static int
exec_bgraph(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
struct bar_data* d;
char* title = NULL;
strm_int tlen = 0;
strm_get_args(strm, argc, args, "|s", &title, &tlen);
d = malloc(sizeof(struct bar_data));
if (!d) return STRM_NG;
d->title = malloc(tlen);
memcpy((void*)d->title, title, tlen);
d->tlen = tlen;
if (refcnt == 0) {
strm_atomic_inc(refcnt);
strm_signal(SIGWINCH, sigupdate, &winch);
strm_signal(SIGINT, sigupdate, &interrupt);
}
if (init_bar(d) == STRM_NG) return STRM_NG;
*ret = strm_stream_value(strm_stream_new(strm_consumer, iter_bar,
fin_bar, (void*)d));
return STRM_OK;
}
static int
exec_sum_avg(strm_stream* strm, int argc, strm_value* args, strm_value* ret, int avg)
{
struct sum_data* d;
strm_value func;
strm_get_args(strm, argc, args, "|v", &func);
d = malloc(sizeof(struct sum_data));
if (!d) return STRM_NG;
d->sum = 0;
d->c = 0;
d->num = 0;
if (argc == 0) {
d->func = strm_nil_value();
*ret = strm_stream_value(strm_stream_new(strm_filter, iter_sum,
avg ? avg_finish : sum_finish, (void*)d));
}
else {
d->func = func;
*ret = strm_stream_value(strm_stream_new(strm_filter, iter_sumf,
avg ? avg_finish : sum_finish, (void*)d));
}
return STRM_OK;
}
static int
str_split(strm_stream* strm, int argc, strm_value* args, strm_value* ret)
{
const char* s;
strm_int slen;
const char* b;
const char* t;
const char* p;
strm_int plen;
const char* pend;
char c;
strm_int n = 0;
strm_array ary;
strm_value* sps;
strm_int i;
strm_get_args(strm, argc, args, "s|s", &p, &plen, &s, &slen);
if (argc == 1) {
s = " ";
slen = 1;
}
/* count number of split strings */
c = s[0];
b = t = p;
pend = p + plen - slen;
n = 0;
while (p<pend) {
if (*p == c) {
if (memcmp(p, s, slen) == 0) {
if (!(slen == 1 && c == ' ' && (p-t) == 0)) {
n++;
}
t = p + slen;
}
}
p++;
}
n++;
/* actual split */
ary = strm_ary_new(NULL, n);
sps = strm_ary_ptr(ary);
c = s[0];
p = t = b;
i = 0;
while (p<pend) {
if (*p == c) {
if (memcmp(p, s, slen) == 0) {
if (!(slen == 1 && c == ' ' && (p-t) == 0)) {
sps[i++] = strm_str_new(t, p-t);
}
t = p + slen;
}
}
p++;
}
pend = b + plen;
sps[i++] = strm_str_new(t, pend-t);
*ret = strm_ary_value(ary);
return STRM_OK;
}
