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