larb 0.1.0 → 1.0.1

data/test/larb/color_test.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class ColorTest < Test::Unit::TestCase
+  def test_bytes_clamp_before_integer_conversion
+    [1e8, 1e300, Float::INFINITY].each do |large|
+      assert_equal [255, 0, 128, 255], Larb::Color.new(large, -large, 0.5, 1).to_bytes
+      assert_equal "#ff0080ff", Larb::Color.new(large, -large, 0.5, 1).to_hex
+    end
+    4.times do |i|
+      values = [0, 0, 0, 1]
+      values[i] = Float::NAN
+      assert_raise(ArgumentError) { Larb::Color.new(*values).to_bytes }
+    end
+  end
+
+  def test_from_hex_validates_the_entire_string
+    ["#gg0000", "#ff0000zz", "#ff0000ffjunk", "f#f0000", "", "#fff",
+     "#ffff", " ff0000", "#ff0000\n", "ff0000\0", "＃ff0000"].each do |hex|
+      assert_raise(ArgumentError, hex.inspect) { Larb::Color.from_hex(hex) }
+    end
+    assert_raise(TypeError) { Larb::Color.from_hex(nil) }
+    assert_equal [255, 128, 0, 170], Larb::Color.from_hex("#FF8000aA").to_bytes
+  end
+
+  def test_new_with_default_values
+    c = Larb::Color.new
+    assert_equal 0.0, c.r
+    assert_equal 0.0, c.g
+    assert_equal 0.0, c.b
+    assert_equal 1.0, c.a
+  end
+
+  def test_new_with_given_values
+    c = Larb::Color.new(0.1, 0.2, 0.3, 0.4)
+    assert_equal 0.1, c.r
+    assert_equal 0.2, c.g
+    assert_equal 0.3, c.b
+    assert_equal 0.4, c.a
+  end
+
+  def test_bracket_syntax
+    c = Larb::Color[0.1, 0.2, 0.3, 0.4]
+    assert_equal 0.1, c.r
+    assert_equal 0.2, c.g
+    assert_equal 0.3, c.b
+    assert_equal 0.4, c.a
+  end
+
+  def test_bracket_syntax_default_alpha
+    c = Larb::Color[0.1, 0.2, 0.3]
+    assert_equal 1.0, c.a
+  end
+
+  def test_rgb
+    c = Larb::Color.rgb(0.5, 0.6, 0.7)
+    assert_equal 0.5, c.r
+    assert_equal 0.6, c.g
+    assert_equal 0.7, c.b
+    assert_equal 1.0, c.a
+  end
+
+  def test_rgba
+    c = Larb::Color.rgba(0.1, 0.2, 0.3, 0.4)
+    assert_equal 0.1, c.r
+    assert_equal 0.2, c.g
+    assert_equal 0.3, c.b
+    assert_equal 0.4, c.a
+  end
+
+  def test_from_bytes
+    c = Larb::Color.from_bytes(255, 128, 0, 255)
+    assert_equal 1.0, c.r
+    assert_in_delta 0.5, c.g, 0.01
+    assert_equal 0.0, c.b
+    assert_equal 1.0, c.a
+  end
+
+  def test_from_bytes_default_alpha
+    c = Larb::Color.from_bytes(255, 0, 0)
+    assert_equal 1.0, c.a
+  end
+
+  def test_from_hex
+    c = Larb::Color.from_hex("#ff8000")
+    assert_equal 1.0, c.r
+    assert_in_delta 0.5, c.g, 0.01
+    assert_equal 0.0, c.b
+    assert_equal 1.0, c.a
+  end
+
+  def test_from_hex_without_hash
+    c = Larb::Color.from_hex("ff0000")
+    assert_equal 1.0, c.r
+    assert_equal 0.0, c.g
+    assert_equal 0.0, c.b
+  end
+
+  def test_from_hex_with_alpha
+    c = Larb::Color.from_hex("#ff000080")
+    assert_equal 1.0, c.r
+    assert_in_delta 0.5, c.a, 0.01
+  end
+
+  def test_black
+    c = Larb::Color.black
+    assert_equal 0.0, c.r
+    assert_equal 0.0, c.g
+    assert_equal 0.0, c.b
+    assert_equal 1.0, c.a
+  end
+
+  def test_white
+    c = Larb::Color.white
+    assert_equal 1.0, c.r
+    assert_equal 1.0, c.g
+    assert_equal 1.0, c.b
+  end
+
+  def test_red
+    c = Larb::Color.red
+    assert_equal 1.0, c.r
+    assert_equal 0.0, c.g
+    assert_equal 0.0, c.b
+  end
+
+  def test_green
+    c = Larb::Color.green
+    assert_equal 0.0, c.r
+    assert_equal 1.0, c.g
+    assert_equal 0.0, c.b
+  end
+
+  def test_blue
+    c = Larb::Color.blue
+    assert_equal 0.0, c.r
+    assert_equal 0.0, c.g
+    assert_equal 1.0, c.b
+  end
+
+  def test_yellow
+    c = Larb::Color.yellow
+    assert_equal 1.0, c.r
+    assert_equal 1.0, c.g
+    assert_equal 0.0, c.b
+  end
+
+  def test_cyan
+    c = Larb::Color.cyan
+    assert_equal 0.0, c.r
+    assert_equal 1.0, c.g
+    assert_equal 1.0, c.b
+  end
+
+  def test_magenta
+    c = Larb::Color.magenta
+    assert_equal 1.0, c.r
+    assert_equal 0.0, c.g
+    assert_equal 1.0, c.b
+  end
+
+  def test_transparent
+    c = Larb::Color.transparent
+    assert_equal 0.0, c.r
+    assert_equal 0.0, c.g
+    assert_equal 0.0, c.b
+    assert_equal 0.0, c.a
+  end
+
+  def test_add
+    c1 = Larb::Color.new(0.1, 0.2, 0.3, 0.4)
+    c2 = Larb::Color.new(0.2, 0.3, 0.4, 0.5)
+    result = c1 + c2
+    assert_in_delta 0.3, result.r, 1e-10
+    assert_in_delta 0.5, result.g, 1e-10
+    assert_in_delta 0.7, result.b, 1e-10
+    assert_in_delta 0.9, result.a, 1e-10
+  end
+
+  def test_subtract
+    c1 = Larb::Color.new(0.5, 0.6, 0.7, 0.8)
+    c2 = Larb::Color.new(0.1, 0.2, 0.3, 0.4)
+    result = c1 - c2
+    assert_in_delta 0.4, result.r, 1e-10
+    assert_in_delta 0.4, result.g, 1e-10
+    assert_in_delta 0.4, result.b, 1e-10
+    assert_in_delta 0.4, result.a, 1e-10
+  end
+
+  def test_multiply_by_scalar
+    c = Larb::Color.new(0.2, 0.3, 0.4, 0.5)
+    result = c * 2
+    assert_in_delta 0.4, result.r, 1e-10
+    assert_in_delta 0.6, result.g, 1e-10
+    assert_in_delta 0.8, result.b, 1e-10
+    assert_in_delta 1.0, result.a, 1e-10
+  end
+
+  def test_multiply_by_color
+    c1 = Larb::Color.new(0.5, 0.5, 0.5, 1.0)
+    c2 = Larb::Color.new(1.0, 0.5, 0.0, 1.0)
+    result = c1 * c2
+    assert_in_delta 0.5, result.r, 1e-10
+    assert_in_delta 0.25, result.g, 1e-10
+    assert_equal 0.0, result.b
+  end
+
+  def test_lerp
+    c1 = Larb::Color.new(0, 0, 0, 0)
+    c2 = Larb::Color.new(1, 1, 1, 1)
+    result = c1.lerp(c2, 0.5)
+    assert_equal 0.5, result.r
+    assert_equal 0.5, result.g
+    assert_equal 0.5, result.b
+    assert_equal 0.5, result.a
+  end
+
+  def test_clamp
+    c = Larb::Color.new(-0.5, 1.5, 0.5, 2.0)
+    result = c.clamp
+    assert_equal 0.0, result.r
+    assert_equal 1.0, result.g
+    assert_equal 0.5, result.b
+    assert_equal 1.0, result.a
+  end
+
+  def test_to_bytes
+    c = Larb::Color.new(1.0, 0.5, 0.0, 1.0)
+    bytes = c.to_bytes
+    assert_equal 255, bytes[0]
+    assert_equal 128, bytes[1]
+    assert_equal 0, bytes[2]
+    assert_equal 255, bytes[3]
+  end
+
+  def test_to_hex
+    c = Larb::Color.new(1.0, 0.0, 0.0, 1.0)
+    assert_equal "#ff0000ff", c.to_hex
+  end
+
+  def test_to_vec3
+    c = Larb::Color.new(0.1, 0.2, 0.3, 1.0)
+    v = c.to_vec3
+    assert_instance_of Larb::Vec3, v
+    assert_equal 0.1, v.x
+    assert_equal 0.2, v.y
+    assert_equal 0.3, v.z
+  end
+
+  def test_to_vec4
+    c = Larb::Color.new(0.1, 0.2, 0.3, 0.4)
+    v = c.to_vec4
+    assert_instance_of Larb::Vec4, v
+    assert_equal 0.1, v.x
+    assert_equal 0.2, v.y
+    assert_equal 0.3, v.z
+    assert_equal 0.4, v.w
+  end
+
+  def test_to_a
+    c = Larb::Color.new(0.1, 0.2, 0.3, 0.4)
+    assert_equal [0.1, 0.2, 0.3, 0.4], c.to_a
+  end
+
+  def test_from_vec4
+    v = Larb::Vec4.new(0.1, 0.2, 0.3, 0.4)
+    c = Larb::Color.from_vec4(v)
+    assert_equal 0.1, c.r
+    assert_equal 0.2, c.g
+    assert_equal 0.3, c.b
+    assert_equal 0.4, c.a
+  end
+
+  def test_from_vec3
+    v = Larb::Vec3.new(0.1, 0.2, 0.3)
+    c = Larb::Color.from_vec3(v)
+    assert_equal 0.1, c.r
+    assert_equal 0.2, c.g
+    assert_equal 0.3, c.b
+    assert_equal 1.0, c.a
+  end
+
+  def test_from_vec3_with_alpha
+    v = Larb::Vec3.new(0.1, 0.2, 0.3)
+    c = Larb::Color.from_vec3(v, 0.5)
+    assert_equal 0.5, c.a
+  end
+
+  def test_inspect
+    c = Larb::Color.new(0.1, 0.2, 0.3, 0.4)
+    assert_equal "Color[0.1, 0.2, 0.3, 0.4]", c.inspect
+  end
+
+  def test_to_s
+    c = Larb::Color.new(0.1, 0.2, 0.3, 0.4)
+    assert_equal c.inspect, c.to_s
+  end
+end

