numerix 1.0.0

data/ext/numerix/quaternion.h

@@ -0,0 +1,53 @@
+#ifndef NUMERIX_QUATERNION_H
+#define NUMERIX_QUATERNION_H 1
+
+#include "common.h"
+#include "vector_base.h"
+
+#define QUATERNION() \
+    Quaternion *q;   \
+    Data_Get_Struct(self, Quaternion, q);
+
+void Init_quaternion(VALUE outer);
+VALUE rb_quaternion_alloc(VALUE klass);
+VALUE rb_quaternion_initialize(int argc, VALUE *argv, VALUE self);
+
+// Instance
+VALUE rb_quaternion_identity_p(VALUE self);
+VALUE rb_quaternion_length(VALUE self);
+VALUE rb_quaternion_length_squared(VALUE self);
+VALUE rb_quaternion_negate(VALUE self);
+VALUE rb_quaternion_add(VALUE self, VALUE other);
+VALUE rb_quaternion_subtract(VALUE self, VALUE other);
+VALUE rb_quaternion_multiply(VALUE self, VALUE other);
+VALUE rb_quaternion_divide(VALUE self, VALUE other);
+VALUE rb_quaternion_equal(VALUE self, VALUE other);
+VALUE rb_quaternion_normalize(VALUE self);
+VALUE rb_quaternion_normalize_bang(VALUE self);
+VALUE rb_quaternion_conjugate(VALUE self);
+VALUE rb_quaternion_conjugate_bang(VALUE self);
+VALUE rb_quaternion_inverse(VALUE self);
+VALUE rb_quaternion_dot(VALUE self, VALUE other);
+VALUE rb_quaternion_concatenate(VALUE self, VALUE other);
+VALUE rb_quaternion_concatenate_bang(VALUE self, VALUE other);
+VALUE rb_quaternion_lerp(VALUE self, VALUE other, VALUE amount);
+VALUE rb_quaternion_lerp_bang(VALUE self, VALUE other, VALUE amount);
+VALUE rb_quaternion_slerp(VALUE self, VALUE other, VALUE amount);
+VALUE rb_quaternion_slerp_bang(VALUE self, VALUE other, VALUE amount);
+
+// Conversion
+VALUE rb_quaternion_to_s(VALUE self);
+VALUE rb_quaternion_to_a(VALUE self);
+VALUE rb_quaternion_to_h(VALUE self);
+VALUE rb_quaternion_to_vec4(VALUE self);
+
+// Class
+VALUE rb_quaternion_identity(VALUE klass);
+VALUE rb_quaternion_from_axis_angle(VALUE klass, VALUE vec3, VALUE angle);
+VALUE rb_quaternion_from_yaw_pitch_roll(VALUE klass, VALUE yaw, VALUE pitch, VALUE roll);
+VALUE rb_quaternion_from_rotation_matrix(VALUE klass, VALUE matrix);
+
+static inline VALUE rb_quaternion_slerp_s(VALUE klass, VALUE quaternion1, VALUE quaternion2, VALUE amount);
+static inline VALUE rb_quaternion_lerp_s(VALUE klass, VALUE quaternion1, VALUE quaternion2, VALUE amount);
+
+#endif /* NUMERIX_QUATERNION_H */

data/ext/numerix/structure.c

