void bezier_split(Bezier* b, float t, Bezier** left, Bezier** right) { float u = (t - b->dom->a) / (b->dom->b - b->dom->a); assert(0.0f <= u && u <= 1.0f); // same as: assert(interval_inside(b->dom, t)); *left = bezier_create(b->n); *right = bezier_create(b->n); float (*d)[b->n + 1] = calloc((b->n + 1) * (b->n + 1), sizeof(float)); for(int i = 0; i <= b->n; ++i) d[0][i] = b->c[i]; for(int j = 1; j <= b->n; ++j) for(int i = 0; i <= b->n - j; ++i) d[j][i] = (1.0f - u) * d[j-1][i] + u * d[j-1][i+1]; for(int i = 0; i <= b->n; ++i) { (*left)->c[i] = d[i][0]; (*right)->c[i] = d[b->n - i][i]; } (*left)->dom = interval_create(b->dom->a, t); (*right)->dom = interval_create(t, b->dom->b); free(d); }
int interval_difference(Interval* i, Interval* j, Interval*** intervals) { if(!interval_overlapps(i, j)) { *intervals = malloc(sizeof(Interval*)); (*intervals)[0] = interval_copy(i); return 1; } else if(!interval_subinterval(i, j)) { if(i->a < j->a) { *intervals = malloc(sizeof(Interval*)); (*intervals)[0] = interval_create(j->b, i->b); return 1; } else { *intervals = malloc(sizeof(Interval*)); (*intervals)[0] = interval_create(i->a, j->a); return 1; } } else { *intervals = malloc(2 * sizeof(Interval*)); (*intervals)[0] = interval_create(i->a, j->a); (*intervals)[1] = interval_create(j->b, i->b); return 2; } }
/** * The function expects @fd_listen is in a "ready" state in the @epfd * epoll set, and directly calls accept() on @fd_listen. The readiness * should guarantee that the accept() doesn't block. * * After a client socket fd is obtained, a new flow is created as part * of the thread @t. The state of the flow is set to "waiting for a * request". */ static void server_accept(int fd_listen, int epfd, struct thread *t) { struct options *opts = t->opts; struct callbacks *cb = t->cb; struct sockaddr_storage cli_addr; struct flow *flow; socklen_t cli_len; int client; cli_len = sizeof(cli_addr); client = accept(fd_listen, (struct sockaddr *)&cli_addr, &cli_len); if (client == -1) { if (errno == EINTR || errno == ECONNABORTED) return; PLOG_ERROR(cb, "accept"); return; } flow = addflow(t->index, epfd, client, t->next_flow_id++, EPOLLIN, opts, cb); flow->bytes_to_read = opts->request_size; flow->itv = interval_create(opts->interval, t); }
static void client_connect(int i, int epfd, struct thread *t) { struct options *opts = t->opts; struct callbacks *cb = t->cb; struct addrinfo *ai = t->ai; struct flow *flow; int fd; fd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol); if (fd == -1) PLOG_FATAL(cb, "socket"); if (opts->min_rto) set_min_rto(fd, opts->min_rto, cb); if (opts->debug) set_debug(fd, 1, cb); if (opts->local_host) set_local_host(fd, opts, cb); if (do_connect(fd, ai->ai_addr, ai->ai_addrlen)) PLOG_FATAL(cb, "do_connect"); flow = addflow(t->index, epfd, fd, i, EPOLLOUT, opts, cb); flow->bytes_to_write = opts->request_size; flow->itv = interval_create(opts->interval, t); }
int main(int argc, char *argv[]) { int ret; char *x0 = NULL, *x1 = NULL; char *epsilon = EPSILON, *func = NULL; char *max_iter = MAXITER, *method = "secant"; long double r; /* parse command line */ while ((ret = getopt(argc, argv, "vm:e:i:a:b:")) != -1) { switch (ret) { case 'e': epsilon = optarg; /* optarg is just a pointer to argv */ break; case 'i': max_iter = optarg; break; case 'a': x0 = optarg; break; case 'b': x1 = optarg; break; case 'm': method = optarg; break; case 'v': root_search_verbose = 1; break; default: return 1; } } if (optind >= argc || !x0) { fprintf(stderr, "usage: %s [-v] [-e <epsilon>] [-i <max-iter>] [-m <method>]" "-a <x0> [-b <x1>] <function eg: cos(x)-x^3>\n", argv[0]); return 1; } else { func = argv[optind]; } function_t *f = function_create(func); interval_t *i = interval_create(atof(x0), x1 ? atof(x1) : (atof(x0) + 1.0)); stop_cond_t *s = stop_cond_create(atof(epsilon), atoi(max_iter)); if (!strcmp(method, "secant")) ret = root_secant(f, i, s, &r); else if (!strcmp(method, "bisection")) ret = root_bisection(f, i, s, &r); else if (!strcmp(method, "regulafalsi")) ret = root_regulafalsi(f, i, s, &r); else if (!strcmp(method, "newton")) ret = root_newton(f, atof(x0), s, &r); else { fprintf(stderr, "Method not recognized: %s\n", method); return 1; } if (ret) { fprintf(stderr, "%s method failed (ret: %d)\n", method, ret); } else { printf("%.15Lg\n", r); } function_destroy(f); interval_destroy(i); stop_cond_destroy(s); return ret; }
Interval* interval_copy(Interval* i) { return interval_create(i->a, i->b); }
Interval* interval_intersection(Interval* i, Interval* j) { return interval_create(max(i->a, j->a), min(i->b, j->b)); }