Added scal, copy, swap; Updated axpy

src/__init__.mojo

@@ -1,3 +1,6 @@
-from .level1.iamax_device import *
-from .level1.dot_device import *
 from .level1.axpy_device import *
+from .level1.scal_device import *
+from .level1.copy_device import *
+from .level1.swap_device import *
+from .level1.dot_device import *
+from .level1.iamax_device import *

src/level1/__init__.mojo

@@ -1,3 +1,6 @@
-from .iamax_device import *
+from .axpy_device import *
+from .scal_device import *
+from .copy_device import *
+from .swap_device import *
 from .dot_device import *
-from .axpy_device import *
+from .iamax_device import *

src/level1/axpy_device.mojo

@@ -1,21 +1,30 @@
-from gpu import thread_idx
+from gpu import grid_dim, block_dim, global_idx
 
 fn axpy_device[dtype: DType](
     n: Int, 
-    sa: SIMD[dtype, 1],
-    sx: UnsafePointer[SIMD[dtype, 1], ImmutAnyOrigin],
+    a: Scalar[dtype],
+    x: UnsafePointer[Scalar[dtype], ImmutAnyOrigin],
     incx: Int,
-    sy: UnsafePointer[SIMD[dtype, 1], MutAnyOrigin],
+    y: UnsafePointer[Scalar[dtype], MutAnyOrigin],
     incy: Int
 ):
-    var thread_id: UInt = thread_idx.x
-
     if (n <= 0):
         return
-    if (sa == 0):
+    if (a == 0):
         return
     if (incx == 0 or incy == 0):
         return
 
-    if (thread_id < n):
-        sy[thread_id*incy] += sa*sx[thread_id*incx]
+    var global_i = global_idx.x
+    var n_threads = Int(grid_dim.x * block_dim.x)
+
+    if (n <= n_threads):
+        # Standard case: each thread gets 1 cell
+        if (global_i < n):
+            y[global_i*incy] += a * x[global_i*incx]
+
+    else:
+        # Multiple cells per thread
+        for i in range(global_i, n, n_threads):
+            y[i*incy] += a * x[i*incx]
+

src/level1/copy_device.mojo

@@ -0,0 +1,26 @@
+from gpu import grid_dim, block_dim, global_idx
+
+fn copy_device[dtype: DType](
+    n: Int,
+    x: UnsafePointer[Scalar[dtype], ImmutAnyOrigin],
+    incx: Int,
+    y: UnsafePointer[Scalar[dtype], MutAnyOrigin],
+    incy: Int
+):
+    if (n <= 0):
+        return
+    if (incx == 0 or incy == 0):
+        return
+
+    var global_i = global_idx.x
+    var n_threads = Int(grid_dim.x * block_dim.x)
+
+    if (n <= n_threads):
+        # Standard case: each thread gets 1 cell
+        if (global_i < n):
+            y[global_i*incy] = x[global_i*incx]
+
+    else:
+        # Multiple cells per thread
+        for i in range(global_i, n, n_threads):
+            y[i*incy] = x[i*incx]

src/level1/scal_device.mojo

@@ -0,0 +1,28 @@
+from gpu import grid_dim, block_dim, global_idx
+
+fn scal_device[dtype: DType](
+    n: Int, 
+    a: Scalar[dtype],
+    x: UnsafePointer[Scalar[dtype], MutAnyOrigin],
+    incx: Int,
+):
+    if (n <= 0):
+        return
+    if (a == 0):
+        return
+    if (incx == 0):
+        return
+
+    var global_i = global_idx.x
+    var n_threads = Int(grid_dim.x * block_dim.x)
+
+    if (n <= n_threads):
+        # Standard case: each thread gets 1 cell
+        if (global_i < n):
+            x[global_i*incx] *= a
+
+    else:
+        # Multiple cells per thread
+        for i in range(global_i, n, n_threads):
+            x[i*incx] *= a
+

src/level1/swap_device.mojo

@@ -0,0 +1,30 @@
+from gpu import grid_dim, block_dim, global_idx
+
+fn swap_device[dtype: DType](
+    n: Int,
+    x: UnsafePointer[Scalar[dtype], MutAnyOrigin],
+    incx: Int,
+    y: UnsafePointer[Scalar[dtype], MutAnyOrigin],
+    incy: Int
+):
+    if (n <= 0):
+        return
+    if (incx == 0 or incy == 0):
+        return
+
+    var global_i = global_idx.x
+    var n_threads = Int(grid_dim.x * block_dim.x)
+
+    if (n <= n_threads):
+        # Standard case: each thread gets 1 cell
+        if (global_i < n):
+            var tmp = x[global_i * incx]
+            x[global_i * incx] = y[global_i * incy]
+            y[global_i * incy] = tmp
+
+    else:
+        # Multiple cells per thread
+        for i in range(global_i, n, n_threads):
+            var tmp = x[i * incx]
+            x[i * incx] = y[i * incy]
+            y[i * incy] = tmp