@@ -0,0 +1,154 @@
+
+#include "structure.h"
+
+VALUE rb_cNumerixStruct;
+
+#if RUBY_API_VERSION_MAJOR >= 2
+VALUE rb_numerix_cFiddlePointer;
+#endif
+
+void Init_numerix_structure(VALUE outer) {
+    rb_cNumerixStruct = rb_define_class_under(outer, "Structure", rb_cObject);
+    rb_define_method(rb_cNumerixStruct, "initialize", rb_numerix_abstract_initialize, 0);
+
+    rb_define_method(rb_cNumerixStruct, "dup", rb_numerix_dup, 0);
+    rb_define_method(rb_cNumerixStruct, "address", rb_numerix_address, 0);
+    rb_define_method(rb_cNumerixStruct, "_dump", rb_numerix_dump, -1);
+    rb_define_method(rb_cNumerixStruct, "[]", rb_numerix_aref, 1);
+    rb_define_method(rb_cNumerixStruct, "[]=", rb_numerix_aset, 2);
+    rb_define_method(rb_cNumerixStruct, "each", rb_numerix_each, 0);
+
+    rb_define_singleton_method(rb_cNumerixStruct, "size", rb_numerix_size, 0);
+    rb_define_singleton_method(rb_cNumerixStruct, "_load", rb_numerix_load, 1);
+    rb_define_singleton_method(rb_cNumerixStruct, "unpack", rb_numerix_load, 1);
+
+    rb_define_alias(rb_cNumerixStruct, "pack", "_dump");
+
+#if RUBY_API_VERSION_MAJOR >= 2
+    rb_require("fiddle");
+    VALUE fiddle = rb_const_get(rb_cObject, rb_intern("Fiddle"));
+    rb_numerix_cFiddlePointer = rb_const_get(fiddle, rb_intern("Pointer"));
+    rb_define_method(rb_cNumerixStruct, "ptr", rb_numerix_fiddle_ptr, 0);
+#endif
+}
+
+#if RUBY_API_VERSION_MAJOR >= 2
+
+VALUE rb_numerix_fiddle_ptr(VALUE self) {
+    // Get basic data about the struct
+    struct RData *rdata = RDATA(self);
+    VALUE *args = xmalloc(sizeof(VALUE) * 2);
+// Set the platform pointer-size address
+#if SIZEOF_INTPTR_T == 4
+    args[0] = LONG2NUM((long)rdata->data);
+#elif SIZEOF_INTPTR_T == 8
+    args[0] = LL2NUM((long long)rdata->data);
+#else
+    args[0] = INT2NUM(0);
+#endif
+    // Get size of structure
+    int size = rb_numerix_isize(rdata->basic.klass);
+    args[1] = INT2NUM(size);
+    VALUE ptr = rb_class_new_instance(2, args, rb_numerix_cFiddlePointer);
+    xfree(args);
+    return ptr;
+}
+
+#endif
+
+VALUE rb_numerix_each(VALUE self) {
+    struct RData *rdata = RDATA(self);
+    int count = rb_numerix_isize(rdata->basic.klass) / sizeof(float);
+
+    volatile VALUE str = self;
+
+    RETURN_SIZED_ENUMERATOR(str, 0, 0, count);
+
+    float *flt = (float *)rdata->data;
+    for (int i = 0; i < count; i++)
+        rb_yield(DBL2NUM(flt[i]));
+
+    return str;
+}
+
+VALUE rb_numerix_aref(VALUE self, VALUE index) {
+    struct RData *rdata = RDATA(self);
+    int max = rb_numerix_isize(rdata->basic.klass) / sizeof(float);
+    int i = NUM2INT(index);
+
+    if (i < 0 || i >= max)
+        return Qnil;
+
+    float *flt = (float *)rdata->data;
+    return DBL2NUM(flt[i]);
+}
+
+VALUE rb_numerix_aset(VALUE self, VALUE index, VALUE value) {
+    struct RData *rdata = RDATA(self);
+    int max = rb_numerix_isize(rdata->basic.klass) / sizeof(float);
+    int i = NUM2INT(index);
+
+    if (i >= 0 || i < max) {
+        float *flt = (float *)rdata->data;
+        flt[i] = NUM2FLT(value);
+    }
+
+    return value;
+}
+
+VALUE rb_numerix_dup(VALUE self) {
+    struct RData *rdata = RDATA(self);
+    int size = rb_numerix_isize(rdata->basic.klass);
+    void *data = ruby_xmalloc(size);
+    memcpy(data, rdata->data, size);
+    return NUMERIX_WRAP(rdata->basic.klass, data);
+}
+
+VALUE rb_numerix_address(VALUE self) {
+    void *address = RDATA(self)->data;
+#if SIZEOF_INTPTR_T == 4
+    return LONG2NUM((long)address);
+#elif SIZEOF_INTPTR_T == 8
+    return LL2NUM((long long)address);
+#else
+    return INT2NUM(0);
+#endif
+}
+
+static inline int rb_numerix_isize(VALUE klass) {
+    if (NUMERIX_INHERIT_P(klass, rb_cVector2))
+        return sizeof(Vector2);
+    if (NUMERIX_INHERIT_P(klass, rb_cVector3))
+        return sizeof(Vector3);
+    if (NUMERIX_INHERIT_P(klass, rb_cVector4))
+        return sizeof(Vector4);
+    if (NUMERIX_INHERIT_P(klass, rb_cMatrix3x2))
+        return sizeof(Matrix3x2);
+    if (NUMERIX_INHERIT_P(klass, rb_cMatrix4x4))
+        return sizeof(Matrix4x4);
+    if (NUMERIX_INHERIT_P(klass, rb_cPlane))
+        return sizeof(Plane);
+    if (NUMERIX_INHERIT_P(klass, rb_cQuaternion))
+        return sizeof(Quaternion);
+    return 0;
+}
+
+VALUE rb_numerix_size(VALUE klass) {
+    int size = rb_numerix_isize(klass);
+    return INT2NUM(size);
+}
+
+VALUE rb_numerix_dump(int arc, VALUE *argv, VALUE self) {
+    int size = rb_numerix_isize(CLASS_OF(self));
+    VALUE str = rb_str_new(NULL, size);
+    void *data = RDATA(self)->data;
+    memcpy(RSTRING_PTR(str), data, size);
+    return str;
+}
+
+VALUE rb_numerix_load(VALUE klass, VALUE str) {
+    int size = rb_numerix_isize(klass);
+    void *data = ruby_xmalloc(size);
+    memcpy(data, RSTRING_PTR(str), size);
+    return NUMERIX_WRAP(klass, data);
+}