data/test/larb/mat2_test.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class Mat2Test < Test::Unit::TestCase
+  def test_new_identity_by_default
+    m = Larb::Mat2.new
+    assert_equal 1.0, m[0]
+    assert_equal 0.0, m[1]
+    assert_equal 0.0, m[2]
+    assert_equal 1.0, m[3]
+  end
+
+  def test_new_with_data
+    m = Larb::Mat2.new([1, 2, 3, 4])
+    assert_equal [1, 2, 3, 4], m.data
+  end
+
+  def test_identity
+    m = Larb::Mat2.identity
+    assert_equal 1.0, m[0]
+    assert_equal 1.0, m[3]
+  end
+
+  def test_zero
+    m = Larb::Mat2.zero
+    4.times { |i| assert_equal 0.0, m[i] }
+  end
+
+  def test_rotation
+    m = Larb::Mat2.rotation(Math::PI / 2)
+    assert_in_delta 0.0, m[0], 1e-10
+    assert_in_delta 1.0, m[1], 1e-10
+    assert_in_delta(-1.0, m[2], 1e-10)
+    assert_in_delta 0.0, m[3], 1e-10
+  end
+
+  def test_scaling
+    m = Larb::Mat2.scaling(2, 3)
+    assert_equal 2.0, m[0]
+    assert_equal 3.0, m[3]
+  end
+
+  def test_from_vec2
+    v1 = Larb::Vec2.new(1, 2)
+    v2 = Larb::Vec2.new(3, 4)
+    m = Larb::Mat2.from_vec2(v1, v2)
+    assert_equal [1.0, 2.0, 3.0, 4.0], m.data
+  end
+
+  def test_multiply_mat2
+    m1 = Larb::Mat2.rotation(Math::PI / 4)
+    m2 = Larb::Mat2.rotation(Math::PI / 4)
+    result = m1 * m2
+    expected = Larb::Mat2.rotation(Math::PI / 2)
+    assert result.near?(expected)
+  end
+
+  def test_multiply_vec2
+    m = Larb::Mat2.rotation(Math::PI / 2)
+    v = Larb::Vec2.new(1, 0)
+    result = m * v
+    assert_in_delta 0.0, result.x, 1e-10
+    assert_in_delta 1.0, result.y, 1e-10
+  end
+
+  def test_multiply_scalar
+    m = Larb::Mat2.identity
+    result = m * 2
+    assert_equal 2.0, result[0]
+    assert_equal 2.0, result[3]
+  end
+
+  def test_add
+    m1 = Larb::Mat2.identity
+    m2 = Larb::Mat2.identity
+    result = m1 + m2
+    assert_equal 2.0, result[0]
+  end
+
+  def test_subtract
+    m1 = Larb::Mat2.identity
+    m2 = Larb::Mat2.identity
+    result = m1 - m2
+    assert_equal 0.0, result[0]
+  end
+
+  def test_determinant
+    m = Larb::Mat2.identity
+    assert_equal 1.0, m.determinant
+  end
+
+  def test_determinant_scaling
+    m = Larb::Mat2.scaling(2, 3)
+    assert_equal 6.0, m.determinant
+  end
+
+  def test_inverse
+    m = Larb::Mat2.scaling(2, 4)
+    inv = m.inverse
+    result = m * inv
+    assert result.near?(Larb::Mat2.identity)
+  end
+
+  def test_inverse_singular
+    m = Larb::Mat2.zero
+    assert_raise_message("Matrix is not invertible") { m.inverse }
+  end
+
+  def test_transpose
+    m = Larb::Mat2.new([1, 2, 3, 4])
+    result = m.transpose
+    assert_equal [1, 3, 2, 4], result.data
+  end
+
+  def test_adjoint
+    m = Larb::Mat2.new([1, 2, 3, 4])
+    adj = m.adjoint
+    assert_equal 4.0, adj[0]
+    assert_equal(-2.0, adj[1])
+  end
+
+  def test_frobenius_norm
+    m = Larb::Mat2.new([1, 2, 2, 0])
+    assert_equal 3.0, m.frobenius_norm
+  end
+
+  def test_equality
+    m1 = Larb::Mat2.identity
+    m2 = Larb::Mat2.identity
+    assert_equal m1, m2
+  end
+
+  def test_near
+    m1 = Larb::Mat2.identity
+    m2 = Larb::Mat2.new([1.0000001, 0, 0, 1.0000001])
+    assert m1.near?(m2)
+  end
+
+  def test_inspect
+    m = Larb::Mat2.identity
+    assert_match(/Mat2/, m.inspect)
+  end
+end

