numerix 1.0.0

data/ext/numerix/vector4.h

@@ -0,0 +1,63 @@
+#ifndef NUMERIX_VECTOR4_H
+#define NUMERIX_VECTOR4_H 1
+
+#include "common.h"
+#include "vector_base.h"
+
+void Init_vector4(VALUE outer);
+static VALUE rb_vector4_alloc(VALUE klass);
+VALUE rb_vector4_initialize(int argc, VALUE *argv, VALUE self);
+
+// Instance
+VALUE rb_vector4_length(VALUE self);
+VALUE rb_vector4_length_squared(VALUE self);
+VALUE rb_vector4_add(VALUE self, VALUE other);
+VALUE rb_vector4_subtract(VALUE self, VALUE other);
+VALUE rb_vector4_multiply(VALUE self, VALUE other);
+VALUE rb_vector4_divide(VALUE self, VALUE other);
+VALUE rb_vector4_equal(VALUE self, VALUE other);
+VALUE rb_vector4_negate(VALUE self);
+VALUE rb_vector4_one_p(VALUE self);
+VALUE rb_vector4_zero_p(VALUE self);
+VALUE rb_vector4_min_value(VALUE self);
+VALUE rb_vector4_max_value(VALUE self);
+VALUE rb_vector4_distance(VALUE self, VALUE other);
+VALUE rb_vector4_distance_squared(VALUE self, VALUE other);
+VALUE rb_vector4_normalize(VALUE self);
+VALUE rb_vector4_normalize_bang(VALUE self);
+VALUE rb_vector4_lerp(VALUE self, VALUE other, VALUE amount);
+VALUE rb_vector4_lerp_bang(VALUE self, VALUE other, VALUE amount);
+VALUE rb_vector4_transform(VALUE self, VALUE other);
+VALUE rb_vector4_transform_bang(VALUE self, VALUE other);
+VALUE rb_vector4_abs(VALUE self);
+VALUE rb_vector4_sqrt(VALUE self);
+VALUE rb_vector4_pow(VALUE self, VALUE exponent);
+VALUE rb_vector4_dot(VALUE self, VALUE other);
+VALUE rb_vector4_clamp(VALUE self, VALUE min, VALUE max);
+VALUE rb_vector4_clamp_bang(VALUE self, VALUE min, VALUE max);
+VALUE rb_vector4_map(VALUE self);
+VALUE rb_vector4_map_bang(VALUE self);
+
+// Conversion
+VALUE rb_vector4_to_s(VALUE self);
+VALUE rb_vector4_to_a(VALUE self);
+VALUE rb_vector4_to_h(VALUE self);
+VALUE rb_vector4_to_vec2(VALUE self);
+VALUE rb_vector4_to_vec3(VALUE self);
+VALUE rb_vector4_to_quaternion(VALUE self);
+VALUE rb_vector4_to_plane(VALUE self);
+
+// Class
+VALUE rb_vector4_one(VALUE klass);
+VALUE rb_vector4_unit_x(VALUE klass);
+VALUE rb_vector4_unit_y(VALUE klass);
+VALUE rb_vector4_unit_z(VALUE klass);
+VALUE rb_vector4_unit_w(VALUE klass);
+VALUE rb_vector4_create_norm(VALUE klass, VALUE x, VALUE y, VALUE z, VALUE w);
+static inline VALUE rb_vector4_clamp_s(VALUE klass, VALUE vector, VALUE minimum, VALUE maximum);
+static inline VALUE rb_vector4_lerp_s(VALUE klass, VALUE vec1, VALUE vec2, VALUE amount);
+static inline VALUE rb_vector4_transform_s(VALUE klass, VALUE vector, VALUE matrix);
+static inline VALUE rb_vector4_min_s(VALUE klass, VALUE vec1, VALUE vec2);
+static inline VALUE rb_vector4_max_s(VALUE klass, VALUE vec1, VALUE vec2);
+
+#endif /* NUMERIX_VECTOR4_H */

