Remove narr (#61)

* remove arr.

* .

* .

* fmt

* .

Author: Quafadas

build.mill

@@ -35,7 +35,6 @@ object V:
   val scalaTags: Dep = mvn"com.lihaoyi::scalatags::0.13.1"
   val scalaVersion = "3.7.2"
   val munitVersion = "1.1.1"
-  val narr: Dep = mvn"ai.dragonfly::narr::1.0"
   val blas: Dep = mvn"dev.ludovic.netlib:blas:3.0.4"
   val lapack: Dep = mvn"dev.ludovic.netlib:lapack:3.0.4"
 end V

experiments/src/cheatsheet.scala

@@ -3,7 +3,6 @@
 
 import vecxt.all.*
 import vecxt.BoundsCheck.DoBoundsCheck.no
-import narr.*
 
 object CheatsheetTest:
 
@@ -12,19 +11,19 @@ object CheatsheetTest:
 
     // Array/Vector Creation and Basic Operations
     println("--- Array/Vector Creation ---")
-    val vec = NArray(1.0, 2.0, 3.0)
+    val vec = Array(1.0, 2.0, 3.0)
     println(s"1D array: ${vec.mkString(", ")}")
 
     println((vec ** 2.0).printArr)
 
-    val mat = Matrix(NArray(1.0, 2.0, 3.0, 4.0, 5.0, 6.0), 2, 3)
+    val mat = Matrix(Array(1.0, 2.0, 3.0, 4.0, 5.0, 6.0), 2, 3)
     println(s"2D matrix shape: ${mat.shape}")
 
     println(svd(mat))
     println(rank(mat))
 
     // QR decomposition
-    val matSquare = Matrix(NArray(1.0, 2.0, 3.0, 4.0), 2, 2)
+    val matSquare = Matrix(Array(1.0, 2.0, 3.0, 4.0), 2, 2)
     val (q, r) = qr(matSquare)
     println(s"Q matrix shape: ${q.shape}")
     println(s"R matrix shape: ${r.shape}")
@@ -43,7 +42,7 @@ object CheatsheetTest:
 
     // Indexing and Slicing
     println("\n--- Indexing and Slicing ---")
-    val m = Matrix(NArray(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0), 3, 3)
+    val m = Matrix(Array(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0), 3, 3)
     val mBig = Matrix.rand(10, 10)
     m.mean
     println("==== m =====")
@@ -65,8 +64,8 @@ object CheatsheetTest:
 
     // Element-wise Operations
     println("\n--- Element-wise Operations ---")
-    val a = NArray(1.0, 2.0, 3.0, 4.0)
-    val b = NArray(2.0, 3.0, 4.0, 5.0)
+    val a = Array(1.0, 2.0, 3.0, 4.0)
+    val b = Array(2.0, 3.0, 4.0, 5.0)
 
     val sum = a + b
     println(s"Element-wise addition: ${sum.mkString(", ")}")
@@ -75,8 +74,8 @@ object CheatsheetTest:
     println(s"Element-wise subtraction: ${diff.mkString(", ")}")
 
     // Element-wise multiply/divide for matrices
-    val mA = Matrix(NArray(1.0, 2.0, 3.0, 4.0), 2, 2)
-    val mB = Matrix(NArray(2.0, 3.0, 4.0, 5.0), 2, 2)
+    val mA = Matrix(Array(1.0, 2.0, 3.0, 4.0), 2, 2)
+    val mB = Matrix(Array(2.0, 3.0, 4.0, 5.0), 2, 2)
     val mProd = mA.hadamard(mB)
     println(s"Element-wise multiply (matrix): shape ${mProd.shape}")
 
@@ -100,8 +99,8 @@ object CheatsheetTest:
 
     // Matrix Operations
     println("\n--- Matrix Operations ---")
-    val m1 = Matrix(NArray(1.0, 2.0, 3.0, 4.0), 2, 2)
-    val m2 = Matrix(NArray(5.0, 6.0, 7.0, 8.0), 2, 2)
+    val m1 = Matrix(Array(1.0, 2.0, 3.0, 4.0), 2, 2)
+    val m2 = Matrix(Array(5.0, 6.0, 7.0, 8.0), 2, 2)
 
     val mneg = -m1
 
@@ -115,7 +114,7 @@ object CheatsheetTest:
     println(s"Determinant: $det")
 
     // Test matrix with scalar operations
-    val m3 = Matrix(NArray(1.0, 2.0, 3.0, 4.0, 5.0, 6.0), 2, 3)
+    val m3 = Matrix(Array(1.0, 2.0, 3.0, 4.0, 5.0, 6.0), 2, 3)
     val m3Scaled = m3 * 2.0
     println(s"Matrix scaled by 2: shape ${m3Scaled.shape}")
 
@@ -167,8 +166,8 @@ object CheatsheetTest:
 
     // Norms and Distances
     println("\n--- Norms and Distances ---")
-    val v1 = NArray(1.0, 2.0, 3.0)
-    val v2 = NArray(4.0, 5.0, 6.0)
+    val v1 = Array(1.0, 2.0, 3.0)
+    val v2 = Array(4.0, 5.0, 6.0)
     val negv2 = -v2
     val cosSim = cosineSimilarity(v1, v2)
     println(s"Cosine similarity: $cosSim")
@@ -193,10 +192,10 @@ object CheatsheetTest:
     val cosResult = a.cos
     println(s"Cosine: ${cosResult.mkString(", ")}")
 
-    val asinResult = NArray(0.5, 0.7, 0.9).asin
+    val asinResult = Array(0.5, 0.7, 0.9).asin
     println(s"Arcsine: ${asinResult.mkString(", ")}")
 
-    val acosResult = NArray(0.5, 0.7, 0.9).acos
+    val acosResult = Array(0.5, 0.7, 0.9).acos
     println(s"Arccosine: ${acosResult.mkString(", ")}")
 
     val atanResult = a.atan
@@ -228,8 +227,8 @@ object CheatsheetTest:
 
     // Logical Operations
     println("\n--- Logical Operations ---")
-    val intArr1 = NArray(1, 2, 3, 4, 5)
-    val intArr2 = NArray(3, 2, 3, 1, 6)
+    val intArr1 = Array(1, 2, 3, 4, 5)
+    val intArr2 = Array(3, 2, 3, 1, 6)
 
     val gtResult = intArr1 > intArr2
     println(s"Greater than: ${gtResult.mkString(", ")}")
@@ -249,8 +248,8 @@ object CheatsheetTest:
     val neqResult = intArr1 !:= intArr2
     println(s"Inequality: ${neqResult.mkString(", ")}")
 
-    val boolArr = NArray(true, false, true, false, true)
-    val boolArr2 = NArray(false, false, true, true, false)
+    val boolArr = Array(true, false, true, false, true)
+    val boolArr2 = Array(false, false, true, true, false)
 
     not(boolArr2)
 
@@ -266,17 +265,17 @@ object CheatsheetTest:
     val diagVals = m.diag
     println(s"Diagonal: ${diagVals.mkString(", ")}")
 
-    val uniqueVals = NArray(1.0, 2.0, 2.0, 3.0, 3.0, 3.0, 4.0).unique
+    val uniqueVals = Array(1.0, 2.0, 2.0, 3.0, 3.0, 3.0, 4.0).unique
     println(s"Unique values: ${uniqueVals.mkString(", ")}")
 
-    val toSort = NArray(3.0, 1.0, 4.0, 1.0, 5.0)
-    val sorted = narr.copy(toSort)
-    narr.sort(sorted)()
+    val toSort = Array(3.0, 1.0, 4.0, 1.0, 5.0)
+    val sorted = toSort.clone()
+    scala.util.Sorting.quickSort(sorted)
     println(s"Sorted: ${sorted.mkString(", ")}")
 
     // Special Operations
     println("\n--- Special Operations ---")
-    val copied = narr.copy(a)
+    val copied = a.clone()
     println(s"Copied array: ${copied.mkString(", ")}")
 
     val increments = intArr1.increments

experiments/src/mnist.scala

@@ -9,7 +9,6 @@ import vecxt.all.*
 import vecxt.BoundsCheck.DoBoundsCheck.yes
 import vecxt.BoundsCheck
 import scala.reflect.ClassTag
-import narr.*
 
 // File can be dowloaded from Kaggle at:
 // https://www.kaggle.com/datasets/quangphota/mnist-csv/data?select=train.csv
@@ -187,7 +186,7 @@ def back_prop(
 end back_prop
 
 inline def oneHot[T](int: Int, numClasses: Int)(using ct: ClassTag[T], f: Numeric[T]): Array[T] =
-  val arr = NArray.fill[T](numClasses)(f.zero)
+  val arr = Array.fill[T](numClasses)(f.zero)
   if int >= 0 && int < numClasses then arr(int) = f.one
   end if
   arr

readme.md

@@ -6,16 +6,10 @@ Freeing you from the tyranny of having to choose which platform you write your c
 
 ## What is it?
 
-Aims to provide convienent and intuitive syntax for vector computations with best-in-class inline-shim-to-BLAS performance.
+Aims to provide convienent and intuitive syntax for vector computations with best-in-class inline-shim-to-BLAS performance on native and JVM. JS... is waiting for WebAssembly BLAS.
 
 ||JVM|JS|Native|
 ----|----|----|----|
-Data structure| `Array[Double]` | `Float64Array` | `Array[Double]` |
+Data structure| `Array[Double]` | `Array[Double]` | `Array[Double]` |
 Shims to | https://github.com/luhenry/netlib | https://github.com/stdlib-js/blas | [CBLAS](https://github.com/ekrich/sblas) |
 
-## Didn't you say "cross platform"?
-
-This is a very neat piece of work.
-https://github.com/dragonfly-ai/narr
-
-

site/TODO/benchmarks/performance.md

@@ -11,7 +11,7 @@ In general cross platform performance is a hard problem. We sidestep where possi
 
 ||JVM|JS|Native|Cross|
 ----|----|----|----|---|
-Data structure| `Array[Double]` | `Float64Array` | `Array[Double]` |`NArray[Double]` |
+Data structure| `Array[Double]` | `Float64Array` | `Array[Double]` |`Array[Double]` |
 Shims to | https://github.com/luhenry/netlib | https://github.com/stdlib-js/blas | [CBLAS](https://github.com/ekrich/sblas) | Best available |
 
 Consider browsing the [[vecxt]] api, and particulaly the extensions object. You'll see that most definitions are `@inline` anotated - i.e. there is zero runtime overhead calling this library, and checkout the [benchmarks](benchmarks/sum.md)

site/docs/blog/2024-08-01-Motivation.md

@@ -22,10 +22,10 @@ For example if your data acquisition is serverside, but do parts of a calculatio
 ```scala mdoc
 
 import vecxt.all.*
-import narr.*
+
 import vecxt.BoundsCheck.DoBoundsCheck.yes
 
-def algo(a: NArray[Double], b :NArray[Double], c: Double ) = (a + b)  / c
+def algo(a: Array[Double], b :Array[Double], c: Double ) = (a + b)  / c
 
 val a = Array[Double](1, 2, 3)
 val b = Array[Double](4, 5, 6)

site/docs/blog/2025-06-23-Linear_Algebra_On_the_JVM.md

@@ -72,7 +72,7 @@ So okay... I'm totally a sucker for punishment. We need zero copy transpose - ho
 
 ```scala sc:nocompile
   class Matrix[A] (
-      val raw: NArray[A],
+      val raw: Array[A],
       val rows: Row,
       val cols: Col,
       val rowStride: Int,

site/docs/cheatsheet.md

@@ -7,7 +7,7 @@ This cheatsheet compares common linear algebra operations across vecxt (Scala 3)
 ```scala
 //> using scala 3.7.3 // or greater
 import vecxt.all.{*, given}
-import narr.*
+
 
 ```
 

site/docs/examples.md

@@ -103,10 +103,10 @@ And Ints. Note that the API here is more limited at the moment.
 
 ```scala mdoc:reset
 import vecxt.all.{*, given}
-import narr.*
 
-val v1 = NArray(1, 2, 3)
-val v2 = NArray(4, 5, 6)
+
+val v1 = Array(1, 2, 3)
+val v2 = Array(4, 5, 6)
 
 
 v1.dot(v2)
@@ -131,11 +131,11 @@ The library includes methods for calculating Tail Value at Risk (TVaR) and Value
 
 ```scala mdoc:reset
 import vecxt.all.{*, given}
-import narr.*
+
 import vecxt.reinsurance.*
 
 // Create a sample loss distribution
-val losses = NArray[Double](10.0, 25.0, 15.0, 50.0, 5.0, 30.0, 20.0, 8.0, 45.0, 12.0)
+val losses = Array[Double](10.0, 25.0, 15.0, 50.0, 5.0, 30.0, 20.0, 8.0, 45.0, 12.0)
 
 // Calculate Value at Risk (VaR) at 90% confidence level
 // VaR represents the threshold value - 90% of losses are above this value
@@ -152,7 +152,7 @@ val varValue = result.VaR
 val tvarValue = result.TVaR
 
 // Calculate multiple confidence levels at once (most efficient for batch analysis)
-val alphas = NArray[Double](0.85, 0.90, 0.95, 0.99)
+val alphas = Array[Double](0.85, 0.90, 0.95, 0.99)
 val results = losses.tVarWithVaRBatch(alphas)
 // Each result contains (cl, VaR, TVaR)
 results(0).cl   // Confidence level for first alpha
@@ -165,8 +165,8 @@ val tailMask = losses.tVarIdx(0.90)
 
 // Calculate tail dependence between two distributions
 // Measures how often extreme values occur together
-val losses1 = NArray[Double](5.0, 10.0, 15.0, 20.0, 25.0, 30.0, 35.0, 40.0, 45.0, 50.0)
-val losses2 = NArray[Double](8.0, 12.0, 18.0, 22.0, 28.0, 32.0, 38.0, 42.0, 48.0, 52.0)
+val losses1 = Array[Double](5.0, 10.0, 15.0, 20.0, 25.0, 30.0, 35.0, 40.0, 45.0, 50.0)
+val losses2 = Array[Double](8.0, 12.0, 18.0, 22.0, 28.0, 32.0, 38.0, 42.0, 48.0, 52.0)
 val tailDep = losses1.qdep(0.90, losses2)
 // Returns proportion of tail observations that are shared (0.0 to 1.0)
 

site/docs/higherkinded.md

@@ -17,7 +17,7 @@ import scala.reflect.ClassTag
 import vecxt.*
 import vecxt.all.*
 import vecxt.BoundsCheck.BoundsCheck
-import narr.*
+
 import BoundsCheck.DoBoundsCheck.yes
 
 // A very naive matrix multiplication implementation...
@@ -31,7 +31,7 @@ object SpireExt:
       val (r1, c1) = m1.shape
       val (r2, c2) = m2.shape
 
-      val nar = NArray.ofSize[A](r1 * c2)
+      val nar = Array.ofDim[A](r1 * c2)
       val res = Matrix(nar, (r1, c2))
 
       for i <- 0 until r1 do
@@ -66,14 +66,14 @@ import SpireExt.*
 
 // That would work with complex numbers
 val mat1 = Matrix.fromRows[Complex[Double]](
-  NArray[Complex[Double]](Complex(1.0, -1.0), Complex(0.0, 2.0), Complex(-2.0, 1.0)),
-  NArray[Complex[Double]](Complex(0.0, -3.0), Complex(3.0, -2.0), Complex(-1.0, -1.0))
+  Array[Complex[Double]](Complex(1.0, -1.0), Complex(0.0, 2.0), Complex(-2.0, 1.0)),
+  Array[Complex[Double]](Complex(0.0, -3.0), Complex(3.0, -2.0), Complex(-1.0, -1.0))
 )
 
 val mat2 = Matrix.fromRows[Complex[Double]](
-  NArray[Complex[Double]](Complex(0.0, -2.0), Complex(1.0, -4.0)),
-  NArray[Complex[Double]](Complex(-1.0, 3.0), Complex(2.0, -3.0)),
-  NArray[Complex[Double]](Complex(-2.0, 1.0), Complex(-4.0, 1.0))
+  Array[Complex[Double]](Complex(0.0, -2.0), Complex(1.0, -4.0)),
+  Array[Complex[Double]](Complex(-1.0, 3.0), Complex(2.0, -3.0)),
+  Array[Complex[Double]](Complex(-2.0, 1.0), Complex(-4.0, 1.0))
 )
 
 println(mat1.showMat)