Merge branch 'main' into backend_lpython

Author: khushi-411

.github/workflows/CI.yml

@@ -437,7 +437,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.9", "3.10", "3.11"]
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
     steps:
       - uses: actions/checkout@v3
         with:

.gitignore

@@ -73,6 +73,10 @@ integration_tests/b5/*
 integration_tests/b6/*
 integration_tests/_lpython-tmp-test-*
 inst/bin/*
+*.clj
+pass_fortran_*.f90
+pass_json_*.json
+pass_tree_*.txt
 *.tmp
 *.tlog
 *.filters

README.md

@@ -29,7 +29,6 @@ LFortran, see that project for a list of sponsors.
 
 Here is the list of requirements needed to build LPython:
 
-- Python (3.10+)
 - Conda
 
 For Windows, these are additionally required:
@@ -111,6 +110,10 @@ Please follow the below steps for Windows:
 - Generate prerequisite files; build in Debug Mode:
 
   ```bash
+  # if you are developing on top of a forked repository; please run following command first
+  # ./generate_default_tag.sh
+
+
   ./build0.sh
   ./build1.sh
   ```
@@ -135,8 +138,8 @@ Please follow the below steps for Windows:
 
   ```bash
   ctest
-  inst\bin\lpython examples\expr2.py
-  inst\bin\lpython examples\expr2.py -o a.out
+  src\bin\lpython examples\expr2.py
+  src\bin\lpython examples\expr2.py -o a.out
   a.out
   ```
 
@@ -169,6 +172,21 @@ Please follow the below steps for Windows:
   cd integration_tests
   ./run_tests.py
   ```
+- Troubleshooting on MacOS latest version:
+  - In case of recently updated MacOS, you may get a warning like below in some test cases:
+    ```bash
+    ld: warning: object file (test_list_index2.out.tmp.o) was built for newer macOS version (14.0) than being linked (13.3)
+    ```
+    This leads to mismatch of hashes with expected output in some test cases, this can be resolved by updating command line tools. Below is a snippet for the same.
+
+    ```bash
+    git clean -dfx
+    sudo rm -rf /Library/Developer/CommandLineTools # make sure you know what you're doing here
+    sudo xcode-select --install
+    ./build.sh
+    ./run_tests.py
+    ```
+
 
 ### Windows
 

integration_tests/CMakeLists.txt

@@ -714,6 +714,10 @@ RUN(NAME symbolics_07        LABELS cpython_sym c_sym llvm_sym NOFAST)
 RUN(NAME symbolics_08        LABELS cpython_sym c_sym llvm_sym)
 RUN(NAME symbolics_09        LABELS cpython_sym c_sym llvm_sym NOFAST)
 RUN(NAME symbolics_10        LABELS cpython_sym c_sym llvm_sym NOFAST)
+RUN(NAME symbolics_11        LABELS cpython_sym c_sym llvm_sym NOFAST)
+RUN(NAME symbolics_12        LABELS cpython_sym c_sym llvm_sym NOFAST)
+RUN(NAME symbolics_13        LABELS cpython_sym c_sym llvm_sym NOFAST)
+RUN(NAME test_gruntz         LABELS cpython_sym llvm_sym NOFAST)
 
 RUN(NAME sizeof_01           LABELS llvm c
         EXTRAFILES sizeof_01b.c)
@@ -772,6 +776,7 @@ RUN(NAME func_dep_03    LABELS cpython llvm c)
 RUN(NAME func_dep_04    LABELS cpython llvm c)
 RUN(NAME func_internal_def_01 LABELS cpython llvm NOFAST)
 RUN(NAME func_01        LABELS cpython llvm)
+RUN(NAME func_02        LABELS c_sym llvm_sym NOFAST)
 
 RUN(NAME float_01 LABELS cpython llvm c wasm wasm_x64)
 RUN(NAME recursive_01 LABELS cpython llvm c wasm wasm_x64 wasm_x86)
@@ -799,6 +804,7 @@ RUN(NAME callback_04       IMPORT_PATH .. LABELS cpython)
 
 # Intrinsic Functions
 RUN(NAME intrinsics_01     LABELS cpython llvm NOFAST) # any
+RUN(NAME intrinsics_02     LABELS cpython llvm c) # floordiv
 
 # lpython decorator
 RUN(NAME lpython_decorator_01    LABELS cpython)

integration_tests/func_02.py

@@ -0,0 +1,13 @@
+from lpython import S, Out
+from sympy import pi
+
+def func(r: Out[S]) -> None:
+    r = pi
+
+def test_func():
+    z: S
+    func(z)
+    print(z)
+    assert z == pi
+
+test_func()

integration_tests/intrinsics_02.py

@@ -0,0 +1,42 @@
+from lpython import Const, i32, f32, f64
+
+foo: Const[i32] = 4
+bar: Const[i32] = foo // 2
+
+print(bar)
+assert bar == 2
+
+def floordiv1():
+    a: f64
+    b: f64
+    c: f64
+    a = 5.0
+    b = 2.0
+    c = a // b
+
+    print(c)
+    assert c == 2.0
+
+def floordiv2():
+    a: Const[f32] = f32(5.0)
+    b: Const[f32] = f32(2.0)
+    c: f32
+    c = a // b
+
+    print(c)
+    assert c == f32(2.0)
+
+def floordiv3():
+    a: f64
+    b: f64
+    c: f64
+    a = 5.0
+    b = -2.0
+    c = a // b
+
+    print(c)
+    assert c == -3.0
+
+floordiv1()
+floordiv2()
+floordiv3()

integration_tests/symbolics_01.py

@@ -6,8 +6,17 @@ def main0():
     y: S = Symbol('y')
     x = pi
     z: S = x + y
+    x = z
+    print(x)
     print(z)
+    assert(x == z)
     assert(z == pi + y)
     assert(z != S(2)*pi + y)
 
+    # testing PR 2404
+    p: S = Symbol('pi')
+    print(p)
+    print(p != pi)
+    assert(p != pi)
+
 main0()

integration_tests/symbolics_02.py

@@ -1,33 +1,80 @@
-from sympy import Symbol
+from sympy import Symbol, pi, Add, Mul, Pow
 from lpython import S
 
 def test_symbolic_operations():
     x: S = Symbol('x')
     y: S = Symbol('y')
+    pi1: S = pi
+    pi2: S = pi
 
     # Addition
     z: S = x + y
+    z1: bool = z.func == Add
+    z2: bool = z.func == Mul
     assert(z == x + y)
+    assert(z1 == True)
+    assert(z2 == False)
+    if z.func == Add:
+        assert True
+    else:
+        assert False
+    assert(z.func == Add)
+    assert(z.args[0] == x or z.args[0] == y)
+    assert(z.args[1] == y or z.args[1] == x)
     print(z)
 
     # Subtraction
     w: S = x - y
+    w1: bool = w.func == Add
     assert(w == x - y)
+    assert(w1 == True)
+    if w.func == Add:
+        assert True
+    else:
+        assert False
+    assert(w.func == Add)
     print(w)
 
     # Multiplication
     u: S = x * y
+    u1: bool = u.func == Mul
     assert(u == x * y)
+    assert(u1 == True)
+    if u.func == Mul:
+        assert True
+    else:
+        assert False
+    assert(u.func == Mul)
+    assert(u.args[0] == x)
+    assert(u.args[1] == y)
     print(u)
 
     # Division
     v: S = x / y
+    v1: bool = v.func == Mul
     assert(v == x / y)
+    assert(v1 == True)
+    if v.func == Mul:
+        assert True
+    else:
+        assert False
+    assert(v.func == Mul)
     print(v)
 
     # Power
     p: S = x ** y
+    p1: bool = p.func == Pow
+    p2: bool = p.func == Add
+    p3: bool = p.func == Mul
     assert(p == x ** y)
+    assert(p1 == True)
+    assert(p2 == False)
+    assert(p3 == False)
+    if p.func == Pow:
+        assert True
+    else:
+        assert False
+    assert(p.func == Pow)
     print(p)
 
     # Casting
@@ -37,4 +84,19 @@ def test_symbolic_operations():
     assert(c == S(0))
     print(c)
 
+    # Comparison
+    b1: bool = pi1 == pi2
+    print(b1)
+    assert(b1 == True)
+    b2: bool = pi1 != pi
+    print(b2)
+    assert(b2 == False)
+    b3: bool = pi1 != x
+    print(b3)
+    assert(b3 == True)
+    b4: bool = pi == Symbol("x")
+    print(b4)
+    assert(b4 == False)
+
+
 test_symbolic_operations()

integration_tests/symbolics_05.py

@@ -32,5 +32,12 @@ def test_operations():
     assert((sin(x) + cos(x)).diff(x) == S(-1)*c + d)
     assert((sin(x) + cos(x) + exp(x) + pi).diff(x).expand().diff(x) == exp(x) + S(-1)*c + S(-1)*d)
 
+    # test args
+    assert(a.args[0] == x + y)
+    assert(a.args[1] == S(2))
+    assert(b.args[0] == x + y + z)
+    assert(b.args[1] == S(3))
+    assert(c.args[0] == x)
+    assert(d.args[0] == x)
 
 test_operations()

integration_tests/symbolics_06.py

@@ -28,10 +28,24 @@ def test_elementary_functions():
     # test composite functions
     a: S = exp(x)
     b: S = sin(a)
+    b1: bool = b.func == sin
     c: S = cos(b)
     d: S = log(c)
+    d1: bool = d.func == log
     e: S = Abs(d)
     print(e)
+    assert(b1 == True)
+    if b.func == sin:
+        assert True
+    else:
+        assert False
+    assert(b.func == sin)
+    assert(d1 == True)
+    if d.func == log:
+        assert True
+    else:
+        assert False
+    assert(d.func == log)
     assert(e == Abs(log(cos(sin(exp(x))))))
 
 test_elementary_functions()

integration_tests/symbolics_11.py

@@ -0,0 +1,19 @@
+from sympy import Symbol, sin, pi
+from lpython import S
+
+def test_extraction_of_elements():
+    x: S = Symbol("x")
+    l1: list[S] = [x, pi, sin(x), Symbol("y")]
+    ele1: S = l1[0]
+    ele2: S = l1[1]
+    ele3: S = l1[2]
+    ele4: S = l1[3]
+
+    assert(ele1 == x)
+    assert(ele2 == pi)
+    assert(ele3 == sin(x))
+    assert(ele4 == Symbol("y"))
+    print(ele1, ele2, ele3, ele4)
+    print(l1[0], l1[1], l1[2], l1[3])
+
+test_extraction_of_elements()

integration_tests/symbolics_12.py

@@ -0,0 +1,39 @@
+from sympy import Symbol, E, log, exp
+from lpython import S
+
+def main0():
+    # Define symbolic variables
+    x: S = Symbol('x')
+    y: S = Symbol('y')
+
+    # Assign E to the variable x
+    x = E
+
+    # Check if x is equal to E
+    assert x == E
+
+    # Perform some symbolic operations
+    z: S = x + y
+
+    # Check if z is equal to E + y
+    assert z == E + y
+
+    # Check if x is not equal to 2E + y
+    assert x != S(2) * E + y
+
+    # Evaluate some mathematical expressions
+    expr1: S = log(E)
+    expr2: S = exp(S(1))
+
+    # Check the results
+    assert expr1 == S(1)
+    assert expr2 == E ** S(1)
+
+    # Print the results
+    print("x =", x)
+    print("z =", z)
+    print("log(E) =", expr1)
+    print("exp(1) =", expr2)
+
+
+main0()

integration_tests/symbolics_13.py

@@ -0,0 +1,12 @@
+from lpython import S
+from sympy import pi
+
+def func() -> S:
+    return pi
+
+def test_func():
+    z: S = func()
+    print(z)
+    assert z == pi
+
+test_func()