data/ext/numerix/vector_base.c

@@ -0,0 +1,94 @@
+
+#include "vector_base.h"
+
+VALUE rb_cVectorBase;
+VALUE rb_cVector2;
+VALUE rb_cVector3;
+VALUE rb_cVector4;
+VALUE rb_cQuaternion;
+
+void Init_vector_base(VALUE outer) {
+    rb_cVectorBase = rb_define_class_under(outer, "VectorBase", rb_cNumerixStruct);
+    rb_cVector2 = rb_define_class_under(outer, "Vector2", rb_cVectorBase);
+    rb_cVector3 = rb_define_class_under(outer, "Vector3", rb_cVectorBase);
+    rb_cVector4 = rb_define_class_under(outer, "Vector4", rb_cVectorBase);
+    rb_cQuaternion = rb_define_class_under(outer, "Quaternion", rb_cNumerixStruct);
+
+    rb_define_method(rb_cVectorBase, "initialize", rb_numerix_abstract_initialize, 0);
+
+    rb_define_method(rb_cVector2, "x", rb_vector_base_x, 0);
+    rb_define_method(rb_cVector2, "y", rb_vector_base_y, 0);
+    rb_define_method(rb_cVector2, "x=", rb_vector_base_x_set, 1);
+    rb_define_method(rb_cVector2, "y=", rb_vector_base_y_set, 1);
+
+    rb_define_method(rb_cVector3, "x", rb_vector_base_x, 0);
+    rb_define_method(rb_cVector3, "y", rb_vector_base_y, 0);
+    rb_define_method(rb_cVector3, "z", rb_vector_base_z, 0);
+    rb_define_method(rb_cVector3, "x=", rb_vector_base_x_set, 1);
+    rb_define_method(rb_cVector3, "y=", rb_vector_base_y_set, 1);
+    rb_define_method(rb_cVector3, "z=", rb_vector_base_z_set, 1);
+
+    rb_define_method(rb_cVector4, "x", rb_vector_base_x, 0);
+    rb_define_method(rb_cVector4, "y", rb_vector_base_y, 0);
+    rb_define_method(rb_cVector4, "z", rb_vector_base_z, 0);
+    rb_define_method(rb_cVector4, "w", rb_vector_base_w, 0);
+    rb_define_method(rb_cVector4, "x=", rb_vector_base_x_set, 1);
+    rb_define_method(rb_cVector4, "y=", rb_vector_base_y_set, 1);
+    rb_define_method(rb_cVector4, "z=", rb_vector_base_z_set, 1);
+    rb_define_method(rb_cVector4, "w=", rb_vector_base_w_set, 1);
+
+    rb_define_method(rb_cQuaternion, "x", rb_vector_base_x, 0);
+    rb_define_method(rb_cQuaternion, "y", rb_vector_base_y, 0);
+    rb_define_method(rb_cQuaternion, "z", rb_vector_base_z, 0);
+    rb_define_method(rb_cQuaternion, "w", rb_vector_base_w, 0);
+    rb_define_method(rb_cQuaternion, "x=", rb_vector_base_x_set, 1);
+    rb_define_method(rb_cQuaternion, "y=", rb_vector_base_y_set, 1);
+    rb_define_method(rb_cQuaternion, "z=", rb_vector_base_z_set, 1);
+    rb_define_method(rb_cQuaternion, "w=", rb_vector_base_w_set, 1);
+
+    rb_include_module(rb_cVectorBase, rb_mEnumerable);
+}
+
+VALUE rb_vector_base_x(VALUE self) {
+    VECTOR2();
+    return DBL2NUM(v->x);
+}
+
+VALUE rb_vector_base_y(VALUE self) {
+    VECTOR2();
+    return DBL2NUM(v->y);
+}
+
+VALUE rb_vector_base_z(VALUE self) {
+    VECTOR3();
+    return DBL2NUM(v->z);
+}
+
+VALUE rb_vector_base_w(VALUE self) {
+    VECTOR4();
+    return DBL2NUM(v->w);
+}
+
+VALUE rb_vector_base_x_set(VALUE self, VALUE value) {
+    VECTOR2();
+    v->x = NUM2FLT(value);
+    return value;
+}
+
+VALUE rb_vector_base_y_set(VALUE self, VALUE value) {
+    VECTOR2();
+    v->y = NUM2FLT(value);
+    return value;
+}
+
+VALUE rb_vector_base_z_set(VALUE self, VALUE value) {
+    VECTOR3();
+    v->z = NUM2FLT(value);
+    return value;
+}
+
+VALUE rb_vector_base_w_set(VALUE self, VALUE value) {
+    VECTOR4();
+    v->w = NUM2FLT(value);
+    return value;
+}

