feature: checkpoint

not a good way of testing things, but it's a way and the first way

.gitignore

@@ -10,4 +10,6 @@ hs_err_pid*
 .idea/
 *.iml
 .vscode/
+.scala-build/
 
+project/metals.sbt

build.sbt

@@ -4,3 +4,4 @@ name := "torque"
 organization := "com.nsrddyn"
 
 libraryDependencies += "dev.zio" %% "zio" % "2.1.22"
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.2.19" % Test

src/main/scala/com/nsrddyn/ALU/Hash.scala

@@ -1,4 +1,4 @@
-package com.nsrddyn
+package com.nsrddyn.alu
 
 import scala.util.hashing
 

src/main/scala/com/nsrddyn/ALU/Prime.scala

@@ -1,9 +1,9 @@
-package com.nsrddyn
+package com.nsrddyn.alu
 
 
+import com.nsrddyn.tools.Benchmark
 
-class Prime() {
-
+class Prime() extends Benchmark {
 
   /*
    * Calculate all primes up to limit
@@ -18,11 +18,25 @@ class Prime() {
    *
    */
 
+
+  /*
+   * TODO: I did the countrary of what i wanted to accieve with the is prime function
+   *       We want the function to be less optimized so that the CPU has more work == more stress 
+   */
+
+
   def isPrime(n: Int): Boolean = {
     if n <= 1 then false
     else !(2 to math.sqrt(n).toInt).exists(i => n % i  == 0)
+
+
   }
 
-  def run(n: Int): Unit = for i <- 0 to n do isPrime(i)
+  def run(n: Int, result: Boolean): Unit = {
+
+    for i <- 0 to n do if isPrime(i) == result then println("true") else println("false") 
+  }
+
+
 }
 

src/main/scala/com/nsrddyn/Enums/Status.scala

@@ -0,0 +1,6 @@
+package com.nsrddyn.Enums
+
+enum Status:
+  case PASS 
+  case FAIL 
+

src/main/scala/com/nsrddyn/FPU/CholeskyDecomposition.scala

@@ -0,0 +1,53 @@
+package com.nsrddyn.fpu
+
+import scala.math._
+import scala.collection.immutable.ListSet
+import scala.collection.mutable.ArrayBuffer
+
+class CholeskyDecomposition {
+
+  /*
+   *  Floating point operation to stress the cpu
+   *  Calculate the number of KFLOPS / FLOPS
+   *  implementation of the Cholesky decomposition
+   *  More information on the Cholesky decomposition at: 
+   *  https://en.wikipedia.org/wiki/Cholesky_decomposition
+   *  
+   *  Linpack uses the cholesky decomposition
+   *  https://www.netlib.org/linpack/
+   *
+   *  https://www.geeksforgeeks.org/dsa/cholesky-decomposition-matrix-decomposition/
+   *
+   *  The Cholesky decomposition maps matrix A into the product of A = L · LH where L is the lower triangular matrix and LH is the transposed,
+   *  complex conjugate or Hermitian, and therefore of upper triangular form (Fig. 13.6).
+   *  This is true because of the special case of A being a square, conjugate symmetric matrix. 
+   */ 
+
+  def run(matrix: List[List[Int]]): Unit = {
+
+    val n: Int = matrix.size
+
+    // store the lower triangular matrix
+    val lower = Vector[Vector[Int]]()
+
+
+    for (i <- 0 until n)
+    {
+      for (j <- 0 until i)
+        var sum: Double = 0
+
+        if j == i then
+        sum += math.pow(lowerBuffer(i)(j), 2)
+
+        end if 
+        lower(i)(j) = (sqrt(matrix(i)(j))())
+
+        j += 1
+    }
+    i += 1
+  }
+  
+  def (matrix: Vector[Vector[Int]], index: int, jindex: int ): Int = if j == 1 then return math.pow(matrix(index)(jindex)) else 
+
+
+}

src/main/scala/com/nsrddyn/FPU/FPU.scala

@@ -0,0 +1,6 @@
+package com.nsrddyn.fpu
+
+
+class FPU {
+  
+}

src/main/scala/com/nsrddyn/FPU/Matrix.scala

@@ -0,0 +1,5 @@
+package com.nsrddyn.fpu
+
+class Matrix {
+  
+}

src/main/scala/com/nsrddyn/Main.scala

@@ -1,20 +1,23 @@
 package com.nsrddyn
 
+import com.nsrddyn.fpu.CholeskyDecomposition
+import com.nsrddyn.Tests.CholeskyDecompositionTest
+import java.time.Instant
+import com.nsrddyn.alu.*
+import com.nsrddyn.tools.Benchmark
+
 object Torque {
 
-  import java.time.Instant
-
-  @main def main(args: String*): Unit = 
+  println("hello world")
 
+  @main def main(args: String*): Unit =  {
     // ANSI ESCAPE CODE: clear screen
     println("\u001b[2J\u001b[H")
     println("--- TORQUE STRESS TESTING UTILITY ---")
 
-  val now: Instant = Instant.now()
-  println(now)
+    var tester: CholeskyDecompositionTest = new CholeskyDecompositionTest
+    println(tester.test())
 
-  val pr = new Prime()
-
-  val intMax = 2147483647
-  pr.run(intMax)
   }
+}
+

src/main/scala/com/nsrddyn/Tests/CholeskyDecompositionTest.scala

@@ -0,0 +1,16 @@
+package com.nsrddyn.Tests
+
+import com.nsrddyn.fpu.CholeskyDecomposition
+import scala.collection.immutable.ListSet
+
+class CholeskyDecompositionTest extends CholeskyDecomposition {
+
+  def test(): Unit = {
+
+    val cdp: CholeskyDecomposition = new  CholeskyDecomposition
+    val matrix: List[List[Int]] = List.empty[List[Int]]
+
+    println(cdp.run(matrix))
+
+  }
+}

src/main/scala/com/nsrddyn/Tests/PrimeTest.scala

@@ -0,0 +1,29 @@
+package com.nsrddyn.Test
+
+import com.nsrddyn.alu.Prime
+import com.nsrddyn.tools.Benchmark
+
+class PrimeTest extends Prime {
+
+  def runBasic(): Unit = {
+
+    val pr = new Prime()
+    val br = new Benchmark()
+
+    /*
+     * test cases
+     *
+     * 7919 true
+     * 2147483647 false
+     */
+
+    val time = pr.run(7919, true)
+    println(time)
+
+  } 
+
+  def runExtreme(): Unit = println("running some very have stuff!")
+  
+
+
+}

src/main/scala/com/nsrddyn/Tools/Benchmark.scala

@@ -0,0 +1,17 @@
+package com.nsrddyn.tools
+
+class Benchmark {
+  /* 
+   * Calculate the time between the start of the execution of the function and the end
+   * */
+  def measureTime(work: => Unit): Long = {
+
+    val start = System.nanoTime()
+    work
+    val end = System.nanoTime()
+    end - start
+  } 
+
+  // TODO: map this to an actual precision value
+  def measurePrecision(work: => Boolean, expectedResult: Boolean): Unit = if work == expectedResult then println(true) else println(false) 
+}

src/main/scala/com/nsrddyn/cpu/Cpu.scala

@@ -1,12 +0,0 @@
-package com.nsrddyn
-
-/*
- * cpu object, only one instance of an object needed
- */
-
-object Cpu {
-  
-  val name = ""
-
-
-}

src/main/scala/com/nsrddyn/cpu/FPU/CholeskyDecomposition.scala

@@ -1,28 +0,0 @@
-package com.nsrddyn
-
-
-class CholeskyDecomposition {
-
-  /*
-   *  Floating point operation to stress the cpu
-   *  Calculate the number of KFLOPS / FLOPS
-   *  implementation of the Cholesky decomposition
-   *  More information on the Cholesky decomposition at: 
-   *  https://en.wikipedia.org/wiki/Cholesky_decomposition
-   *  
-   *  Linpack uses the cholesky decomposition
-   *  https://www.netlib.org/linpack/
-   *
-   *
-   */ 
-
-  def choleskyDecomposition(n: Int): Unit =   {
-
-    for (w <- 0 to n) {
-
-
-    }
-  }
-
-  
-}

src/main/scala/com/nsrddyn/cpu/FPU/FPU.scala

@@ -1,6 +0,0 @@
-package com.nsrddyn
-
-
-class FPU {
-  
-}

src/main/scala/com/nsrddyn/cpu/FPU/Matrix.scala

@@ -1,5 +0,0 @@
-package com.nsrddyn
-
-class Matrix {
-  
-}