Improve DSL

Relate-To: #94, #119

Author: michalharakal

skainet-core/skainet-tensors-api/src/commonMain/kotlin/sk/ainet/core/tensor/TensorFactories.kt

@@ -0,0 +1,22 @@
+package sk.ainet.core.tensor
+
+import kotlin.random.Random
+
+public interface TensorFactory<T: DType, V> {
+    public fun zeros(shape: Shape): Tensor<T, V>
+    public fun ones(shape: Shape): Tensor<T, V>
+    public fun random(shape: Shape): Tensor<T, V>
+    
+    // Advanced random methods with seed control
+    public fun random(shape: Shape, seed: Long): Tensor<T, V>
+    public fun random(shape: Shape, random: Random): Tensor<T, V>
+    
+    // Distribution-based random methods
+    public fun randomNormal(shape: Shape, mean: Double = 0.0, std: Double = 1.0): Tensor<T, V>
+    public fun randomNormal(shape: Shape, mean: Double = 0.0, std: Double = 1.0, seed: Long): Tensor<T, V>
+    public fun randomNormal(shape: Shape, mean: Double = 0.0, std: Double = 1.0, random: Random): Tensor<T, V>
+    
+    public fun randomUniform(shape: Shape, min: Double = 0.0, max: Double = 1.0): Tensor<T, V>
+    public fun randomUniform(shape: Shape, min: Double = 0.0, max: Double = 1.0, seed: Long): Tensor<T, V>
+    public fun randomUniform(shape: Shape, min: Double = 0.0, max: Double = 1.0, random: Random): Tensor<T, V>
+}

skainet-core/skainet-tensors-api/src/commonMain/kotlin/sk/ainet/core/tensor/TensorFactoryProvider.kt

@@ -0,0 +1,65 @@
+package sk.ainet.core.tensor
+
+/**
+ * Provides default TensorFactory instances for supported DType and value type combinations.
+ * This enables automatic factory resolution in DSL contexts without requiring explicit factory parameters.
+ * 
+ * The implementation uses type-based resolution to return the appropriate backend factory.
+ */
+public object DefaultTensorFactories {
+    
+    /**
+     * Internal storage for factory instances to avoid recreating them.
+     */
+    private var fp32Factory: TensorFactory<FP32, Float>? = null
+    private var int8Factory: TensorFactory<Int8, Byte>? = null  
+    private var int32Factory: TensorFactory<Int32, Int>? = null
+    
+    /**
+     * Sets the FP32 factory implementation. This is called by the implementation module.
+     */
+    public fun setFP32Factory(factory: TensorFactory<FP32, Float>) {
+        fp32Factory = factory
+    }
+    
+    /**
+     * Sets the Int8 factory implementation. This is called by the implementation module.
+     */
+    public fun setInt8Factory(factory: TensorFactory<Int8, Byte>) {
+        int8Factory = factory
+    }
+    
+    /**
+     * Sets the Int32 factory implementation. This is called by the implementation module.
+     */
+    public fun setInt32Factory(factory: TensorFactory<Int32, Int>) {
+        int32Factory = factory
+    }
+    
+    /**
+     * Gets the default TensorFactory for FP32/Float combinations.
+     */
+    public fun getFP32Factory(): TensorFactory<FP32, Float> {
+        return fp32Factory ?: throw IllegalStateException(
+            "FP32 factory not initialized. Make sure the tensor implementation module is included."
+        )
+    }
+    
+    /**
+     * Gets the default TensorFactory for Int8/Byte combinations.
+     */
+    public fun getInt8Factory(): TensorFactory<Int8, Byte> {
+        return int8Factory ?: throw IllegalStateException(
+            "Int8 factory not initialized. Make sure the tensor implementation module is included."
+        )
+    }
+    
+    /**
+     * Gets the default TensorFactory for Int32/Int combinations.
+     */
+    public fun getInt32Factory(): TensorFactory<Int32, Int> {
+        return int32Factory ?: throw IllegalStateException(
+            "Int32 factory not initialized. Make sure the tensor implementation module is included."
+        )
+    }
+}

skainet-core/skainet-tensors/src/commonMain/kotlin/sk/ainet/core/tensor/backend/CpuBackend.kt