data/test/larb/mat2d_test.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class Mat2dTest < Test::Unit::TestCase
+  def test_new_identity_by_default
+    m = Larb::Mat2d.new
+    assert_equal 1.0, m[0]
+    assert_equal 0.0, m[1]
+    assert_equal 0.0, m[2]
+    assert_equal 1.0, m[3]
+    assert_equal 0.0, m[4]
+    assert_equal 0.0, m[5]
+  end
+
+  def test_new_with_data
+    data = [1, 2, 3, 4, 5, 6]
+    m = Larb::Mat2d.new(data)
+    assert_equal [1, 2, 3, 4, 5, 6], m.data
+  end
+
+  def test_identity
+    m = Larb::Mat2d.identity
+    assert_equal 1.0, m[0]
+    assert_equal 1.0, m[3]
+  end
+
+  def test_zero
+    m = Larb::Mat2d.zero
+    6.times { |i| assert_equal 0.0, m[i] }
+  end
+
+  def test_translation
+    m = Larb::Mat2d.translation(10, 20)
+    assert_equal 10.0, m[4]
+    assert_equal 20.0, m[5]
+  end
+
+  def test_rotation
+    m = Larb::Mat2d.rotation(Math::PI / 2)
+    assert_in_delta 0.0, m[0], 1e-10
+    assert_in_delta 1.0, m[1], 1e-10
+  end
+
+  def test_scaling
+    m = Larb::Mat2d.scaling(2, 3)
+    assert_equal 2.0, m[0]
+    assert_equal 3.0, m[3]
+  end
+
+  def test_from_rotation_translation_scale
+    m = Larb::Mat2d.from_rotation_translation_scale(
+      0,
+      Larb::Vec2.new(10, 20),
+      Larb::Vec2.new(2, 3)
+    )
+    assert_equal 2.0, m[0]
+    assert_equal 3.0, m[3]
+    assert_equal 10.0, m[4]
+    assert_equal 20.0, m[5]
+  end
+
+  def test_multiply_mat2d
+    m1 = Larb::Mat2d.translation(10, 0)
+    m2 = Larb::Mat2d.translation(5, 0)
+    result = m1 * m2
+    assert_equal 15.0, result[4]
+  end
+
+  def test_multiply_vec2
+    m = Larb::Mat2d.translation(10, 20)
+    v = Larb::Vec2.new(0, 0)
+    result = m * v
+    assert_equal 10.0, result.x
+    assert_equal 20.0, result.y
+  end
+
+  def test_multiply_rotation_translation
+    m = Larb::Mat2d.rotation(Math::PI / 2) * Larb::Mat2d.translation(1, 0)
+    v = Larb::Vec2.new(0, 0)
+    result = m * v
+    assert_in_delta 0.0, result.x, 1e-10
+    assert_in_delta 1.0, result.y, 1e-10
+  end
+
+  def test_determinant
+    m = Larb::Mat2d.identity
+    assert_equal 1.0, m.determinant
+  end
+
+  def test_determinant_scaling
+    m = Larb::Mat2d.scaling(2, 3)
+    assert_equal 6.0, m.determinant
+  end
+
+  def test_inverse
+    m = Larb::Mat2d.translation(10, 20) * Larb::Mat2d.scaling(2, 2)
+    inv = m.inverse
+    result = m * inv
+    assert result.near?(Larb::Mat2d.identity)
+  end
+
+  def test_inverse_singular
+    m = Larb::Mat2d.zero
+    assert_raise_message("Matrix is not invertible") { m.inverse }
+  end
+
+  def test_translate
+    m = Larb::Mat2d.identity
+    result = m.translate(5, 10)
+    assert_equal 5.0, result[4]
+    assert_equal 10.0, result[5]
+  end
+
+  def test_rotate
+    m = Larb::Mat2d.identity
+    result = m.rotate(Math::PI / 2)
+    assert_in_delta 0.0, result[0], 1e-10
+  end
+
+  def test_scale
+    m = Larb::Mat2d.identity
+    result = m.scale(2, 3)
+    assert_equal 2.0, result[0]
+    assert_equal 3.0, result[3]
+  end
+
+  def test_extract_translation
+    m = Larb::Mat2d.translation(10, 20)
+    t = m.extract_translation
+    assert_equal 10.0, t.x
+    assert_equal 20.0, t.y
+  end
+
+  def test_extract_rotation
+    m = Larb::Mat2d.rotation(Math::PI / 4)
+    angle = m.extract_rotation
+    assert_in_delta Math::PI / 4, angle, 1e-10
+  end
+
+  def test_extract_scale
+    m = Larb::Mat2d.scaling(2, 3)
+    s = m.extract_scale
+    assert_in_delta 2.0, s.x, 1e-10
+    assert_in_delta 3.0, s.y, 1e-10
+  end
+
+  def test_to_mat3
+    m = Larb::Mat2d.translation(10, 20)
+    m3 = m.to_mat3
+    assert_instance_of Larb::Mat3, m3
+    assert_equal 10.0, m3[6]
+    assert_equal 20.0, m3[7]
+  end
+
+  def test_equality
+    m1 = Larb::Mat2d.identity
+    m2 = Larb::Mat2d.identity
+    assert_equal m1, m2
+  end
+
+  def test_near
+    m1 = Larb::Mat2d.identity
+    m2 = Larb::Mat2d.new([1.0000001, 0, 0, 1.0000001, 0, 0])
+    assert m1.near?(m2)
+  end
+
+  def test_inspect
+    m = Larb::Mat2d.identity
+    assert_match(/Mat2d/, m.inspect)
+  end
+
+  def test_decomposition_round_trips_signed_scales
+    [-1, 1].repeated_permutation(2) do |signs|
+      [0, Math::PI / 2, 1.2].each do |angle|
+        matrix = Larb::Mat2d.from_rotation_translation_scale(
+          angle, Larb::Vec2.new(1, 2), Larb::Vec2.new(signs[0] * 2, signs[1] * 3)
+        )
+        scale = matrix.extract_scale
+        assert_equal signs.inject(:*) < 0, scale.x < 0
+        rebuilt = Larb::Mat2d.from_rotation_translation_scale(
+          matrix.extract_rotation, matrix.extract_translation, scale
+        )
+        assert rebuilt.to_a.all?(&:finite?)
+        matrix.to_a.zip(rebuilt.to_a).each { |a, b| assert_in_delta a, b, 1e-9 }
+      end
+    end
+  end
+
+  def test_decomposition_rejects_shear_zero_scale_and_nonfinite_values
+    [Larb::Mat2d.new([1, 0, 0.5, 1, 0, 0]), Larb::Mat2d.scaling(0, 1),
+     Larb::Mat2d.scaling(Float::NAN, 1)].each do |matrix|
+      assert_raise(ArgumentError) { matrix.extract_scale }
+      assert_raise(ArgumentError) { matrix.extract_rotation }
+    end
+  end
+end