env and parse int functions, more linalg (#189)

* Replace columns

* Add new functions

* More to linalg

benchmarks/linalg/main.py

@@ -0,0 +1,28 @@
+import numpy as np
+import os
+
+# read n from N env
+n = int(os.environ.get('N', 10))
+
+# Define Hilbert matrix A
+A = np.array([[1.0 / (i + j + 1) for j in range(0, n)] for i in range(0, n)])
+
+# Define vector b
+b = np.ones(n)
+
+# Solve Ax = b
+x = np.linalg.solve(A, b)
+
+# # Round to nearest integer
+# x = np.round(x)
+
+# # Make it a vector of integers
+# x = x.astype(int)
+
+# Print vertically for easier reading
+print("Solution for x:")
+for i in range(0, n):
+    print(x[i])
+
+print("Check Ax = b")
+print(A @ x)

benchmarks/linalg/linalg/src/main.ppl → benchmarks/linalg/src/main.ppl

@@ -243,11 +243,52 @@ fn gauss <a_: Matrix> <b_: Matrix> -> Matrix:
 
 	return b
 
+type MutColumnSlice:
+	column: Integer
+	matrix: &mut Matrix
+
+fn <column: Integer> column of <matrix: &mut Matrix> -> MutColumnSlice:
+	return MutColumnSlice { matrix, column }
+
+fn <slice: MutColumnSlice> [ <row: Integer> ] -> &mut Rational:
+	let i = row * slice.matrix.columns + slice.column
+	return slice.matrix.data[i]
+
+type ColumnSlice:
+	column: Integer
+	matrix: &Matrix
+
+fn <column: Integer> column of <matrix: &Matrix> -> ColumnSlice:
+	return ColumnSlice { matrix, column }
+
+fn <slice: ColumnSlice> [ <row: Integer> ] -> &Rational:
+	let i = row * slice.matrix.columns + slice.column
+	return slice.matrix.data[i]
+
+fn ColumnSlice from <slice: MutColumnSlice> -> ColumnSlice:
+	return ColumnSlice { column: slice.column, matrix: slice.matrix }
+
+fn replace <dst: MutColumnSlice> with <src: ColumnSlice>:
+	assert dst.matrix.rows == src.matrix.rows "Can't replace columns of different lengths"
+	let n = dst.matrix.rows
+	let mut i = 0
+	while i < n:
+		dst[i] = src[i]
+		i += 1
+
+fn replace <dst: MutColumnSlice> with <src: MutColumnSlice>:
+	replace dst with (ColumnSlice from src)
+
+fn replace <dst: MutColumnSlice> with <src: Matrix>:
+	assert src.columns == 1 "Can't replace column with matrix"
+	replace dst with (0 column of src)
+
 fn run code:
-	let mut a = 3 x 3 Hilbert Matrix
-// println (det a)
-	let mut b = Vector from (repeat 1.0 3 times)
-	let x = gauss (copy of a) (copy of b) 
+	let n = Integer from (env "N")
+	let mut a = n x n Hilbert Matrix
+	let mut b = Vector from (repeat 1.0 n times)
+	let x = gauss (copy of a) b
+	println x
 	println a * x
 
 run code

benchmarks/linalg/test.py

@@ -0,0 +1,4 @@
+ns = [i * 5 for i in range(1, 20)]
+for n in ns:
+    # run `N={n} hyperfine --warmup 3 ./target/linalg.out`
+    # run `N={n} hyperfine --warmup 3 "python3 main.py"`

benchmarks/linalg/times.csv

@@ -0,0 +1,6 @@
+n  ,ppl_ms,python_ms,haskel_ms
+ 5 ,58.7
+10 ,70.2
+15 ,  
+20 ,  
+25 ,  

ppl/src/core.ppl

@@ -119,6 +119,10 @@ fn <x: Integer> % <y: Integer> -> Integer
 @mangle_as("integer_as_string")
 fn String from <:Integer> -> String
 
+/// Parse `Integer` from `String`
+@mangle_as("integer_from_string")
+fn Integer from <str: &String> -> Integer
+
 @mangle_as("destroy_integer")
 fn destroy <:&mut Integer>
 

ppl/src/env.ppl

@@ -0,0 +1,4 @@
+use core.*
+
+@mangle_as("env")
+fn env <:&String> -> String

ppl/src/lib.ppl

@@ -8,4 +8,5 @@ use memory.*
 use threads.*
 use math.*
 use printable.*
-use swap.*
+use swap.*
+use env.*

src/driver/execute/run.rs

@@ -1,6 +1,3 @@
-use cmd_lib::run_cmd;
-use miette::miette;
-
 use crate::driver::commands::{Build, Run};
 
 use super::Execute;
@@ -11,7 +8,7 @@ impl Execute for Run {
     /// Build and run the project
     fn execute(&self) -> Self::Output {
         let exe = Build::default().execute()?;
-        run_cmd!($exe).map_err(|e| miette!("{e}"))?;
+        std::process::Command::new(exe).status().unwrap();
         Ok(())
     }
 }

src/runtime/src/env.rs

@@ -0,0 +1,11 @@
+use crate::String;
+
+/// # PPL
+/// ```no_run
+/// @mangle_as("env")
+/// fn env <:&String> -> String
+/// ```
+#[no_mangle]
+pub extern "C" fn env(name: &String) -> String {
+    std::env::var(name.as_ref()).unwrap_or_default().into()
+}

src/runtime/src/integer.rs

@@ -273,3 +273,15 @@ pub extern "C" fn integer_as_i32(x: Integer) -> i32 {
         .to_i32()
         .expect(&format!("Integer `{integer}` is too big to fit into i32"))
 }
+
+/// # PPL
+/// ```no_run
+/// /// Parse `Integer` from `String`
+/// @mangle_as("integer_from_string")
+/// fn Integer from <str: &String> -> Integer
+/// ```
+#[no_mangle]
+pub extern "C" fn integer_from_string(str: &String) -> Integer {
+    let str = str.as_ref();
+    str.parse::<rug::Integer>().unwrap().into()
+}

src/runtime/src/lib.rs

@@ -21,3 +21,6 @@ pub use r#type::*;
 
 mod assert;
 pub use assert::*;
+
+mod env;
+pub use env::*;

src/tests/snapshots/ppl__tests__array.hir.snap

@@ -29,8 +29,8 @@ while `<:Integer> <= <:Integer>`(`clone <:Reference<Integer>>`((i:Integer)), 10)
 
 
 fn<Integer> size of <ty: Type<Integer>> -> Integer:
-	let $tmp@4586: Integer = `clone <:Reference<Integer>>`((ty:Type<Integer>).size)
-	return ($tmp@4586:Integer)
+	let $tmp@4697: Integer = `clone <:Reference<Integer>>`((ty:Type<Integer>).size)
+	return ($tmp@4697:Integer)
 
 
 fn<Integer> allocate <n: Integer> <$arg1: Type<Integer>> -> MemoryAddress:
@@ -76,13 +76,13 @@ fn<Integer> <array: Reference<Array<Integer>>> is empty -> Bool:
 
 
 fn<Integer> size of <ty: Type<Integer>> -> Integer:
-	let $tmp@4586: Integer = `clone <:Reference<Integer>>`((ty:Type<Integer>).size)
-	return ($tmp@4586:Integer)
+	let $tmp@4697: Integer = `clone <:Reference<Integer>>`((ty:Type<Integer>).size)
+	return ($tmp@4697:Integer)
 
 
 fn<Integer> size of <ty: Type<Integer>> -> Integer:
-	let $tmp@4586: Integer = `clone <:Reference<Integer>>`((ty:Type<Integer>).size)
-	return ($tmp@4586:Integer)
+	let $tmp@4697: Integer = `clone <:Reference<Integer>>`((ty:Type<Integer>).size)
+	return ($tmp@4697:Integer)
 
 
 fn<Integer> allocate <n: Integer> <$arg1: Type<Integer>> -> MemoryAddress:
@@ -151,8 +151,8 @@ fn<Integer> <array: Reference<Array<Integer>>> is not empty -> Bool:
 
 
 fn<Integer> size of <ty: Type<Integer>> -> Integer:
-	let $tmp@4586: Integer = `clone <:Reference<Integer>>`((ty:Type<Integer>).size)
-	return ($tmp@4586:Integer)
+	let $tmp@4697: Integer = `clone <:Reference<Integer>>`((ty:Type<Integer>).size)
+	return ($tmp@4697:Integer)
 
 
 @mangle_as("read_memory")
@@ -197,13 +197,13 @@ fn <x: Integer> <= <y: Integer> -> Bool:
 
 
 fn<Integer> size of <ty: Type<Integer>> -> Integer:
-	let $tmp@4586: Integer = `clone <:Reference<Integer>>`((ty:Type<Integer>).size)
-	return ($tmp@4586:Integer)
+	let $tmp@4697: Integer = `clone <:Reference<Integer>>`((ty:Type<Integer>).size)
+	return ($tmp@4697:Integer)
 
 
 fn<Integer> size of <ty: Type<Integer>> -> Integer:
-	let $tmp@4586: Integer = `clone <:Reference<Integer>>`((ty:Type<Integer>).size)
-	return ($tmp@4586:Integer)
+	let $tmp@4697: Integer = `clone <:Reference<Integer>>`((ty:Type<Integer>).size)
+	return ($tmp@4697:Integer)
 
 
 fn<Integer> allocate <n: Integer> <$arg1: Type<Integer>> -> MemoryAddress:

src/tests/snapshots/ppl__tests__array.ir.snap

@@ -272,9 +272,9 @@ define private %Integer @"size of <:Type<Integer>>"(%"Type<Integer>" %0) !dbg !5
   store %"Type<Integer>" %0, ptr %ty, align 8
   %size = getelementptr inbounds %"Type<Integer>", ptr %ty, i32 0, i32 1, !dbg !51
   %2 = call %Integer @clone_integer(ptr %size), !dbg !51
-  %"$tmp@4586" = alloca %Integer, align 8, !dbg !51
-  store %Integer %2, ptr %"$tmp@4586", align 8, !dbg !51
-  %3 = load %Integer, ptr %"$tmp@4586", align 8, !dbg !51
+  %"$tmp@4697" = alloca %Integer, align 8, !dbg !51
+  store %Integer %2, ptr %"$tmp@4697", align 8, !dbg !51
+  %3 = load %Integer, ptr %"$tmp@4697", align 8, !dbg !51
   store %Integer %3, ptr %return_value, align 8, !dbg !51
   br label %return, !dbg !51
 

src/tests/snapshots/ppl__tests__candidate_not_viable.error.snap

@@ -39,12 +39,12 @@ Advice:   ☞ candidate is not viable
         × expected `Rational` type, got `Integer`
 
       Error:   × Rational
-           ╭─[core.ppl:152:19]
-       151 │ @mangle_as("rational_plus_rational")
-       152 │ fn <:Rational> + <:Rational> -> Rational
+           ╭─[core.ppl:156:19]
+       155 │ @mangle_as("rational_plus_rational")
+       156 │ fn <:Rational> + <:Rational> -> Rational
            ·                   ▲
            ·                   ╰── this has `Rational` type
-       153 │
+       157 │
            ╰────
       Error:   × Integer
          ╭─[main.ppl:1:7]
@@ -59,12 +59,12 @@ Advice:   ☞ candidate is not viable
         × expected `String` type, got `Rational`
 
       Error:   × String
-           ╭─[core.ppl:187:5]
-       186 │ @mangle_as("string_plus_string")
-       187 │ fn <:String> + <:String> -> String
+           ╭─[core.ppl:191:5]
+       190 │ @mangle_as("string_plus_string")
+       191 │ fn <:String> + <:String> -> String
            ·     ▲
            ·     ╰── this has `String` type
-       188 │
+       192 │
            ╰────
       Error:   × Rational
          ╭─[main.ppl:1:1]

src/tests/snapshots/ppl__tests__empty_constructor.hir.snap

@@ -10,13 +10,13 @@ let a: A = A {  }
 
 
 fn<A> type of <$arg0: A> -> Type<A>:
-	let $tmp@4643: Type<A> = (copy Type<A>:Type<A>)
-	return ($tmp@4643:Type<A>)
+	let $tmp@4754: Type<A> = (copy Type<A>:Type<A>)
+	return ($tmp@4754:Type<A>)
 
 
 fn<A> String from <ty: Type<A>> -> String:
-	let $tmp@4518: String = `clone <:Reference<String>>`((ty:Type<A>).name)
-	return ($tmp@4518:String)
+	let $tmp@4629: String = `clone <:Reference<String>>`((ty:Type<A>).name)
+	return ($tmp@4629:String)
 
 
 fn println <x: Type<A>> -> None:

src/tests/snapshots/ppl__tests__empty_constructor.ir.snap

@@ -154,9 +154,9 @@ define private %String @"String from <:Type<A>>"(%"Type<A>" %0) !dbg !29 {
   store %"Type<A>" %0, ptr %ty, align 8
   %name = getelementptr inbounds %"Type<A>", ptr %ty, i32 0, i32 0, !dbg !30
   %2 = call %String @clone_string(ptr %name), !dbg !30
-  %"$tmp@4518" = alloca %String, align 8, !dbg !30
-  store %String %2, ptr %"$tmp@4518", align 8, !dbg !30
-  %3 = load %String, ptr %"$tmp@4518", align 8, !dbg !30
+  %"$tmp@4629" = alloca %String, align 8, !dbg !30
+  store %String %2, ptr %"$tmp@4629", align 8, !dbg !30
+  %3 = load %String, ptr %"$tmp@4629", align 8, !dbg !30
   store %String %3, ptr %return_value, align 8, !dbg !30
   br label %return, !dbg !30
 
@@ -174,9 +174,9 @@ define private %"Type<A>" @"type of <:A>"(ptr %0) !dbg !31 {
   %"$arg0" = alloca ptr, align 8
   store ptr %0, ptr %"$arg0", align 8
   %2 = load %"Type<A>", ptr @"Type<A>", align 8, !dbg !32
-  %"$tmp@4643" = alloca %"Type<A>", align 8, !dbg !32
-  store %"Type<A>" %2, ptr %"$tmp@4643", align 8, !dbg !32
-  %3 = load %"Type<A>", ptr %"$tmp@4643", align 8, !dbg !32
+  %"$tmp@4754" = alloca %"Type<A>", align 8, !dbg !32
+  store %"Type<A>" %2, ptr %"$tmp@4754", align 8, !dbg !32
+  %3 = load %"Type<A>", ptr %"$tmp@4754", align 8, !dbg !32
   store %"Type<A>" %3, ptr %return_value, align 8, !dbg !32
   br label %return, !dbg !32
 

src/tests/snapshots/ppl__tests__memory.hir.snap

@@ -13,8 +13,8 @@ let x: ReferenceMut<Integer> = `<:Type<Integer>> at <:Reference<MemoryAddress>>`
 
 
 fn<Integer> size of <ty: Type<Integer>> -> Integer:
-	let $tmp@4586: Integer = `clone <:Reference<Integer>>`((ty:Type<Integer>).size)
-	return ($tmp@4586:Integer)
+	let $tmp@4697: Integer = `clone <:Reference<Integer>>`((ty:Type<Integer>).size)
+	return ($tmp@4697:Integer)
 
 
 fn<Integer> allocate <n: Integer> <$arg1: Type<Integer>> -> MemoryAddress:

src/tests/snapshots/ppl__tests__memory.ir.snap

@@ -183,9 +183,9 @@ define private %Integer @"size of <:Type<Integer>>"(%"Type<Integer>" %0) !dbg !3
   store %"Type<Integer>" %0, ptr %ty, align 8
   %size = getelementptr inbounds %"Type<Integer>", ptr %ty, i32 0, i32 1, !dbg !40
   %2 = call %Integer @clone_integer(ptr %size), !dbg !40
-  %"$tmp@4586" = alloca %Integer, align 8, !dbg !40
-  store %Integer %2, ptr %"$tmp@4586", align 8, !dbg !40
-  %3 = load %Integer, ptr %"$tmp@4586", align 8, !dbg !40
+  %"$tmp@4697" = alloca %Integer, align 8, !dbg !40
+  store %Integer %2, ptr %"$tmp@4697", align 8, !dbg !40
+  %3 = load %Integer, ptr %"$tmp@4697", align 8, !dbg !40
   store %Integer %3, ptr %return_value, align 8, !dbg !40
   br label %return, !dbg !40
 

src/tests/snapshots/ppl__tests__ppl.hir.snap

@@ -12,3 +12,4 @@ use threads.*
 use math.*
 use printable.*
 use swap.*
+use env.*

src/tests/snapshots/ppl__tests__ppl.ir.snap

@@ -106,14 +106,14 @@ return:                                           ; preds = %0
 !0 = !{i32 2, !"Debug Info Version", i32 3}
 !1 = distinct !DICompileUnit(language: DW_LANG_C, file: !2, producer: "ppl", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, sysroot: "/")
 !2 = !DIFile(filename: "/Users/gavrilikhin_d/Code/ppl/ppl/src/lib.ppl", directory: ".")
-!3 = distinct !DISubprogram(name: "initialize", linkageName: "initialize", scope: !2, file: !2, line: 10, type: !4, spFlags: DISPFlagDefinition, unit: !1)
+!3 = distinct !DISubprogram(name: "initialize", linkageName: "initialize", scope: !2, file: !2, line: 11, type: !4, spFlags: DISPFlagDefinition, unit: !1)
 !4 = !DISubroutineType(types: !5)
 !5 = !{!6}
 !6 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_signed)
-!7 = !DILocation(line: 10, column: 10, scope: !3)
+!7 = !DILocation(line: 11, column: 9, scope: !3)
 !8 = !DILocation(line: 0, scope: !3)
-!9 = distinct !DISubprogram(name: "initialize.1", linkageName: "initialize.1", scope: !2, file: !2, line: 10, type: !4, spFlags: DISPFlagDefinition, unit: !1)
-!10 = !DILocation(line: 10, column: 10, scope: !9)
+!9 = distinct !DISubprogram(name: "initialize.1", linkageName: "initialize.1", scope: !2, file: !2, line: 11, type: !4, spFlags: DISPFlagDefinition, unit: !1)
+!10 = !DILocation(line: 11, column: 9, scope: !9)
 !11 = !DILocation(line: 0, scope: !9)
 !12 = distinct !DISubprogram(name: "initialize.2", linkageName: "initialize.2", scope: !2, file: !2, line: 6, type: !4, spFlags: DISPFlagDefinition, unit: !1)
 !13 = !DILocation(line: 6, column: 6, scope: !12)
@@ -122,6 +122,6 @@ return:                                           ; preds = %0
 !16 = !DILocation(line: 6, column: 1, scope: !15)
 !17 = !DILocation(line: 0, scope: !15)
 !18 = distinct !DISubprogram(name: "lib.execute", linkageName: "lib.execute", scope: !2, file: !2, type: !4, spFlags: DISPFlagDefinition, unit: !1)
-!19 = !DILocation(line: 10, column: 10, scope: !18)
+!19 = !DILocation(line: 11, column: 9, scope: !18)
 !20 = !DILocation(line: 6, column: 6, scope: !18)
 !21 = !DILocation(line: 6, column: 1, scope: !18)

src/tests/snapshots/ppl__tests__references.hir.snap

@@ -16,8 +16,8 @@ let value: ReferenceMut<I32> = `<:Type<I32>> at <:Reference<MemoryAddress>>`((co
 
 
 fn<I32> size of <ty: Type<I32>> -> Integer:
-	let $tmp@4586: Integer = `clone <:Reference<Integer>>`((ty:Type<I32>).size)
-	return ($tmp@4586:Integer)
+	let $tmp@4697: Integer = `clone <:Reference<Integer>>`((ty:Type<I32>).size)
+	return ($tmp@4697:Integer)
 
 
 @mangle_as("read_memory")