data/ext/numerix/vector_base.h

@@ -0,0 +1,30 @@
+#ifndef NUMERIX_VECTOR_BASE_H
+#define NUMERIX_VECTOR_BASE_H 1
+
+#include "common.h"
+
+#define VECTOR2() \
+    Vector2 *v;   \
+    Data_Get_Struct(self, Vector2, v)
+
+#define VECTOR3() \
+    Vector3 *v;   \
+    Data_Get_Struct(self, Vector3, v)
+
+#define VECTOR4() \
+    Vector4 *v;   \
+    Data_Get_Struct(self, Vector4, v)
+
+void Init_vector_base(VALUE outer);
+
+VALUE rb_vector_base_x(VALUE self);
+VALUE rb_vector_base_y(VALUE self);
+VALUE rb_vector_base_z(VALUE self);
+VALUE rb_vector_base_w(VALUE self);
+
+VALUE rb_vector_base_x_set(VALUE self, VALUE value);
+VALUE rb_vector_base_y_set(VALUE self, VALUE value);
+VALUE rb_vector_base_z_set(VALUE self, VALUE value);
+VALUE rb_vector_base_w_set(VALUE self, VALUE value);
+
+#endif /* NUMERIX_VECTOR_BASE_H */

data/lib/numerix/error.rb

@@ -0,0 +1,36 @@
+
+module Numerix
+
+  ##
+  # Size of the internal {Vector2} struct, in bytes.
+  SIZEOF_VECTOR2 = SIZEOF_FLOAT * 2
+
+  ##
+  # Size of the internal {Vector3} struct, in bytes.
+  SIZEOF_VECTOR3 = SIZEOF_FLOAT * 3
+
+  ##
+  # Size of the internal {Vector4} struct, in bytes.
+  SIZEOF_VECTOR4 = SIZEOF_FLOAT * 4
+
+  ##
+  # Size of the internal {Matrix3x2} struct, in bytes.
+  SIZEOF_MATRIX3X2 = SIZEOF_FLOAT * 6
+
+  ##
+  # Size of the internal {Matrix4x4} struct, in bytes.
+  SIZEOF_MATRIX4X4 = SIZEOF_FLOAT * 16
+
+  ##
+  # Size of the internal {Plane} struct, in bytes.
+  SIZEOF_PLANE = SIZEOF_FLOAT * 4
+
+  ##
+  # Size of the internal {Quaternion} struct, in bytes.
+  SIZEOF_QUATERNION = SIZEOF_FLOAT * 4
+
+  ##
+  # Exception class for Numerix specific errors.
+  class NumerixError < StandardError
+  end
+end

data/lib/numerix/matrix3x2.rb

