larb 0.1.0 → 1.0.0

data/test/larb/vec3_test.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class Vec3Test < Test::Unit::TestCase
+  def test_new_with_default_values
+    v = Larb::Vec3.new
+    assert_equal 0.0, v.x
+    assert_equal 0.0, v.y
+    assert_equal 0.0, v.z
+  end
+
+  def test_new_with_given_values
+    v = Larb::Vec3.new(1, 2, 3)
+    assert_equal 1.0, v.x
+    assert_equal 2.0, v.y
+    assert_equal 3.0, v.z
+  end
+
+  def test_bracket_syntax
+    v = Larb::Vec3[1, 2, 3]
+    assert_equal 1.0, v.x
+    assert_equal 2.0, v.y
+    assert_equal 3.0, v.z
+  end
+
+  def test_zero
+    assert_equal Larb::Vec3.new(0, 0, 0), Larb::Vec3.zero
+  end
+
+  def test_one
+    assert_equal Larb::Vec3.new(1, 1, 1), Larb::Vec3.one
+  end
+
+  def test_up
+    assert_equal Larb::Vec3.new(0, 1, 0), Larb::Vec3.up
+  end
+
+  def test_down
+    assert_equal Larb::Vec3.new(0, -1, 0), Larb::Vec3.down
+  end
+
+  def test_forward
+    assert_equal Larb::Vec3.new(0, 0, -1), Larb::Vec3.forward
+  end
+
+  def test_back
+    assert_equal Larb::Vec3.new(0, 0, 1), Larb::Vec3.back
+  end
+
+  def test_right
+    assert_equal Larb::Vec3.new(1, 0, 0), Larb::Vec3.right
+  end
+
+  def test_left
+    assert_equal Larb::Vec3.new(-1, 0, 0), Larb::Vec3.left
+  end
+
+  def test_add
+    v1 = Larb::Vec3.new(1, 2, 3)
+    v2 = Larb::Vec3.new(4, 5, 6)
+    assert_equal Larb::Vec3.new(5, 7, 9), v1 + v2
+  end
+
+  def test_subtract
+    v1 = Larb::Vec3.new(4, 5, 6)
+    v2 = Larb::Vec3.new(1, 2, 3)
+    assert_equal Larb::Vec3.new(3, 3, 3), v1 - v2
+  end
+
+  def test_multiply_by_scalar
+    v = Larb::Vec3.new(1, 2, 3)
+    assert_equal Larb::Vec3.new(2, 4, 6), v * 2
+  end
+
+  def test_multiply_by_vec3
+    v1 = Larb::Vec3.new(1, 2, 3)
+    v2 = Larb::Vec3.new(2, 3, 4)
+    assert_equal Larb::Vec3.new(2, 6, 12), v1 * v2
+  end
+
+  def test_divide_by_scalar
+    v = Larb::Vec3.new(2, 4, 6)
+    assert_equal Larb::Vec3.new(1, 2, 3), v / 2
+  end
+
+  def test_negate
+    v = Larb::Vec3.new(1, -2, 3)
+    assert_equal Larb::Vec3.new(-1, 2, -3), -v
+  end
+
+  def test_dot
+    v1 = Larb::Vec3.new(1, 2, 3)
+    v2 = Larb::Vec3.new(4, 5, 6)
+    assert_equal 32.0, v1.dot(v2)
+  end
+
+  def test_cross
+    v1 = Larb::Vec3.new(1, 0, 0)
+    v2 = Larb::Vec3.new(0, 1, 0)
+    assert_equal Larb::Vec3.new(0, 0, 1), v1.cross(v2)
+  end
+
+  def test_cross_arbitrary
+    v1 = Larb::Vec3.new(1, 2, 3)
+    v2 = Larb::Vec3.new(4, 5, 6)
+    assert_equal Larb::Vec3.new(-3, 6, -3), v1.cross(v2)
+  end
+
+  def test_length
+    v = Larb::Vec3.new(2, 3, 6)
+    assert_equal 7.0, v.length
+  end
+
+  def test_length_squared
+    v = Larb::Vec3.new(2, 3, 6)
+    assert_equal 49.0, v.length_squared
+  end
+
+  def test_normalize
+    v = Larb::Vec3.new(0, 3, 4)
+    result = v.normalize
+    assert_in_delta 0.0, result.x, 1e-10
+    assert_in_delta 0.6, result.y, 1e-10
+    assert_in_delta 0.8, result.z, 1e-10
+  end
+
+  def test_reflect
+    v = Larb::Vec3.new(1, -1, 0).normalize
+    normal = Larb::Vec3.new(0, 1, 0)
+    result = v.reflect(normal)
+    assert_in_delta v.x, result.x, 1e-10
+    assert_in_delta(-v.y, result.y, 1e-10)
+  end
+
+  def test_xy
+    v = Larb::Vec3.new(1, 2, 3)
+    result = v.xy
+    assert_instance_of Larb::Vec2, result
+    assert_equal 1.0, result.x
+    assert_equal 2.0, result.y
+  end
+
+  def test_xz
+    v = Larb::Vec3.new(1, 2, 3)
+    result = v.xz
+    assert_instance_of Larb::Vec2, result
+    assert_equal 1.0, result.x
+    assert_equal 3.0, result.y
+  end
+
+  def test_yz
+    v = Larb::Vec3.new(1, 2, 3)
+    result = v.yz
+    assert_instance_of Larb::Vec2, result
+    assert_equal 2.0, result.x
+    assert_equal 3.0, result.y
+  end
+
+  def test_lerp
+    v1 = Larb::Vec3.new(0, 0, 0)
+    v2 = Larb::Vec3.new(10, 20, 30)
+    assert_equal Larb::Vec3.new(5, 10, 15), v1.lerp(v2, 0.5)
+  end
+
+  def test_to_a
+    v = Larb::Vec3.new(1, 2, 3)
+    assert_equal [1.0, 2.0, 3.0], v.to_a
+  end
+
+  def test_to_vec4
+    v = Larb::Vec3.new(1, 2, 3)
+    result = v.to_vec4
+    assert_instance_of Larb::Vec4, result
+    assert_equal 1.0, result.x
+    assert_equal 2.0, result.y
+    assert_equal 3.0, result.z
+    assert_equal 1.0, result.w
+  end
+
+  def test_to_vec4_with_custom_w
+    v = Larb::Vec3.new(1, 2, 3)
+    result = v.to_vec4(0.5)
+    assert_equal 0.5, result.w
+  end
+
+  def test_index_access
+    v = Larb::Vec3.new(1, 2, 3)
+    assert_equal 1.0, v[0]
+    assert_equal 2.0, v[1]
+    assert_equal 3.0, v[2]
+  end
+
+  def test_equality
+    v1 = Larb::Vec3.new(1, 2, 3)
+    v2 = Larb::Vec3.new(1, 2, 3)
+    assert_equal v1, v2
+  end
+
+  def test_inequality
+    v1 = Larb::Vec3.new(1, 2, 3)
+    v2 = Larb::Vec3.new(1, 2, 4)
+    assert_not_equal v1, v2
+  end
+
+  def test_not_equal_to_array
+    v = Larb::Vec3.new(1, 2, 3)
+    assert_not_equal v, [1, 2, 3]
+  end
+
+  def test_near
+    v1 = Larb::Vec3.new(1.0, 2.0, 3.0)
+    v2 = Larb::Vec3.new(1.0000001, 2.0000001, 3.0000001)
+    assert v1.near?(v2)
+  end
+
+  def test_distance
+    v1 = Larb::Vec3.new(0, 0, 0)
+    v2 = Larb::Vec3.new(2, 3, 6)
+    assert_equal 7.0, v1.distance(v2)
+  end
+
+  def test_distance_squared
+    v1 = Larb::Vec3.new(0, 0, 0)
+    v2 = Larb::Vec3.new(2, 3, 6)
+    assert_equal 49.0, v1.distance_squared(v2)
+  end
+
+  def test_angle_between
+    v1 = Larb::Vec3.new(1, 0, 0)
+    v2 = Larb::Vec3.new(0, 1, 0)
+    assert_in_delta Math::PI / 2, v1.angle_between(v2), 1e-10
+  end
+
+  def test_project
+    v = Larb::Vec3.new(3, 4, 0)
+    onto = Larb::Vec3.new(1, 0, 0)
+    result = v.project(onto)
+    assert_equal 3.0, result.x
+    assert_equal 0.0, result.y
+  end
+
+  def test_reject
+    v = Larb::Vec3.new(3, 4, 0)
+    from = Larb::Vec3.new(1, 0, 0)
+    result = v.reject(from)
+    assert_equal 0.0, result.x
+    assert_equal 4.0, result.y
+  end
+
+  def test_clamp_length
+    v = Larb::Vec3.new(2, 3, 6)
+    result = v.clamp_length(3.5)
+    assert_in_delta 3.5, result.length, 1e-10
+  end
+
+  def test_clamp_length_under_limit
+    v = Larb::Vec3.new(1, 1, 1)
+    result = v.clamp_length(10)
+    assert_equal v, result
+  end
+
+  def test_normalize!
+    v = Larb::Vec3.new(0, 3, 4)
+    v.normalize!
+    assert_in_delta 1.0, v.length, 1e-10
+  end
+
+  def test_min
+    v1 = Larb::Vec3.new(1, 5, 3)
+    v2 = Larb::Vec3.new(2, 3, 4)
+    assert_equal Larb::Vec3.new(1, 3, 3), v1.min(v2)
+  end
+
+  def test_max
+    v1 = Larb::Vec3.new(1, 5, 3)
+    v2 = Larb::Vec3.new(2, 3, 4)
+    assert_equal Larb::Vec3.new(2, 5, 4), v1.max(v2)
+  end
+
+  def test_abs
+    v = Larb::Vec3.new(-1, -2, 3)
+    assert_equal Larb::Vec3.new(1, 2, 3), v.abs
+  end
+
+  def test_floor
+    v = Larb::Vec3.new(1.7, 2.3, 3.9)
+    assert_equal Larb::Vec3.new(1, 2, 3), v.floor
+  end
+
+  def test_ceil
+    v = Larb::Vec3.new(1.1, 2.5, 3.9)
+    assert_equal Larb::Vec3.new(2, 3, 4), v.ceil
+  end
+
+  def test_round
+    v = Larb::Vec3.new(1.4, 2.5, 3.6)
+    assert_equal Larb::Vec3.new(1, 3, 4), v.round
+  end
+
+  def test_inspect
+    v = Larb::Vec3.new(1, 2, 3)
+    assert_equal "Vec3[1.0, 2.0, 3.0]", v.inspect
+  end
+
+  def test_to_s
+    v = Larb::Vec3.new(1, 2, 3)
+    assert_equal v.inspect, v.to_s
+  end
+end