@@ -1336,6 +1336,67 @@ public class CpuBackend : ComputeBackend<FP32, Float> {
     override fun ones(shape: Shape): Tensor<FP32, Float> {
         return CpuTensorFP32.ones(shape)
     }
+
+    override fun random(shape: Shape): Tensor<FP32, Float> {
+        return CpuTensorFP32.fromArray(shape, FloatArray(shape.volume) { kotlin.random.Random.nextFloat() })
+    }
+
+    override fun random(shape: Shape, seed: Long): Tensor<FP32, Float> {
+        val random = kotlin.random.Random(seed)
+        return CpuTensorFP32.fromArray(shape, FloatArray(shape.volume) { random.nextFloat() })
+    }
+
+    override fun random(shape: Shape, random: kotlin.random.Random): Tensor<FP32, Float> {
+        return CpuTensorFP32.fromArray(shape, FloatArray(shape.volume) { random.nextFloat() })
+    }
+
+    override fun randomNormal(shape: Shape, mean: Double, std: Double): Tensor<FP32, Float> {
+        val random = kotlin.random.Random
+        return CpuTensorFP32.fromArray(shape, FloatArray(shape.volume) { 
+            (generateNormalDistribution(random, mean, std)).toFloat()
+        })
+    }
+
+    override fun randomNormal(shape: Shape, mean: Double, std: Double, seed: Long): Tensor<FP32, Float> {
+        val random = kotlin.random.Random(seed)
+        return CpuTensorFP32.fromArray(shape, FloatArray(shape.volume) { 
+            (generateNormalDistribution(random, mean, std)).toFloat()
+        })
+    }
+
+    override fun randomNormal(shape: Shape, mean: Double, std: Double, random: kotlin.random.Random): Tensor<FP32, Float> {
+        return CpuTensorFP32.fromArray(shape, FloatArray(shape.volume) { 
+            (generateNormalDistribution(random, mean, std)).toFloat()
+        })
+    }
+
+    override fun randomUniform(shape: Shape, min: Double, max: Double): Tensor<FP32, Float> {
+        val random = kotlin.random.Random
+        return CpuTensorFP32.fromArray(shape, FloatArray(shape.volume) { 
+            (random.nextDouble(min, max)).toFloat()
+        })
+    }
+
+    override fun randomUniform(shape: Shape, min: Double, max: Double, seed: Long): Tensor<FP32, Float> {
+        val random = kotlin.random.Random(seed)
+        return CpuTensorFP32.fromArray(shape, FloatArray(shape.volume) { 
+            (random.nextDouble(min, max)).toFloat()
+        })
+    }
+
+    override fun randomUniform(shape: Shape, min: Double, max: Double, random: kotlin.random.Random): Tensor<FP32, Float> {
+        return CpuTensorFP32.fromArray(shape, FloatArray(shape.volume) { 
+            (random.nextDouble(min, max)).toFloat()
+        })
+    }
+
+    private fun generateNormalDistribution(random: kotlin.random.Random, mean: Double, std: Double): Double {
+        // Box-Muller transform for generating normal distribution
+        val u1 = random.nextDouble()
+        val u2 = random.nextDouble()
+        val z0 = sqrt(-2.0 * ln(u1)) * cos(2.0 * PI * u2)
+        return z0 * std + mean
+    }
 }
 
 /**
@@ -1446,6 +1507,64 @@ public class CpuBackendInt8 : ComputeBackend<Int8, Byte> {
 
     override fun ones(shape: Shape): Tensor<Int8, Byte> =
         CpuTensorInt8.ones(shape)
+
+    override fun random(shape: Shape): Tensor<Int8, Byte> =
+        CpuTensorInt8.fromArray(shape, ByteArray(shape.volume) { kotlin.random.Random.nextInt(-128, 128).toByte() })
+
+    override fun random(shape: Shape, seed: Long): Tensor<Int8, Byte> {
+        val random = kotlin.random.Random(seed)
+        return CpuTensorInt8.fromArray(shape, ByteArray(shape.volume) { random.nextInt(-128, 128).toByte() })
+    }
+
+    override fun random(shape: Shape, random: kotlin.random.Random): Tensor<Int8, Byte> =
+        CpuTensorInt8.fromArray(shape, ByteArray(shape.volume) { random.nextInt(-128, 128).toByte() })
+
+    override fun randomNormal(shape: Shape, mean: Double, std: Double): Tensor<Int8, Byte> {
+        val random = kotlin.random.Random
+        return CpuTensorInt8.fromArray(shape, ByteArray(shape.volume) { 
+            generateNormalDistributionInt8(random, mean, std)
+        })
+    }
+
+    override fun randomNormal(shape: Shape, mean: Double, std: Double, seed: Long): Tensor<Int8, Byte> {
+        val random = kotlin.random.Random(seed)
+        return CpuTensorInt8.fromArray(shape, ByteArray(shape.volume) { 
+            generateNormalDistributionInt8(random, mean, std)
+        })
+    }
+
+    override fun randomNormal(shape: Shape, mean: Double, std: Double, random: kotlin.random.Random): Tensor<Int8, Byte> =
+        CpuTensorInt8.fromArray(shape, ByteArray(shape.volume) { 
+            generateNormalDistributionInt8(random, mean, std)
+        })
+
+    override fun randomUniform(shape: Shape, min: Double, max: Double): Tensor<Int8, Byte> {
+        val random = kotlin.random.Random
+        return CpuTensorInt8.fromArray(shape, ByteArray(shape.volume) { 
+            random.nextInt(min.toInt().coerceAtLeast(-128), max.toInt().coerceAtMost(127) + 1).toByte()
+        })
+    }
+
+    override fun randomUniform(shape: Shape, min: Double, max: Double, seed: Long): Tensor<Int8, Byte> {
+        val random = kotlin.random.Random(seed)
+        return CpuTensorInt8.fromArray(shape, ByteArray(shape.volume) { 
+            random.nextInt(min.toInt().coerceAtLeast(-128), max.toInt().coerceAtMost(127) + 1).toByte()
+        })
+    }
+
+    override fun randomUniform(shape: Shape, min: Double, max: Double, random: kotlin.random.Random): Tensor<Int8, Byte> =
+        CpuTensorInt8.fromArray(shape, ByteArray(shape.volume) { 
+            random.nextInt(min.toInt().coerceAtLeast(-128), max.toInt().coerceAtMost(127) + 1).toByte()
+        })
+
+    private fun generateNormalDistributionInt8(random: kotlin.random.Random, mean: Double, std: Double): Byte {
+        // Box-Muller transform for generating normal distribution
+        val u1 = random.nextDouble()
+        val u2 = random.nextDouble()
+        val z0 = sqrt(-2.0 * ln(u1)) * cos(2.0 * PI * u2)
+        val value = (z0 * std + mean).toInt().coerceIn(-128, 127)
+        return value.toByte()
+    }
 }
 
 /**
@@ -1554,4 +1673,61 @@ public class CpuBackendInt32 : ComputeBackend<Int32, Int> {
 
     override fun ones(shape: Shape): Tensor<Int32, Int> =
         CpuTensorInt32.ones(shape)
+
+    override fun random(shape: Shape): Tensor<Int32, Int> =
+        CpuTensorInt32.fromArray(shape, IntArray(shape.volume) { kotlin.random.Random.nextInt() })
+
+    override fun random(shape: Shape, seed: Long): Tensor<Int32, Int> {
+        val random = kotlin.random.Random(seed)
+        return CpuTensorInt32.fromArray(shape, IntArray(shape.volume) { random.nextInt() })
+    }
+
+    override fun random(shape: Shape, random: kotlin.random.Random): Tensor<Int32, Int> =
+        CpuTensorInt32.fromArray(shape, IntArray(shape.volume) { random.nextInt() })
+
+    override fun randomNormal(shape: Shape, mean: Double, std: Double): Tensor<Int32, Int> {
+        val random = kotlin.random.Random
+        return CpuTensorInt32.fromArray(shape, IntArray(shape.volume) { 
+            generateNormalDistributionInt32(random, mean, std)
+        })
+    }
+
+    override fun randomNormal(shape: Shape, mean: Double, std: Double, seed: Long): Tensor<Int32, Int> {
+        val random = kotlin.random.Random(seed)
+        return CpuTensorInt32.fromArray(shape, IntArray(shape.volume) { 
+            generateNormalDistributionInt32(random, mean, std)
+        })
+    }
+
+    override fun randomNormal(shape: Shape, mean: Double, std: Double, random: kotlin.random.Random): Tensor<Int32, Int> =
+        CpuTensorInt32.fromArray(shape, IntArray(shape.volume) { 
+            generateNormalDistributionInt32(random, mean, std)
+        })
+
+    override fun randomUniform(shape: Shape, min: Double, max: Double): Tensor<Int32, Int> {
+        val random = kotlin.random.Random
+        return CpuTensorInt32.fromArray(shape, IntArray(shape.volume) { 
+            random.nextInt(min.toInt(), max.toInt() + 1)
+        })
+    }
+
+    override fun randomUniform(shape: Shape, min: Double, max: Double, seed: Long): Tensor<Int32, Int> {
+        val random = kotlin.random.Random(seed)
+        return CpuTensorInt32.fromArray(shape, IntArray(shape.volume) { 
+            random.nextInt(min.toInt(), max.toInt() + 1)
+        })
+    }
+
+    override fun randomUniform(shape: Shape, min: Double, max: Double, random: kotlin.random.Random): Tensor<Int32, Int> =
+        CpuTensorInt32.fromArray(shape, IntArray(shape.volume) { 
+            random.nextInt(min.toInt(), max.toInt() + 1)
+        })
+
+    private fun generateNormalDistributionInt32(random: kotlin.random.Random, mean: Double, std: Double): Int {
+        // Box-Muller transform for generating normal distribution
+        val u1 = random.nextDouble()
+        val u2 = random.nextDouble()
+        val z0 = sqrt(-2.0 * ln(u1)) * cos(2.0 * PI * u2)
+        return (z0 * std + mean).toInt()
+    }
 }