@@ -0,0 +1,420 @@
+module Numerix
+
+  ##
+  # A structure encapsulating a 3x2 matrix.
+  class Matrix3x2 < MatrixBase
+    
+    ##
+    # @return [Float] the first element of the first row.
+    attr_accessor :m11
+
+    ##
+    # @return [Float] the second element of the first row.
+    attr_accessor :m12
+
+    ##
+    # @return [Float] the first element of the second row.
+    attr_accessor :m21
+
+    ##
+    # @return [Float] the second element of the second row.
+    attr_accessor :m22
+
+    ##
+    # @return [Float] the first element of the third row.
+    attr_accessor :m31
+
+    ##
+    # @return [Float] the second element of the third row.
+    attr_accessor :m32
+
+    ##
+    # @return [Vector2] the translation component of this matrix.
+    attr_accessor :translation
+
+    ##
+    # @overload initialize
+    #   Creates a new matrix with all values set to `0.0`.
+    #
+    # @overload initialize(m11, m12, m21, m22, m31, m32)
+    #   Constructs a Matrix3x2 from the given components.
+    #
+    #   @param m11 [Float] The first element of the first row.
+    #   @param m12 [Float] The second element of the first row.
+    #   @param m21 [Float] The first element of the second row.
+    #   @param m22 [Float] The second element of the second row.
+    #   @param m31 [Float] The first element of the third row.
+    #   @param m32 [Float] The second element of the third row.
+    #
+    # @see create_translation
+    # @see create_scale
+    # @see create_skew
+    # @see create_rotation
+    # @see identity
+    def initialize(*args)
+    end
+
+    ##
+    # The equivalent of `Enumerable#map`, but returns a matrix object instead of
+    # an Array.
+    #
+    # Invokes the given block once for each element of `self`.
+    #
+    # Creates a new matrix containing the values returned by the block.
+    #
+    # @yield [component] Yields a component of the matrix to the block.
+    # @yieldparam component [Float] The yielded component.
+    #
+    # @return [Matrix3x2]
+    #
+    # @see map!
+    def map
+    end
+
+    ##
+    # Invokes the given block once for each element of self, replacing the
+    # element with the value returned by the block.
+    #
+    # The values of the matrix are altered without creating a ne object.
+    #
+    # @yield [component] Yields a component of the matrix to the block.
+    # @yieldparam component [Float] The yielded component.
+    #
+    # @return [self]
+    #
+    # @see map
+    def map!
+    end
+
+    alias_method :collect, :map
+    alias_method :collect!, :map!
+
+    ##
+    # Raises the matrix to the given power.
+    #
+    # @param exponent [Float] The power to raise the matrix to.
+    #
+    # @return [Matrix3x2] New matrix that is result of the operation.
+    def **(exponent)
+    end
+
+    ##
+    # @return [Boolean] `true` if the matrix is the identity matrix, otherwise
+    #   `false`.
+    def identity?
+    end
+
+    ##
+    # Calculates the determinant for this matrix.
+    #
+    # The determinant is calculated by expanding the matrix with a third column
+    # whose values are (0,0,1).
+    #
+    # @return [Float] the determinant.
+    def determinant
+    end
+
+    ##
+    # Returns the specified matrix row as an array.
+    #
+    # @param index [Integer] The row index to retrieve.
+    #
+    # @return [Array<Float>, nil] the requested row, or `nil` if index is out of
+    #   range.
+    #
+    # @see column
+    def row(index)
+    end
+
+    ##
+    # Returns the specified matrix column as an array.
+    #
+    # @param index [Integer] The column index to retrieve.
+    #
+    # @return [Array<Float>, nil] the requested column, or `nil` if index is out
+    #   of range.
+    #
+    # @see row
+    def column(index)
+    end
+
+    ##
+    # Enumerates the rows of the matrix.
+    #
+    # @yield [row] Yields a row to the block.
+    # @yieldparam row [Array<Float>] The current row as an array.
+    #
+    # @return [self]
+    #
+    # see each_column
+    def each_row
+    end
+
+    ##
+    # Enumerates the columns of the matrix.
+    #
+    # @yield [column] Yields a column to the block.
+    # @yieldparam column [Array<Float>] The current column as an array.
+    #
+    # @return [self]
+    #
+    # @see each_row
+    def each_column
+    end
+
+    ##
+    # Attempts to invert the given matrix.
+    #
+    # @note Some matrices cannot be inverted, in which case the returned matrix
+    #   will have all values set to `NaN`.
+    #
+    # @return [Matrix3x2] A new matrix that is this matrix inverted.
+    def invert
+    end
+
+    ##
+    # Linearly interpolates from this matrix to another, based on the amount.
+    #
+    # @param matrix [Matrix3x2] The source matrix to interpolate between.
+    # @param amount [Float] The relative weighting of the given matrix, clamped
+    #   between `0.0` and `1.0`.
+    #
+    # @return [Matrix3x2] a newly created interpolated matrix.
+    #
+    # @see lerp!
+    def lerp(matrix, amount)
+    end
+
+    ##
+    # @note This method is the same as {#lerp}, but alters the values of this
+    #   matrix instead of creating a new instance.
+    #
+    # Linearly interpolates from this matrix to another, based on the amount.
+    #
+    # @param matrix [Matrix3x2] The source matrix to interpolate between.
+    # @param amount [Float] The relative weighting of the given matrix, clamped
+    #   between `0.0` and `1.0`.
+    #
+    # @return [self]
+    #
+    # @see lerp
+    def lerp!(matrix, amount)
+    end
+
+    ##
+    # @return [String] a String representation of this instance.
+    def to_s
+    end
+
+    ##
+    # @return [Array<Array<Float>>] an Array representation of this instance.
+    def to_a
+    end
+
+    alias_method :elements, :to_a
+
+    ##
+    # @return [Hash{Symbol => Float}] a Hash representation of this instance.
+    def to_h
+    end
+
+    ##
+    # Negates the given matrix by multiplying all values by `-1.0`.
+    #
+    # @return [Matrix3x2] the negated matrix.
+    def -@
+    end
+
+    ##
+    # Adds each matrix element in value1 with its corresponding element in the
+    # specified matrix.
+    #
+    # @param other [Matrix3x2] The matrix to add.
+    #
+    # @return [Matrix3x2] A matrix containing the summed values.
+    def +(other)
+    end
+
+    ##
+    # Subtracts each matrix element in the specified matrix from its
+    # corresponding element in this matrix to form a new matrix of the
+    # difference.
+    #
+    # @param other [Matrix3x2] The matrix to subtract.
+    #
+    # @return [Matrix3x2] The matrix containing the resulting values.
+    def -(other)
+    end
+
+    ##
+    # Multiplies this matrix by the specified value.
+    #
+    # @overload *(scalar)
+    #   Scales all elements in a matrix by the given scalar factor.
+    #
+    #   @param scalar [Float] The scaling value to use.
+    #
+    # @overload *(other)
+    #   Multiplies two matrices together and returns the resulting matrix.
+    #
+    #   @param other [Matrix3x2] The source matrix to multiply.
+    #
+    # @return [Matrix3x2] the product matrix.
+    def *(other)
+    end
+
+    ##
+    # Returns flag if this matrix instance is equal to the given object.
+    #
+    # @param other [Object] The object to compare.
+    #
+    # @return [Boolean] `true` if objects are equal, otherwise `false`.
+    def ==(other)
+    end
+
+    ##
+    # Accesses the matrix component using the zero-based row/column indices.
+    #
+    # @param row [Integer] The zero-based row index.
+    # @param column [Integer] The zero-based column index.
+    #
+    # @return [Float, nil] the value at the specified location, or `nil` if an
+    #   index is out of range.
+    def [](row, column)
+    end
+
+    ##
+    # Sets the matrix component using the zero-based row/column indices.
+    #
+    # @param row [Integer] The zero-based row index.
+    # @param column [Integer] The zero-based column index.
+    # @param value [Float] The value to set.
+    #
+    # @return [Float] the value.
+    def []=(row, column, value)
+    end
+
+    class << self
+
+      ##
+      # @return [Matrix3x2] the multiplicative identity matrix.
+      def identity
+      end
+
+      ##
+      # Creates a translation matrix.
+      #
+      # @overload create_translation(position)
+      #   Creates a translation matrix from the given vector.
+      #
+      #   @param position [Vector] The translation position.
+      #
+      # @overload create_translation(x, y)
+      #   Creates a translation matrix from the given X and Y components.
+      #
+      #   @param x [Float] The X position.
+      #   @param y [Float] The Y position.
+      #
+      # @return [Matrix3x2] a translation matrix.
+      def create_translation(other)
+      end
+
+      ##
+      # Creates a scale matrix.
+      #
+      # @overload create_scale(x, y)
+      #   Creates a scale matrix from the given X and Y components.
+      #
+      #   @param x [Float] Value to scale by on the X-axis.
+      #   @param y [Float] Value to scale by on the Y-axis.
+      #
+      # @overload create_scale(x, y, center)
+      #   Creates a scale matrix that is offset by a given center point.
+      #
+      #   @param x [Float] Value to scale by on the X-axis.
+      #   @param y [Float] Value to scale by on the Y-axis.
+      #   @param center [Vector2] The center point.
+      #
+      # @overload create_scale(scales)
+      #   Creates a scale matrix from the given vector scale.
+      #
+      #   @param scales [Vector2] The scale to use.
+      #
+      # @overload create_scale(scales, center)
+      #   Creates a scale matrix from the given vector scale with an offset from
+      #   the given center point.
+      #
+      #   @param scales [Vector2] The scale to use.
+      #   @param center [Vector2] The center point.
+      #
+      # @overload create_scale(scale)
+      #   Creates a scale matrix that scales uniformly with the given scale.
+      #
+      #   @param scale [Float] The uniform scale to use.
+      #
+      # @overload create_scale(scale, center)
+      #   Creates a scale matrix that scales uniformly with the given scale with
+      #   an offset from the given center.
+      #
+      #   @param scale [Float] The uniform scale to use.
+      #   @param center [Vector2] The center point.
+      #
+      # @return [Matrix3x2] a scaling matrix.
+      def create_scale(*args)
+      end
+
+      ##
+      # Creates a skew matrix.
+      #
+      # @overload create_skew(x, y)
+      #   Creates a skew matrix from the given angles in radians.
+      #
+      #   @param x [Float] The X angle, in radians
+      #   @param y [Float] The Y angle, in radians
+      #
+      # @overload create_skew(x, y, center)
+      #   Creates a skew matrix from the given angles in radians and a center
+      #   point.
+      #
+      #   @param x [Float] The X angle, in radians
+      #   @param y [Float] The Y angle, in radians
+      #   @param center [Vector2] The center point.
+      #
+      # @return [Matrix3x2] a skew matrix.
+      def create_skew(*args)
+      end
+
+      ##
+      # Creates a rotation matrix.
+      #
+      # @overload create_rotation(radians)
+      #   Creates a rotation matrix using the given rotation in radians.
+      #
+      #   @param radians [Float] The amount of rotation, in radians.
+      #
+      # @overload create_rotation(radians, center)
+      #   Creates a rotation matrix using the given rotation in radians and a
+      #   center point.
+      #
+      #   @param radians [Float] The amount of rotation, in radians.
+      #   @param center [Vector2] The center point
+      #
+      # @return [Matrix3x2] a rotation matrix.
+      def create_rotation
+      end
+
+      ##
+      # Linearly interpolates from _matrix1_ to _matrix2_, based on the third
+      # parameter.
+      #
+      # @param matrix1 [Matrix3x2] The first source matrix.
+      # @param matrix2 [Matrix3x2] The second source matrix.
+      # @param amount [Float] The relative weighting of _matrix2_, clamped
+      #   between `0.0` and `1.0`.
+      #
+      # @return [Matrix3x2] the interpolated matrix.
+      def lerp(matrix1, matrix2, amount)
+      end
+    end
+  end
+end