data/test/larb/vec4_test.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class Vec4Test < Test::Unit::TestCase
+  def test_new_with_default_values
+    v = Larb::Vec4.new
+    assert_equal 0.0, v.x
+    assert_equal 0.0, v.y
+    assert_equal 0.0, v.z
+    assert_equal 1.0, v.w
+  end
+
+  def test_new_with_given_values
+    v = Larb::Vec4.new(1, 2, 3, 4)
+    assert_equal 1.0, v.x
+    assert_equal 2.0, v.y
+    assert_equal 3.0, v.z
+    assert_equal 4.0, v.w
+  end
+
+  def test_bracket_syntax
+    v = Larb::Vec4[1, 2, 3, 4]
+    assert_equal 1.0, v.x
+    assert_equal 2.0, v.y
+    assert_equal 3.0, v.z
+    assert_equal 4.0, v.w
+  end
+
+  def test_bracket_syntax_default_w
+    v = Larb::Vec4[1, 2, 3]
+    assert_equal 1.0, v.w
+  end
+
+  def test_zero
+    assert_equal Larb::Vec4.new(0, 0, 0, 0), Larb::Vec4.zero
+  end
+
+  def test_one
+    assert_equal Larb::Vec4.new(1, 1, 1, 1), Larb::Vec4.one
+  end
+
+  def test_add
+    v1 = Larb::Vec4.new(1, 2, 3, 4)
+    v2 = Larb::Vec4.new(5, 6, 7, 8)
+    assert_equal Larb::Vec4.new(6, 8, 10, 12), v1 + v2
+  end
+
+  def test_subtract
+    v1 = Larb::Vec4.new(5, 6, 7, 8)
+    v2 = Larb::Vec4.new(1, 2, 3, 4)
+    assert_equal Larb::Vec4.new(4, 4, 4, 4), v1 - v2
+  end
+
+  def test_multiply_by_scalar
+    v = Larb::Vec4.new(1, 2, 3, 4)
+    assert_equal Larb::Vec4.new(2, 4, 6, 8), v * 2
+  end
+
+  def test_divide_by_scalar
+    v = Larb::Vec4.new(2, 4, 6, 8)
+    assert_equal Larb::Vec4.new(1, 2, 3, 4), v / 2
+  end
+
+  def test_perspective_divide
+    v = Larb::Vec4.new(2, 4, 6, 2)
+    result = v.perspective_divide
+    assert_instance_of Larb::Vec3, result
+    assert_equal 1.0, result.x
+    assert_equal 2.0, result.y
+    assert_equal 3.0, result.z
+  end
+
+  def test_perspective_divide_w_is_1
+    v = Larb::Vec4.new(1, 2, 3, 1)
+    assert_equal Larb::Vec3.new(1, 2, 3), v.perspective_divide
+  end
+
+  def test_perspective_divide_w_is_0
+    v = Larb::Vec4.new(1, 2, 3, 0)
+    assert_equal Larb::Vec3.new(1, 2, 3), v.perspective_divide
+  end
+
+  def test_xyz
+    v = Larb::Vec4.new(1, 2, 3, 4)
+    result = v.xyz
+    assert_instance_of Larb::Vec3, result
+    assert_equal Larb::Vec3.new(1, 2, 3), result
+  end
+
+  def test_xy
+    v = Larb::Vec4.new(1, 2, 3, 4)
+    result = v.xy
+    assert_instance_of Larb::Vec2, result
+    assert_equal Larb::Vec2.new(1, 2), result
+  end
+
+  def test_rgb
+    v = Larb::Vec4.new(0.5, 0.6, 0.7, 1.0)
+    result = v.rgb
+    assert_instance_of Larb::Vec3, result
+    assert_equal Larb::Vec3.new(0.5, 0.6, 0.7), result
+  end
+
+  def test_to_a
+    v = Larb::Vec4.new(1, 2, 3, 4)
+    assert_equal [1.0, 2.0, 3.0, 4.0], v.to_a
+  end
+
+  def test_index_access
+    v = Larb::Vec4.new(1, 2, 3, 4)
+    assert_equal 1.0, v[0]
+    assert_equal 2.0, v[1]
+    assert_equal 3.0, v[2]
+    assert_equal 4.0, v[3]
+  end
+
+  def test_negate
+    v = Larb::Vec4.new(1, -2, 3, -4)
+    assert_equal Larb::Vec4.new(-1, 2, -3, 4), -v
+  end
+
+  def test_dot
+    v1 = Larb::Vec4.new(1, 2, 3, 4)
+    v2 = Larb::Vec4.new(5, 6, 7, 8)
+    assert_equal 70.0, v1.dot(v2)
+  end
+
+  def test_length
+    v = Larb::Vec4.new(1, 2, 2, 0)
+    assert_equal 3.0, v.length
+  end
+
+  def test_length_squared
+    v = Larb::Vec4.new(1, 2, 2, 0)
+    assert_equal 9.0, v.length_squared
+  end
+
+  def test_normalize
+    v = Larb::Vec4.new(1, 2, 2, 0)
+    result = v.normalize
+    assert_in_delta 1.0, result.length, 1e-10
+  end
+
+  def test_normalize!
+    v = Larb::Vec4.new(1, 2, 2, 0)
+    v.normalize!
+    assert_in_delta 1.0, v.length, 1e-10
+  end
+
+  def test_equality
+    v1 = Larb::Vec4.new(1, 2, 3, 4)
+    v2 = Larb::Vec4.new(1, 2, 3, 4)
+    assert_equal v1, v2
+  end
+
+  def test_inequality
+    v1 = Larb::Vec4.new(1, 2, 3, 4)
+    v2 = Larb::Vec4.new(1, 2, 3, 5)
+    assert_not_equal v1, v2
+  end
+
+  def test_not_equal_to_array
+    v = Larb::Vec4.new(1, 2, 3, 4)
+    assert_not_equal v, [1, 2, 3, 4]
+  end
+
+  def test_near
+    v1 = Larb::Vec4.new(1.0, 2.0, 3.0, 4.0)
+    v2 = Larb::Vec4.new(1.0000001, 2.0000001, 3.0000001, 4.0000001)
+    assert v1.near?(v2)
+  end
+
+  def test_lerp
+    v1 = Larb::Vec4.new(0, 0, 0, 0)
+    v2 = Larb::Vec4.new(10, 20, 30, 40)
+    assert_equal Larb::Vec4.new(5, 10, 15, 20), v1.lerp(v2, 0.5)
+  end
+
+  def test_inspect
+    v = Larb::Vec4.new(1, 2, 3, 4)
+    assert_equal "Vec4[1.0, 2.0, 3.0, 4.0]", v.inspect
+  end
+
+  def test_to_s
+    v = Larb::Vec4.new(1, 2, 3, 4)
+    assert_equal v.inspect, v.to_s
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "test-unit"
+require_relative "../lib/larb"