data/ext/numerix/structure.h

@@ -0,0 +1,24 @@
+#ifndef NUMERIX_STRUCTURE_H
+#define NUMERIX_STRUCTURE_H 1
+
+#include "common.h"
+#include "ruby/version.h"
+
+void Init_numerix_structure(VALUE outer);
+
+VALUE rb_numerix_address(VALUE self);
+VALUE rb_numerix_dump(int arc, VALUE *argv, VALUE self);
+VALUE rb_numerix_dup(VALUE self);
+VALUE rb_numerix_aref(VALUE self, VALUE index);
+VALUE rb_numerix_aset(VALUE self, VALUE index, VALUE value);
+VALUE rb_numerix_each(VALUE self);
+
+#if RUBY_API_VERSION_MAJOR >= 2
+VALUE rb_numerix_fiddle_ptr(VALUE self);
+#endif
+
+static inline int rb_numerix_isize(VALUE klass);
+VALUE rb_numerix_size(VALUE klass);
+VALUE rb_numerix_load(VALUE klass, VALUE str);
+
+#endif /* NUMERIX_STRUCTURE_H */

data/ext/numerix/vector.c

@@ -0,0 +1,326 @@
+
+#include "vector.h"
+
+VALUE rb_cBasicVector;
+
+void Init_basic_vector(VALUE outer) {
+    rb_cBasicVector = rb_define_class_under(outer, "Vector", rb_cObject);
+    rb_define_alloc_func(rb_cBasicVector, rb_basic_vector_alloc);
+    rb_define_method(rb_cBasicVector, "initialize", rb_basic_vector_initialize, -1);
+
+    // Instance
+    rb_define_method(rb_cBasicVector, "size", rb_basic_vector_size, 0);
+    rb_define_method(rb_cBasicVector, "address", rb_basic_vector_address, 0);
+    rb_define_method(rb_cBasicVector, "count", rb_basic_vector_count, 0);
+    rb_define_method(rb_cBasicVector, "length", rb_basic_vector_length, 0);
+    rb_define_method(rb_cBasicVector, "length_squared", rb_basic_vector_length_squared, 0);
+    rb_define_method(rb_cBasicVector, "normalize", rb_basic_vector_normalize, 0);
+    rb_define_method(rb_cBasicVector, "normalize!", rb_basic_vector_normalize_bang, 0);
+    rb_define_method(rb_cBasicVector, "each", rb_basic_vector_each, 0);
+    rb_define_method(rb_cBasicVector, "dot", rb_basic_vector_dot, 1);
+
+    // Operators
+    rb_define_method(rb_cBasicVector, "+", rb_basic_vector_add, 1);
+    rb_define_method(rb_cBasicVector, "-", rb_basic_vector_subtract, 1);
+    rb_define_method(rb_cBasicVector, "*", rb_basic_vector_multiply, 1);
+    rb_define_method(rb_cBasicVector, "/", rb_basic_vector_divide, 1);
+    rb_define_method(rb_cBasicVector, "-@", rb_basic_vector_negate, 0);
+    rb_define_method(rb_cBasicVector, "==", rb_basic_vector_equal, 1);
+    rb_define_method(rb_cBasicVector, "[]", rb_basic_vector_aref, 1);
+    rb_define_method(rb_cBasicVector, "[]=", rb_basic_vector_aset, 2);
+    rb_define_method(rb_cBasicVector, "**", rb_basic_vector_pow, 1);
+
+    rb_define_method(rb_cBasicVector, "to_s", rb_basic_vector_to_s, 0);
+
+    // Alias
+    rb_define_alias(rb_cBasicVector, "magnitude", "length");
+
+    // Class
+    rb_define_singleton_method(rb_cBasicVector, "[]", rb_basic_vector_create, -1);
+
+    // Include
+    rb_include_module(rb_cBasicVector, rb_mEnumerable);
+}
+
+VALUE rb_basic_vector_alloc(VALUE klass) {
+    BasicVector *v = ALLOC(BasicVector);
+    v->count = 0;
+    v->values = NULL;
+    return NUMERIX_WRAP(klass, v);
+}
+
+VALUE rb_basic_vector_initialize(int argc, VALUE *argv, VALUE self) {
+    BASIC_VECTOR();
+    if (argc == 1) {
+        int count = NUM2INT(argv[0]);
+        if (count < 2) {
+            rb_raise(rb_eNumerixError, "vector size must be 2 or greater");
+            return Qnil;
+        }
+        v->count = count;
+        v->values = (float *)ruby_xmalloc(sizeof(float) * count);
+        memset(v->values, 0, count * sizeof(float));
+    } else if (argc > 1) {
+        v->count = argc;
+        v->values = (float *)ruby_xmalloc(sizeof(float) * argc);
+        for (int i = 0; i < argc; i++)
+            v->values[i] = NUM2FLT(argv[i]);
+    } else
+        rb_raise(rb_eArgError, "no arguments given");
+
+    return Qnil;
+}
+
+VALUE rb_basic_vector_create(int argc, VALUE *argv, VALUE klass) {
+    if (argc < 2)
+        rb_raise(rb_eArgError, "wrong number of arguments (given %d, expected 2 or more)", argc);
+
+    BasicVector *v = ALLOC(BasicVector);
+    v->count = argc;
+    v->values = ruby_xmalloc(sizeof(float) * argc);
+    for (int i = 0; i < argc; i++)
+        v->values[i] = NUM2FLT(argv[i]);
+    rb_basic_vector_create;
+
+    return NUMERIX_WRAP(klass, v);
+}
+
+VALUE rb_basic_vector_length(VALUE self) {
+    BASIC_VECTOR();
+    int c = v->count;
+    float length = 0.0f;
+    for (int i = 0; i < c; i++)
+        length += v->values[i] * v->values[i];
+
+    return DBL2NUM(sqrtf(length));
+}
+
+VALUE rb_basic_vector_length_squared(VALUE self) {
+    BASIC_VECTOR();
+    int c = v->count;
+    float length = 0.0f;
+    for (int i = 0; i < c; i++)
+        length += v->values[i] * v->values[i];
+
+    return DBL2NUM(length);
+}
+
+VALUE rb_basic_vector_normalize(VALUE self) {
+    BASIC_VECTOR_RESULT();
+
+    int c = v->count;
+    float length = 0.0f;
+    for (int i = 0; i < c; i++)
+        length += v->values[i] * v->values[i];
+
+    float inverse = 1.0f / sqrtf(length);
+    for (int i = 0; i < c; i++)
+        result->values[i] = v->values[i] * inverse;
+
+    return NUMERIX_WRAP(CLASS_OF(self), result);
+}
+
+VALUE rb_basic_vector_normalize_bang(VALUE self) {
+    BASIC_VECTOR();
+
+    int c = v->count;
+    float length = 0.0f;
+    for (int i = 0; i < c; i++)
+        length += v->values[i] * v->values[i];
+
+    float inverse = 1.0f / sqrtf(length);
+    for (int i = 0; i < c; i++)
+        v->values[i] *= inverse;
+
+    return self;
+}
+
+VALUE rb_basic_vector_add(VALUE self, VALUE other) {
+    BASIC_VECTOR_OTHER_RESULT();
+    for (int i = 0; i < count; i++)
+        result->values[i] = v1->values[i] + v2->values[i];
+
+    return NUMERIX_WRAP(CLASS_OF(self), result);
+}
+
+VALUE rb_basic_vector_subtract(VALUE self, VALUE other) {
+    BASIC_VECTOR_OTHER_RESULT();
+    for (int i = 0; i < count; i++)
+        result->values[i] = v1->values[i] - v2->values[i];
+
+    return NUMERIX_WRAP(CLASS_OF(self), result);
+}
+
+VALUE rb_basic_vector_multiply(VALUE self, VALUE other) {
+    BASIC_VECTOR_RESULT();
+    int count = v->count;
+    if (NUMERIX_TYPE_P(other, rb_cBasicVector)) {
+        BasicVector *v2;
+        Data_Get_Struct(other, BasicVector, v2);
+        if (count != v2->count)
+            rb_raise(rb_eNumerixError, "unequal length vectors");
+        for (int i = 0; i < count; i++)
+            result->values[i] = v->values[i] * v2->values[i];
+    } else {
+        float scalar = NUM2FLT(other);
+        for (int i = 0; i < count; i++)
+            result->values[i] = v->values[i] * scalar;
+    }
+
+    return NUMERIX_WRAP(CLASS_OF(self), result);
+}
+
+VALUE rb_basic_vector_divide(VALUE self, VALUE other) {
+    BASIC_VECTOR_RESULT();
+    int count = v->count;
+    if (NUMERIX_TYPE_P(other, rb_cBasicVector)) {
+        BasicVector *v2;
+        Data_Get_Struct(other, BasicVector, v2);
+        if (count != v2->count)
+            rb_raise(rb_eNumerixError, "unequal length vectors");
+        for (int i = 0; i < count; i++)
+            result->values[i] = v->values[i] / v2->values[i];
+    } else {
+        float scalar = 1.0f / NUM2FLT(other);
+        for (int i = 0; i < count; i++)
+            result->values[i] = v->values[i] * scalar;
+    }
+
+    return NUMERIX_WRAP(CLASS_OF(self), result);
+}
+
+VALUE rb_basic_vector_negate(VALUE self, VALUE other) {
+    BASIC_VECTOR_RESULT();
+
+    int c = v->count;
+    for (int i = 0; i < c; i++)
+        result->values[i] = -v->values[i];
+
+    return NUMERIX_WRAP(CLASS_OF(self), result);
+}
+
+VALUE rb_basic_vector_equal(VALUE self, VALUE other) {
+    if (CLASS_OF(self) != CLASS_OF(other))
+        return Qfalse;
+
+    BasicVector *v1, *v2;
+    Data_Get_Struct(self, BasicVector, v1);
+    Data_Get_Struct(other, BasicVector, v2);
+
+    int count = v1->count;
+
+    if (count != v2->count)
+        return Qfalse;
+
+    for (int i = 0; i < count; i++) {
+        if (!FLT_EQUAL(v1->values[i], v2->values[i]))
+            return Qfalse;
+    }
+
+    return Qtrue;
+}
+
+VALUE rb_basic_vector_size(VALUE self) {
+    BASIC_VECTOR();
+    return INT2NUM(v->count * sizeof(float));
+}
+
+VALUE rb_basic_vector_address(VALUE self) {
+    BASIC_VECTOR();
+#if (SIZEOF_INTPTR_T == 4)
+    return LONG2NUM((long)v->values);
+#elif (SIZEOF_INTPTR_T == 8)
+    return LL2NUM((long long)v->values)
+#else
+    return INT2NUM(0);
+#endif
+}
+
+VALUE rb_basic_vector_count(VALUE self) {
+    BASIC_VECTOR();
+    return INT2NUM(v->count);
+}
+
+VALUE rb_basic_vector_aref(VALUE self, VALUE index) {
+    BASIC_VECTOR();
+    int i = NUM2INT(index);
+
+    if (i < 0 || i >= v->count)
+        return Qnil;
+    return DBL2NUM(v->values[i]);
+}
+
+VALUE rb_basic_vector_aset(VALUE self, VALUE index, VALUE value) {
+    BASIC_VECTOR();
+    int i = NUM2INT(index);
+
+    if (i >= 0 && i < v->count)
+        v->values[i] = NUM2FLT(value);
+
+    return value;
+}
+
+VALUE rb_basic_vector_each(VALUE self) {
+    BASIC_VECTOR();
+    int count = v->count;
+
+    volatile VALUE vector = self;
+    RETURN_SIZED_ENUMERATOR(vector, 0, 0, count);
+
+    for (int i = 0; i < count; i++)
+        rb_yield(DBL2NUM(v->values[i]));
+
+    return vector;
+}
+
+VALUE rb_basic_vector_dot(VALUE self, VALUE other) {
+    BasicVector *v1, *v2;
+    Data_Get_Struct(self, BasicVector, v1);
+    Data_Get_Struct(self, BasicVector, v1);
+    int count = v1->count;
+    if (count != v2->count)
+        rb_raise(rb_eNumerixError, "unequal length vectors");
+
+    float dot = 0;
+    for (int i = 0; i < count; i++)
+        dot += v1->values[i] * v2->values[i];
+
+    return DBL2NUM(dot);
+}
+
+VALUE rb_basic_vector_to_s(VALUE self) {
+    VALUE ary = rb_funcall(self, rb_intern("to_a"), 0);
+    VALUE str = rb_ary_join(ary, rb_str_new_cstr(", "));
+    return rb_sprintf("<%" PRIsVALUE ">", str);
+}
+
+VALUE rb_basic_vector_abs(VALUE self) {
+    BASIC_VECTOR_RESULT();
+
+    int count = v->count;
+    for (int i = 0; i < count; i++)
+        result->values[i] = fabsf(v->values[i]);
+
+    return NUMERIX_WRAP(CLASS_OF(self), result);
+}
+
+VALUE rb_basic_vector_sqrt(VALUE self) {
+    BASIC_VECTOR_RESULT();
+
+    int count = v->count;
+    for (int i = 0; i < count; i++)
+        result->values[i] = sqrtf(v->values[i]);
+
+    return NUMERIX_WRAP(CLASS_OF(self), result);
+}
+
+VALUE rb_basic_vector_pow(VALUE self, VALUE exponent) {
+    BASIC_VECTOR_RESULT();
+
+    float e = fabsf(NUM2FLT(exponent));
+    int count = v->count;
+    for (int i = 0; i < count; i++)
+        result->values[i] = powf(v->values[i], e);
+
+    return NUMERIX_WRAP(CLASS_OF(self), result);
+}

