.gitignore

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

build.sbt

@@ -4,4 +4,3 @@ 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/Enums/Status.scala

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

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

@@ -1,53 +0,0 @@
-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

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

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

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

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

@@ -1,23 +1,20 @@
 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 {
 
-  println("hello world")
+  import java.time.Instant
 
-  @main def main(args: String*): Unit =  {
+  @main def main(args: String*): Unit = 
-    // ANSI ESCAPE CODE: clear screen
-    println("\u001b[2J\u001b[H")
-    println("--- TORQUE STRESS TESTING UTILITY ---")
 
-    var tester: CholeskyDecompositionTest = new CholeskyDecompositionTest
+  // ANSI ESCAPE CODE: clear screen
-    println(tester.test())
+  println("\u001b[2J\u001b[H")
+  println("--- TORQUE STRESS TESTING UTILITY ---")
 
-  }
+  val now: Instant = Instant.now()
+  println(now)
+
+  val pr = new Prime()
+
+  val intMax = 2147483647
+  pr.run(intMax)
 }
-

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

@@ -1,16 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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/ALU/Hash.scala

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

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

@@ -1,9 +1,9 @@
-package com.nsrddyn.alu
+package com.nsrddyn
 
 
-import com.nsrddyn.tools.Benchmark
 
-class Prime() extends Benchmark {
+class Prime() {
+
 
   /*
    * Calculate all primes up to limit
@@ -18,25 +18,11 @@ class Prime() extends Benchmark {
    *
    */
 
-
-  /*
-   * 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, result: Boolean): Unit = {
+  def run(n: Int): Unit = for i <- 0 to n do isPrime(i)
-
-    for i <- 0 to n do if isPrime(i) == result then println("true") else println("false") 
-  }
-
-
 }
 

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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,28 @@
+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

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

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

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