metadata

@@ -1,37 +1,76 @@
 --- !ruby/object:Gem::Specification
 name: larb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Yudai Takada
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
 description: Larb provides vectors, matrices, quaternions, and Color classes for 2D/3D
   graphics and mathematical computations
 email:
 - t.yudai92@gmail.com
 executables: []
-extensions: []
+extensions:
+- ext/larb/extconf.rb
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
 - LICENSE
 - README.md
-- Rakefile
+- ext/larb/color.c
+- ext/larb/color.h
+- ext/larb/extconf.rb
+- ext/larb/larb.c
+- ext/larb/larb.h
+- ext/larb/mat2.c
+- ext/larb/mat2.h
+- ext/larb/mat2d.c
+- ext/larb/mat2d.h
+- ext/larb/mat3.c
+- ext/larb/mat3.h
+- ext/larb/mat4.c
+- ext/larb/mat4.h
+- ext/larb/quat.c
+- ext/larb/quat.h
+- ext/larb/quat2.c
+- ext/larb/quat2.h
+- ext/larb/vec2.c
+- ext/larb/vec2.h
+- ext/larb/vec3.c
+- ext/larb/vec3.h
+- ext/larb/vec4.c
+- ext/larb/vec4.h
 - lib/larb.rb
-- lib/larb/color.rb
-- lib/larb/mat2.rb
-- lib/larb/mat2d.rb
-- lib/larb/mat3.rb
-- lib/larb/mat4.rb
-- lib/larb/quat.rb
-- lib/larb/quat2.rb
-- lib/larb/vec2.rb
-- lib/larb/vec3.rb
-- lib/larb/vec4.rb
+- lib/larb/version.rb
+- test/larb/color_test.rb
+- test/larb/mat2_test.rb
+- test/larb/mat2d_test.rb
+- test/larb/mat3_test.rb
+- test/larb/mat4_test.rb
+- test/larb/quat2_test.rb
+- test/larb/quat_test.rb
+- test/larb/vec2_test.rb
+- test/larb/vec3_test.rb
+- test/larb/vec4_test.rb
+- test/test_helper.rb
 homepage: https://github.com/ydah/larb
 licenses:
 - MIT

data/Rakefile

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-require "rake/testtask"
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.test_files = FileList["test/**/*_test.rb"]
-end
-
-task default: :test