data/ext/numerix/vector.h

@@ -0,0 +1,57 @@
+#ifndef NUMERIX_BASIC_VECTOR_H
+#define NUMERIX_BASIC_VECTOR_H 1
+
+#include "common.h"
+
+#define BASIC_VECTOR() \
+    BasicVector *v;    \
+    Data_Get_Struct(self, BasicVector, v)
+
+#define BASIC_VECTOR_RESULT()                 \
+    BASIC_VECTOR();                           \
+    BasicVector *result = ALLOC(BasicVector); \
+    result->count = v->count;                 \
+    result->values = ruby_xmalloc(sizeof(float) * v->count)
+
+#define BASIC_VECTOR_OTHER_RESULT()                           \
+    BasicVector *v1, *v2, *result;                            \
+    Data_Get_Struct(self, BasicVector, v1);                   \
+    Data_Get_Struct(other, BasicVector, v2);                  \
+    result = ALLOC(BasicVector);                              \
+    int count = v1->count;                                    \
+    if (count != v2->count)                                   \
+        rb_raise(rb_eNumerixError, "unequal length vectors"); \
+    result->count = count;                                    \
+    result->values = ruby_xmalloc(sizeof(float) * count)
+
+void Init_basic_vector(VALUE outer);
+VALUE rb_basic_vector_alloc(VALUE klass);
+VALUE rb_basic_vector_initialize(int argc, VALUE *argv, VALUE self);
+
+// Instance
+VALUE rb_basic_vector_length(VALUE self);
+VALUE rb_basic_vector_length_squared(VALUE self);
+VALUE rb_basic_vector_normalize(VALUE self);
+VALUE rb_basic_vector_normalize_bang(VALUE self);
+VALUE rb_basic_vector_add(VALUE self, VALUE other);
+VALUE rb_basic_vector_subtract(VALUE self, VALUE other);
+VALUE rb_basic_vector_multiply(VALUE self, VALUE other);
+VALUE rb_basic_vector_divide(VALUE self, VALUE other);
+VALUE rb_basic_vector_negate(VALUE self, VALUE other);
+VALUE rb_basic_vector_equal(VALUE self, VALUE other);
+VALUE rb_basic_vector_size(VALUE self);
+VALUE rb_basic_vector_address(VALUE self);
+VALUE rb_basic_vector_count(VALUE self);
+VALUE rb_basic_vector_each(VALUE self);
+VALUE rb_basic_vector_aref(VALUE self, VALUE index);
+VALUE rb_basic_vector_aset(VALUE self, VALUE index, VALUE value);
+VALUE rb_basic_vector_dot(VALUE self, VALUE other);
+VALUE rb_basic_vector_to_s(VALUE self);
+VALUE rb_basic_vector_abs(VALUE self);
+VALUE rb_basic_vector_sqrt(VALUE self);
+VALUE rb_basic_vector_pow(VALUE self, VALUE exponent);
+
+// Class
+VALUE rb_basic_vector_create(int argc, VALUE *argv, VALUE klass);
+
+#endif