int lineClip (osuVertex &v0, osuVertex &v1,double a, double b,double c,double d0, double d1) { osuVertex newv0, newv1; int in0,in1; /* are v0 or v1 in the proper half-space */ int status = 1; in0 = (a * v0.x + b * v0.y + c * v0.z + d0 > 0); in1 = (a * v1.x + b * v1.y + c * v1.z + d1 > 0); if (in0 && in1) { //do nothing, I'll return v0 and v1 } else if (!in0 && in1) { create_vertex(v0, v1, newv0, a, b, c,d0); vertex_copy(v0, newv0); } else if (in0 && !in1) { create_vertex(v0, v1, newv1, a, b, c,d1); vertex_copy(v1, newv1); } else { /* both are not in, so we add no vertices to the clipped line*/ status = 0; } in0 = in1; return(status); }
int simplex_collapsed(const simplex_t *s) { static vertex_t *a, *b; int i, j; if (!a || !b || a->id != N) { free(a); free(b); a = vertex_alloc(); b = vertex_alloc(); if (!a || !b) return -1; } vertex_copy(a, s->vertex[0]); vertex_regrid(a); a->id = N; for (i = 1; i < s->len; ++i) { vertex_copy(b, s->vertex[i]); vertex_regrid(b); for (j = 0; j < N; ++j) { if (a->term[j] != b->term[j]) return 0; } } return 1; }
int vertex_center(vertex_t *v) { int i; vertex_copy(v, vmin); for (i = 0; i < N; ++i) v->term[i] += (vmax->term[i] - vmin->term[i]) / 2; hperf_reset(v->perf); return 0; }
void simplex_transform(const simplex_t *src, const vertex_t *wrt, double coefficient, simplex_t *result) { int i; for (i = 0; i < src->len; ++i) { if (src->vertex[i] == wrt) { vertex_copy(result->vertex[i], src->vertex[i]); continue; } vertex_transform(src->vertex[i], wrt, coefficient, result->vertex[i]); } }
int pro_next_simplex(simplex_t *output) { int i; switch (state) { case SIMPLEX_STATE_INIT: /* Bootstrap the process by testing the reference simplex. */ simplex_copy(output, base); break; case SIMPLEX_STATE_REFLECT: /* Reflect all original simplex vertices around the best known * vertex thus far. */ simplex_transform(base, base->vertex[best_base], -reflect, output); break; case SIMPLEX_STATE_EXPAND_ONE: /* Next simplex should have one vertex extending the best. * And the rest should be copies of the best known vertex. */ vertex_transform(test->vertex[best_test], base->vertex[best_base], expand, output->vertex[0]); for (i = 1; i < simplex_size; ++i) vertex_copy(output->vertex[i], base->vertex[best_base]); break; case SIMPLEX_STATE_EXPAND_ALL: /* Expand all original simplex vertices away from the best * known vertex thus far. */ simplex_transform(base, base->vertex[best_base], expand, output); break; case SIMPLEX_STATE_SHRINK: /* Shrink all original simplex vertices towards the best * known vertex thus far. */ simplex_transform(base, base->vertex[best_base], shrink, output); break; case SIMPLEX_STATE_CONVERGED: /* Simplex has converged. Nothing to do. * In the future, we may consider new search at this point. */ break; default: return -1; } return 0; }
int simplex_copy(simplex_t *dst, const simplex_t *src) { int i; if (dst == src) return 0; if (dst->len != src->len) return -1; for (i = 0; i < src->len; ++i) vertex_copy(dst->vertex[i], src->vertex[i]); return 0; }
void generate_random_graph1 (MutableGraph& g, typename graph_traits<MutableGraph>::vertices_size_type V, typename graph_traits<MutableGraph>::vertices_size_type E, RandNumGen& gen, bool allow_parallel = true, bool self_edges = false) { typedef graph_traits<MutableGraph> Traits; typedef typename Traits::vertices_size_type v_size_t; typedef typename Traits::edges_size_type e_size_t; typedef typename Traits::vertex_descriptor vertex_descriptor; // When parallel edges are not allowed, we create a new graph which // does not allow parallel edges, construct it and copy back. // This is not efficient if 'g' already disallow parallel edges, // but that's task for later. if (!allow_parallel) { typedef typename boost::graph_traits<MutableGraph>::directed_category dir; typedef typename mpl::if_<is_convertible<dir, directed_tag>, directedS, undirectedS>::type select; adjacency_list<setS, vecS, select> g2; generate_random_graph1(g2, V, E, gen, true, self_edges); copy_graph(g2, g, vertex_copy(detail::dummy_property_copier()). edge_copy(detail::dummy_property_copier())); } else { for (v_size_t i = 0; i < V; ++i) add_vertex(g); for (e_size_t j = 0; j < E; ++j) { vertex_descriptor a = random_vertex(g, gen), b; do { b = random_vertex(g, gen); } while (self_edges == false && a == b); add_edge(a, b, g); } } }