Implement determinant

alan/src/compile/integration_tests.rs

@@ -816,6 +816,26 @@ test_gpgpu!(gpu_fract => r#"
     stdout "0.00, 0.14\n";
 );
 
+test_gpgpu!(gpu_determinant => r#"
+    export fn{Js} main {
+      let b = GBuffer([1.0.f32, 2.0.f32, 3.0.f32, 4.0.f32]);
+      let id = gFor(1);
+      let out = GBuffer{f32}(1);
+      // Hack to get this to work in JS, because the generic is not passed through there
+      {"((b) => { b.ValKind = alan_std.F32; })" :: GBuffer}(out);
+      out[id].store(gmat2x2f(b[0].asF32, b[1].asF32, b[2].asF32, b[3].asF32).determinant.asI32).build.run;
+      (out.read{f32}[0]!!).string(1).print;
+    }
+    export fn{Rs} main {
+      let b = GBuffer([1.0.f32, 2.0.f32, 3.0.f32, 4.0.f32]);
+      let id = gFor(1);
+      let out = GBuffer{f32}(1);
+      out[id].store(gmat2x2f(b[0].asF32, b[1].asF32, b[2].asF32, b[3].asF32).determinant.asI32).build.run;
+      (out.read{f32}[0]!!).string(1).print;
+    }"#;
+    stdout "-2.0\n";
+);
+
 // TODO: Fix u64 numeric constants to get u64 bitwise tests in the new test suite
 test!(u64_bitwise => r#"
     prefix u64 as ~ precedence 10

alan/test.ln

@@ -1061,7 +1061,9 @@ export fn{Test} main {
           .map(fn (v: f64) = string(v, 1)).join(', '),
         '10.0, 14.0, 11.0')
     .it('fract')
-      .assert(eq, {f64[2]}(1.0, 3.14).fract.map(fn (v: f64) = v.string(2)).join(', '), '0.00, 0.14');
+      .assert(eq, {f64[2]}(1.0, 3.14).fract.map(fn (v: f64) = v.string(2)).join(', '), '0.00, 0.14')
+    .it('determinant')
+      .assert(eq, {f64[4]}(1.0, 2.0, 3.0, 4.0).determinant, -2.0);
 
   test.describe("Conditionals")
     .it("if function")

alan_compiler/src/std/root.ln

@@ -1428,6 +1428,23 @@ fn fma{S}(a: Buffer{f32, S}, b: Buffer{f32, S}, c: Buffer{f32, S}) = a.map(fn (v
 fn fma{S}(a: Buffer{f64, S}, b: Buffer{f64, S}, c: Buffer{f64, S}) = a.map(fn (v: f64, i: i64) = v.fma(b[i]!!, c[i]!!));
 fn fract{S}(a: Buffer{f32, S}) = a.map(fract);
 fn fract{S}(a: Buffer{f64, S}) = a.map(fract);
+fn determinant{T}(m: Buffer{T, 4}) = m.0 * m.3 - m.2 * m.1;
+fn determinant{T}(m: Buffer{T, 9}) =
+  m.0 * m.4 * m.8 +
+  m.3 * m.7 * m.2 +
+  m.6 * m.1 * m.5 -
+  m.6 * m.4 * m.2 -
+  m.3 * m.1 * m.8 -
+  m.0 * m.7 * m.5;
+fn determinant{T}(m: Buffer{T, 16}) =
+  m.0 * m.5 * m.10 * m.15 +
+  m.4 * m.9 * m.14 * m.3 +
+  m.8 * m.13 * m.2 * m.7 +
+  m.12 * m.1 * m.6 * m.11 -
+  m.12 * m.9 * m.6 * m.3 -
+  m.8 * m.5 * m.2 * m.15 -
+  m.4 * m.1 * m.14 * m.11 -
+  m.0 * m.13 * m.10 * m.7;
 
 /// Dictionary-related bindings
 fn{Rs} Dict{K, V} "alan_std::OrderedHashMap::new" <- RootBacking :: () -> Dict{K, V};
@@ -4135,6 +4152,14 @@ fn fract(a: gvec2f) = gFract(a);
 fn fract(a: gvec3f) = gFract(a);
 fn fract(a: gvec4f) = gFract(a);
 
+fn gDeterminant{I}(m: I) {
+  let varName = 'determinant('.concat(m.varName).concat(')');
+  return gf32(varName, m.statements, m.buffers);
+}
+fn determinant(m: gmat2x2f) = gDeterminant(m);
+fn determinant(m: gmat3x3f) = gDeterminant(m);
+fn determinant(m: gmat4x4f) = gDeterminant(m);
+
 fn gadd{A, B}(a: A, b: B) {
   let varName = '('.concat(a.varName).concat(' + ').concat(b.varName).concat(')');
   let statements = a.statements.concat(b.statements);