예제 #1
0
double MATHNS::angle(std::vector<double> u, std::vector<double> v)
{
    double um = vector_mag(u);
    double vm = vector_mag(v);
    double dot = vector_dot(u,v);
    return acos(dot/(um*vm));
}
예제 #2
0
파일: tests.c 프로젝트: kmaterna/matrix
void test_vector_magnitudes() {
    printf("Testing vector magnitudes...\n");
    TestStats stats = test_stats();
    Vector test_vector;
    double computed;

    test_vector = zeroes(0);
    computed = vector_mag(&test_vector);
    assert_double(&stats, 0, computed,
            "Zero element vectors should have zero magnitude");

    int i;
    for (i = -1; i < 3; i++) {
        test_vector = linear(1, i, 0);
        computed = vector_mag(&test_vector);
        assert_double(&stats, abs(i), computed, 
                "One element vectors must have magnitude equal to their element.");
    }

    double quad_a[4] = {-.4, 0, .6, 1.2};
    Vector quad = { 4, &quad_a[0] };
    computed = vector_mag(&quad);
    assert_double(&stats, 1.4, computed,
            "Incorrectly computed vector magnitude");

    print_state(&stats);
}
예제 #3
0
static void compute_normal(point_t* points, int num_points, vector_t* n)
{
  vector_t A, B;
  point_displacement(&points[0], &points[1], &A);
  point_displacement(&points[0], &points[2], &B);
  vector_cross(&A, &B, n);
  ASSERT(vector_mag(n) > 0.0);
  vector_normalize(n);
}
예제 #4
0
파일: physics.c 프로젝트: Brunoarico/POGWar
Vector gravitational_acel (Body a, Body b) {
    Vector res;
    double force, tmp;
    force = G * b->bbody.mass;
    res = vector_zeros (a->bbody.position->size);
    vector_copy (res, a->bbody.position);
    vector_sub (res, b->bbody.position);

    tmp = vector_mag (res);

    if (tmp == 0) {
        fprintf (stderr, "gravitational_force: ");
        fprintf (stderr, "Division by zero.\n");
        /* exit(EXIT_FAILURE); */
        tmp = 0.00001;
    }
    
    force /= tmp*tmp*tmp;
    vector_scale (res, force);
    return res;
}
예제 #5
0
static vector_t hat_grad(void* context, vector_t* y)
{
  real_t h = *((real_t*)context); // Spatial extent of W.
  real_t D = vector_mag(y);
  static vector_t zero = {.x = 0.0, .y = 0.0, .z = 0.0};
  vector_t g = {.x = -y->x/(D*h), .y = -y->y/(D*h), .z = -y->z/(D*h)};
  return (D < h) ? g : zero;
}

static void hat_dtor(void* context)
{
  polymec_free(context);
}

static point_weight_function_t* hat_function_new(real_t h)
{
  real_t* Wh = polymec_malloc(sizeof(real_t));
  *Wh = h;
  point_weight_function_vtable vtable = {.value = hat_W, 
                                         .gradient = hat_grad, 
                                         .dtor = hat_dtor};
  return point_weight_function_new("Hat function", Wh, vtable);
}
예제 #6
0
static real_t hat_W(void* context, vector_t* y)
{
  real_t h = *((real_t*)context); // Spatial extent of W.
  real_t D = vector_mag(y);
  return (D < h) ? 1.0 - D/h : 0.0;
}
Vector vector_unit(Vector v) {
	return vector_scale(v, 1. / vector_mag(v));
}