diff --git a/integration_tests/bindc_03.py b/integration_tests/bindc_03.py index 3a1a9fbf33..d1e699371b 100644 --- a/integration_tests/bindc_03.py +++ b/integration_tests/bindc_03.py @@ -42,7 +42,7 @@ def h(q_void: CPtr) -> None: def run(): a: CPtr array_wrapped: ArrayWrapped = ArrayWrapped(a) - array_wrapped1: ArrayWrapped + array_wrapped1: ArrayWrapped = ArrayWrapped() size: i32 size = 10 a = get_array(size) diff --git a/integration_tests/structs_01.py b/integration_tests/structs_01.py index e88682d93b..e588116414 100644 --- a/integration_tests/structs_01.py +++ b/integration_tests/structs_01.py @@ -14,8 +14,7 @@ def change_struct(a: A): a.y = a.y + f32(1) def g(): - x: A - x = A(f32(3.25), 3) + x: A = A(f32(3.25), 3) f(x) assert x.x == 3 assert f64(x.y) == 3.25 diff --git a/integration_tests/structs_02.py b/integration_tests/structs_02.py index 5dc1acb5e6..f3325d6a9a 100644 --- a/integration_tests/structs_02.py +++ b/integration_tests/structs_02.py @@ -9,9 +9,8 @@ class A: def f(a: CPtr) -> None: x: i32 y: f32 - a1: A + a1: A = A(3, f32(3.25)) a2: Pointer[A] - a1 = A(3, f32(3.25)) a2 = pointer(a1) print(a2, pointer(a1)) x = a2.x diff --git a/integration_tests/structs_04.py b/integration_tests/structs_04.py index ac902839a8..087fac365e 100644 --- a/integration_tests/structs_04.py +++ b/integration_tests/structs_04.py @@ -8,8 +8,8 @@ class A: @dataclass class B: - a: A z: i32 + a: A = A(f32(0.0), 0) def f(b: B): print(b.z, b.a.x, b.a.y) @@ -20,7 +20,7 @@ def f(b: B): def g(): a1: A = A(f32(1.0), 1) a2: A = A(f32(2.0), 2) - b: B = B(a1, 1) + b: B = B(1, a1) b.a = deepcopy(a2) b.z = 1 b.a.x = 2 diff --git a/integration_tests/structs_05.py b/integration_tests/structs_05.py index 05c9dda4ea..d738778109 100644 --- a/integration_tests/structs_05.py +++ b/integration_tests/structs_05.py @@ -1,4 +1,5 @@ from lpython import i32, f64, i64, i16, i8, f32, dataclass +from numpy import empty @dataclass class A: @@ -49,9 +50,8 @@ def update_2(s: A[:]): s[1].c = i8(3) def g(): - # TODO: Replace y: A[2] with y: A[2] = [None, None] - # TODO: And enable cpython in integration_tests. - y: A[2] + # TODO: Enable cpython in integration_tests. + y: A[2] = empty([2], dtype=A) y[0] = A(1.1, 1, i64(1), f32(1.1), i16(1), i8(1), True) y[1] = A(2.2, 2, i64(2), f32(2.2), i16(2), i8(2), True) verify(y, 1, 1.1, 2, 2.2) diff --git a/integration_tests/structs_09.py b/integration_tests/structs_09.py index ea309529be..b32d059afa 100644 --- a/integration_tests/structs_09.py +++ b/integration_tests/structs_09.py @@ -7,13 +7,13 @@ class C: @dataclass class B: z: i32 - bc: C + bc: C = C(f32(0.0)) @dataclass class A: y: f32 x: i32 - b: B + b: B = B(0, C(f32(0.0))) def f(a: A): @@ -22,8 +22,7 @@ def f(a: A): print(a.b.z) def g(): - x: A - x = A(f32(3.25), 3, B(71, C(f32(4.0)))) + x: A = A(f32(3.25), 3, B(71, C(f32(4.0)))) f(x) assert x.x == 3 assert f64(x.y) == 3.25 diff --git a/integration_tests/structs_10.py b/integration_tests/structs_10.py index 59fd41cd5b..8e55c9a5ae 100644 --- a/integration_tests/structs_10.py +++ b/integration_tests/structs_10.py @@ -11,8 +11,8 @@ class Vec: @dataclass class MatVec: - mat: Mat - vec: Vec + mat: Mat = Mat([f64(0.0), f64(0.0)]) + vec: Vec = Vec([f64(0.0), f64(0.0)]) def rotate(mat_vec: MatVec) -> f64[2]: rotated_vec: f64[2] = empty(2, dtype=float64) diff --git a/integration_tests/structs_17.py b/integration_tests/structs_17.py index 95aeada9c3..462432c9ba 100644 --- a/integration_tests/structs_17.py +++ b/integration_tests/structs_17.py @@ -6,13 +6,13 @@ class B: @dataclass class C: cz: f32 - bc: C + bc: C = C(f32(0.0)) @dataclass class A: y: f32 x: i32 - b: B + b: B = B(0, B.C(f32(0.0))) def f(a: A): diff --git a/integration_tests/union_02.py b/integration_tests/union_02.py index 12b340b3dd..c64f08463a 100644 --- a/integration_tests/union_02.py +++ b/integration_tests/union_02.py @@ -19,9 +19,9 @@ class C: @ccall @union class D(Union): - a: A - b: B - c: C + a: A = A() + b: B = B() + c: C = C() def test_struct_union(): d: D = D() diff --git a/src/libasr/asr_utils.h b/src/libasr/asr_utils.h index 3fb215d1c8..b1da17c7ec 100644 --- a/src/libasr/asr_utils.h +++ b/src/libasr/asr_utils.h @@ -1192,15 +1192,15 @@ static inline std::string type_to_str_python(const ASR::ttype_t *t, } case ASR::ttypeType::Struct: { ASR::Struct_t* d = ASR::down_cast(t); - return symbol_name(d->m_derived_type); + return "struct " + std::string(symbol_name(d->m_derived_type)); } case ASR::ttypeType::Enum: { ASR::Enum_t* d = ASR::down_cast(t); - return symbol_name(d->m_enum_type); + return "enum " + std::string(symbol_name(d->m_enum_type)); } case ASR::ttypeType::Union: { ASR::Union_t* d = ASR::down_cast(t); - return symbol_name(d->m_union_type); + return "union " + std::string(symbol_name(d->m_union_type)); } case ASR::ttypeType::Pointer: { ASR::Pointer_t* p = ASR::down_cast(t); diff --git a/src/lpython/semantics/python_ast_to_asr.cpp b/src/lpython/semantics/python_ast_to_asr.cpp index 1f9f758008..49a6299395 100644 --- a/src/lpython/semantics/python_ast_to_asr.cpp +++ b/src/lpython/semantics/python_ast_to_asr.cpp @@ -2465,6 +2465,11 @@ class CommonVisitor : public AST::BaseVisitor { is_c_p_pointer_call = false; if (x.m_value) { this->visit_expr(*x.m_value); + } else { + if (ASR::is_a(*type)) { + throw SemanticError(ASRUtils::type_to_str_python(type) + " " + var_name + + " must be initialized a value", x.base.base.loc); + } } if( is_c_p_pointer_call ) { create_add_variable_to_scope(var_name, nullptr, type, @@ -4098,6 +4103,10 @@ class SymbolTableVisitor : public CommonVisitor { void visit_If(const AST::If_t &/*x*/) { // We skip this in the SymbolTable visitor, but visit it in the BodyVisitor } + + void visit_Call(const AST::Call_t &/*x*/) { + // We skip this in the SymbolTable visitor, but visit it in the BodyVisitor + } }; Result symbol_table_visitor(Allocator &al, LocationManager &lm, const AST::Module_t &ast, diff --git a/tests/errors/structs_02.py b/tests/errors/structs_02.py new file mode 100644 index 0000000000..5c0c1010a0 --- /dev/null +++ b/tests/errors/structs_02.py @@ -0,0 +1,11 @@ +from lpython import i32, dataclass + +@dataclass +class S: + x: i32 + +def main0(): + s: S + s.x = 2 + +main0() diff --git a/tests/reference/asr-structs_01-be14d49.json b/tests/reference/asr-structs_01-be14d49.json index b15e93631e..b0ef6e9369 100644 --- a/tests/reference/asr-structs_01-be14d49.json +++ b/tests/reference/asr-structs_01-be14d49.json @@ -2,7 +2,7 @@ "basename": "asr-structs_01-be14d49", "cmd": "lpython --show-asr --no-color {infile} -o {outfile}", "infile": "tests/../integration_tests/structs_01.py", - "infile_hash": "a17eed6995c1af36b3968cb80367bda33fb855a60793b6bdc770aad2", + "infile_hash": "c8012b0c841b0d8e304c18ca7c6d4365f1d5e41235dc6f4e2dc21664", "outfile": null, "outfile_hash": null, "stdout": "asr-structs_01-be14d49.stdout", diff --git a/tests/reference/asr-structs_02-2ab459a.json b/tests/reference/asr-structs_02-2ab459a.json index 9fc29f74ff..7859a34eb9 100644 --- a/tests/reference/asr-structs_02-2ab459a.json +++ b/tests/reference/asr-structs_02-2ab459a.json @@ -2,7 +2,7 @@ "basename": "asr-structs_02-2ab459a", "cmd": "lpython --show-asr --no-color {infile} -o {outfile}", "infile": "tests/../integration_tests/structs_02.py", - "infile_hash": "f101938e4f5608477de4e57be8f04196e51b97aab3ade62833cecf91", + "infile_hash": "6d54aa7c2bb850cbce2c0add7b77f9f72c9323162ae080c7eef4867a", "outfile": null, "outfile_hash": null, "stdout": "asr-structs_02-2ab459a.stdout", diff --git a/tests/reference/asr-structs_02-f95782c.json b/tests/reference/asr-structs_02-f95782c.json new file mode 100644 index 0000000000..6a45542935 --- /dev/null +++ b/tests/reference/asr-structs_02-f95782c.json @@ -0,0 +1,13 @@ +{ + "basename": "asr-structs_02-f95782c", + "cmd": "lpython --show-asr --no-color {infile} -o {outfile}", + "infile": "tests/errors/structs_02.py", + "infile_hash": "bc4446b7b96cad60bb368378e7af4a8f628bfaaecac2063a1bec5c06", + "outfile": null, + "outfile_hash": null, + "stdout": null, + "stdout_hash": null, + "stderr": "asr-structs_02-f95782c.stderr", + "stderr_hash": "feebf3045d755a862d604df8c8ab0e0cb346f7fbc285256b18e9d559", + "returncode": 2 +} \ No newline at end of file diff --git a/tests/reference/asr-structs_02-f95782c.stderr b/tests/reference/asr-structs_02-f95782c.stderr new file mode 100644 index 0000000000..4ae0a08977 --- /dev/null +++ b/tests/reference/asr-structs_02-f95782c.stderr @@ -0,0 +1,5 @@ +semantic error: struct S s must be initialized a value + --> tests/errors/structs_02.py:8:5 + | +8 | s: S + | ^^^^ diff --git a/tests/reference/asr-structs_04-387747b.json b/tests/reference/asr-structs_04-387747b.json index 82ee8c0110..942a62efad 100644 --- a/tests/reference/asr-structs_04-387747b.json +++ b/tests/reference/asr-structs_04-387747b.json @@ -2,11 +2,11 @@ "basename": "asr-structs_04-387747b", "cmd": "lpython --show-asr --no-color {infile} -o {outfile}", "infile": "tests/../integration_tests/structs_04.py", - "infile_hash": "b57d1dd265f7a7906398ff70e0d5713433a7c3354590d727b3e6306d", + "infile_hash": "c19af3c3fbac1430c22c5aaf69aea7c622faa9d7c4e7734edbd0066d", "outfile": null, "outfile_hash": null, "stdout": "asr-structs_04-387747b.stdout", - "stdout_hash": "596c5faeae119e44e06dc8f6501c1b84360bceed027db7b76498eb1f", + "stdout_hash": "421cc9ffddc15f1c8ec8724fed6b2a87c54d03cfbfc288b13175d718", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-structs_04-387747b.stdout b/tests/reference/asr-structs_04-387747b.stdout index 03aa35d7e4..67c42f339a 100644 --- a/tests/reference/asr-structs_04-387747b.stdout +++ b/tests/reference/asr-structs_04-387747b.stdout @@ -95,8 +95,8 @@ }) B [A] - [a - z] + [z + a] Source Public .false. @@ -432,8 +432,8 @@ (Var 5 b) (StructTypeConstructor 8 B - [((Var 5 a1)) - ((IntegerConstant 1 (Integer 4 [])))] + [((IntegerConstant 1 (Integer 4 []))) + ((Var 5 a1))] (Struct 8 B [] diff --git a/tests/reference/asr-structs_05-fa98307.json b/tests/reference/asr-structs_05-fa98307.json index d795618fd4..f8694a70e6 100644 --- a/tests/reference/asr-structs_05-fa98307.json +++ b/tests/reference/asr-structs_05-fa98307.json @@ -2,11 +2,11 @@ "basename": "asr-structs_05-fa98307", "cmd": "lpython --show-asr --no-color {infile} -o {outfile}", "infile": "tests/../integration_tests/structs_05.py", - "infile_hash": "5c9d6218394744f26160b09fb545064c82ef9172e10b474d6be5fca2", + "infile_hash": "0ca482232f99c40614dc5b994fa8c9f4865fbe72f5a133b02914b5ad", "outfile": null, "outfile_hash": null, "stdout": "asr-structs_05-fa98307.stdout", - "stdout_hash": "eed215681e7afcff6553f61228ae7482df849e1b24c3a022f80c6da0", + "stdout_hash": "4adb7d314cd3d28086e7e0ebb8a701b1de0d0f253d5de63730b6f113", "stderr": null, "stderr_hash": null, "returncode": 0 diff --git a/tests/reference/asr-structs_05-fa98307.stdout b/tests/reference/asr-structs_05-fa98307.stdout index 0ef6e59ba5..f2ef05d938 100644 --- a/tests/reference/asr-structs_05-fa98307.stdout +++ b/tests/reference/asr-structs_05-fa98307.stdout @@ -5,16 +5,16 @@ _global_symbols: (Module (SymbolTable - 9 + 200 { A: (StructType (SymbolTable - 2 + 193 { a: (Variable - 2 + 193 a [] Local @@ -29,7 +29,7 @@ ), b: (Variable - 2 + 193 b [] Local @@ -44,7 +44,7 @@ ), c: (Variable - 2 + 193 c [] Local @@ -59,7 +59,7 @@ ), d: (Variable - 2 + 193 d [] Local @@ -74,7 +74,7 @@ ), x: (Variable - 2 + 193 x [] Local @@ -89,7 +89,7 @@ ), y: (Variable - 2 + 193 y [] Local @@ -104,7 +104,7 @@ ), z: (Variable - 2 + 193 z [] Local @@ -137,7 +137,7 @@ _lpython_main_program: (Function (SymbolTable - 8 + 199 { }) @@ -160,7 +160,7 @@ [g] [] [(SubroutineCall - 9 g + 200 g () [] () @@ -174,11 +174,11 @@ g: (Function (SymbolTable - 6 + 197 { y: (Variable - 6 + 197 y [] Local @@ -186,7 +186,7 @@ () Default (Struct - 9 A + 200 A [((IntegerConstant 0 (Integer 4 [])) (IntegerConstant 2 (Integer 4 [])))] ) @@ -218,19 +218,19 @@ [] [(= (ArrayItem - (Var 6 y) + (Var 197 y) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Struct - 9 A + 200 A [] ) RowMajor () ) (StructTypeConstructor - 9 A + 200 A [((RealConstant 1.100000 (Real 8 []) @@ -271,7 +271,7 @@ (Logical 4 []) ))] (Struct - 9 A + 200 A [] ) () @@ -280,19 +280,19 @@ ) (= (ArrayItem - (Var 6 y) + (Var 197 y) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct - 9 A + 200 A [] ) RowMajor () ) (StructTypeConstructor - 9 A + 200 A [((RealConstant 2.200000 (Real 8 []) @@ -333,7 +333,7 @@ (Logical 4 []) ))] (Struct - 9 A + 200 A [] ) () @@ -341,9 +341,9 @@ () ) (SubroutineCall - 9 verify + 200 verify () - [((Var 6 y)) + [((Var 197 y)) ((IntegerConstant 1 (Integer 4 []))) ((RealConstant 1.100000 @@ -357,15 +357,15 @@ () ) (SubroutineCall - 9 update_1 + 200 update_1 () [((ArrayItem - (Var 6 y) + (Var 197 y) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Struct - 9 A + 200 A [] ) RowMajor @@ -374,15 +374,15 @@ () ) (SubroutineCall - 9 update_2 + 200 update_2 () - [((Var 6 y))] + [((Var 197 y))] () ) (SubroutineCall - 9 verify + 200 verify () - [((Var 6 y)) + [((Var 197 y)) ((IntegerConstant 2 (Integer 4 []))) ((RealConstant 1.200000 @@ -404,11 +404,11 @@ update_1: (Function (SymbolTable - 4 + 195 { s: (Variable - 4 + 195 s [] In @@ -416,7 +416,7 @@ () Default (Struct - 9 A + 200 A [] ) Source @@ -428,7 +428,7 @@ update_1 (FunctionType [(Struct - 9 A + 200 A [] )] () @@ -445,11 +445,11 @@ .false. ) [] - [(Var 4 s)] + [(Var 195 s)] [(= (StructInstanceMember - (Var 4 s) - 2 x + (Var 195 s) + 193 x (Integer 4 []) () ) @@ -458,8 +458,8 @@ ) (= (StructInstanceMember - (Var 4 s) - 2 y + (Var 195 s) + 193 y (Real 8 []) () ) @@ -471,8 +471,8 @@ ) (= (StructInstanceMember - (Var 4 s) - 2 z + (Var 195 s) + 193 z (Integer 8 []) () ) @@ -486,8 +486,8 @@ ) (= (StructInstanceMember - (Var 4 s) - 2 a + (Var 195 s) + 193 a (Real 4 []) () ) @@ -507,8 +507,8 @@ ) (= (StructInstanceMember - (Var 4 s) - 2 b + (Var 195 s) + 193 b (Integer 2 []) () ) @@ -522,8 +522,8 @@ ) (= (StructInstanceMember - (Var 4 s) - 2 c + (Var 195 s) + 193 c (Integer 1 []) () ) @@ -544,11 +544,11 @@ update_2: (Function (SymbolTable - 5 + 196 { s: (Variable - 5 + 196 s [] InOut @@ -556,7 +556,7 @@ () Default (Struct - 9 A + 200 A [(() ())] ) @@ -569,7 +569,7 @@ update_2 (FunctionType [(Struct - 9 A + 200 A [(() ())] )] @@ -587,22 +587,22 @@ .false. ) [] - [(Var 5 s)] + [(Var 196 s)] [(= (StructInstanceMember (ArrayItem - (Var 5 s) + (Var 196 s) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct - 9 A + 200 A [] ) RowMajor () ) - 2 x + 193 x (Integer 4 []) () ) @@ -612,18 +612,18 @@ (= (StructInstanceMember (ArrayItem - (Var 5 s) + (Var 196 s) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct - 9 A + 200 A [] ) RowMajor () ) - 2 y + 193 y (Real 8 []) () ) @@ -636,18 +636,18 @@ (= (StructInstanceMember (ArrayItem - (Var 5 s) + (Var 196 s) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct - 9 A + 200 A [] ) RowMajor () ) - 2 z + 193 z (Integer 8 []) () ) @@ -662,18 +662,18 @@ (= (StructInstanceMember (ArrayItem - (Var 5 s) + (Var 196 s) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct - 9 A + 200 A [] ) RowMajor () ) - 2 a + 193 a (Real 4 []) () ) @@ -694,18 +694,18 @@ (= (StructInstanceMember (ArrayItem - (Var 5 s) + (Var 196 s) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct - 9 A + 200 A [] ) RowMajor () ) - 2 b + 193 b (Integer 2 []) () ) @@ -720,18 +720,18 @@ (= (StructInstanceMember (ArrayItem - (Var 5 s) + (Var 196 s) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct - 9 A + 200 A [] ) RowMajor () ) - 2 c + 193 c (Integer 1 []) () ) @@ -752,11 +752,11 @@ verify: (Function (SymbolTable - 3 + 194 { eps: (Variable - 3 + 194 eps [] Local @@ -771,7 +771,7 @@ ), s: (Variable - 3 + 194 s [] InOut @@ -779,7 +779,7 @@ () Default (Struct - 9 A + 200 A [(() ())] ) @@ -790,7 +790,7 @@ ), s0: (Variable - 3 + 194 s0 [] Local @@ -798,7 +798,7 @@ () Default (Struct - 9 A + 200 A [] ) Source @@ -808,7 +808,7 @@ ), s1: (Variable - 3 + 194 s1 [] Local @@ -816,7 +816,7 @@ () Default (Struct - 9 A + 200 A [] ) Source @@ -826,7 +826,7 @@ ), x1: (Variable - 3 + 194 x1 [] In @@ -841,7 +841,7 @@ ), x2: (Variable - 3 + 194 x2 [] In @@ -856,7 +856,7 @@ ), y1: (Variable - 3 + 194 y1 [] In @@ -871,7 +871,7 @@ ), y2: (Variable - 3 + 194 y2 [] In @@ -888,7 +888,7 @@ verify (FunctionType [(Struct - 9 A + 200 A [(() ())] ) @@ -910,13 +910,13 @@ .false. ) [] - [(Var 3 s) - (Var 3 x1) - (Var 3 y1) - (Var 3 x2) - (Var 3 y2)] + [(Var 194 s) + (Var 194 x1) + (Var 194 y1) + (Var 194 x2) + (Var 194 y2)] [(= - (Var 3 eps) + (Var 194 eps) (RealConstant 0.000000 (Real 8 []) @@ -924,14 +924,14 @@ () ) (= - (Var 3 s0) + (Var 194 s0) (ArrayItem - (Var 3 s) + (Var 194 s) [(() (IntegerConstant 0 (Integer 4 [])) ())] (Struct - 9 A + 200 A [] ) RowMajor @@ -942,44 +942,44 @@ (Print () [(StructInstanceMember - (Var 3 s0) - 2 x + (Var 194 s0) + 193 x (Integer 4 []) () ) (StructInstanceMember - (Var 3 s0) - 2 y + (Var 194 s0) + 193 y (Real 8 []) () ) (StructInstanceMember - (Var 3 s0) - 2 z + (Var 194 s0) + 193 z (Integer 8 []) () ) (StructInstanceMember - (Var 3 s0) - 2 a + (Var 194 s0) + 193 a (Real 4 []) () ) (StructInstanceMember - (Var 3 s0) - 2 b + (Var 194 s0) + 193 b (Integer 2 []) () ) (StructInstanceMember - (Var 3 s0) - 2 c + (Var 194 s0) + 193 c (Integer 1 []) () ) (StructInstanceMember - (Var 3 s0) - 2 d + (Var 194 s0) + 193 d (Logical 4 []) () )] @@ -989,13 +989,13 @@ (Assert (IntegerCompare (StructInstanceMember - (Var 3 s0) - 2 x + (Var 194 s0) + 193 x (Integer 4 []) () ) Eq - (Var 3 x1) + (Var 194 x1) (Logical 4 []) () ) @@ -1007,13 +1007,13 @@ Abs [(RealBinOp (StructInstanceMember - (Var 3 s0) - 2 y + (Var 194 s0) + 193 y (Real 8 []) () ) Sub - (Var 3 y1) + (Var 194 y1) (Real 8 []) () )] @@ -1022,7 +1022,7 @@ () ) Lt - (Var 3 eps) + (Var 194 eps) (Logical 4 []) () ) @@ -1031,14 +1031,14 @@ (Assert (IntegerCompare (StructInstanceMember - (Var 3 s0) - 2 z + (Var 194 s0) + 193 z (Integer 8 []) () ) Eq (Cast - (Var 3 x1) + (Var 194 x1) IntegerToInteger (Integer 8 []) () @@ -1054,14 +1054,14 @@ Abs [(RealBinOp (StructInstanceMember - (Var 3 s0) - 2 a + (Var 194 s0) + 193 a (Real 4 []) () ) Sub (Cast - (Var 3 y1) + (Var 194 y1) RealToReal (Real 4 []) () @@ -1094,14 +1094,14 @@ (Assert (IntegerCompare (StructInstanceMember - (Var 3 s0) - 2 b + (Var 194 s0) + 193 b (Integer 2 []) () ) Eq (Cast - (Var 3 x1) + (Var 194 x1) IntegerToInteger (Integer 2 []) () @@ -1114,14 +1114,14 @@ (Assert (IntegerCompare (StructInstanceMember - (Var 3 s0) - 2 c + (Var 194 s0) + 193 c (Integer 1 []) () ) Eq (Cast - (Var 3 x1) + (Var 194 x1) IntegerToInteger (Integer 1 []) () @@ -1133,22 +1133,22 @@ ) (Assert (StructInstanceMember - (Var 3 s0) - 2 d + (Var 194 s0) + 193 d (Logical 4 []) () ) () ) (= - (Var 3 s1) + (Var 194 s1) (ArrayItem - (Var 3 s) + (Var 194 s) [(() (IntegerConstant 1 (Integer 4 [])) ())] (Struct - 9 A + 200 A [] ) RowMajor @@ -1159,44 +1159,44 @@ (Print () [(StructInstanceMember - (Var 3 s1) - 2 x + (Var 194 s1) + 193 x (Integer 4 []) () ) (StructInstanceMember - (Var 3 s1) - 2 y + (Var 194 s1) + 193 y (Real 8 []) () ) (StructInstanceMember - (Var 3 s1) - 2 z + (Var 194 s1) + 193 z (Integer 8 []) () ) (StructInstanceMember - (Var 3 s1) - 2 a + (Var 194 s1) + 193 a (Real 4 []) () ) (StructInstanceMember - (Var 3 s1) - 2 b + (Var 194 s1) + 193 b (Integer 2 []) () ) (StructInstanceMember - (Var 3 s1) - 2 c + (Var 194 s1) + 193 c (Integer 1 []) () ) (StructInstanceMember - (Var 3 s1) - 2 d + (Var 194 s1) + 193 d (Logical 4 []) () )] @@ -1206,13 +1206,13 @@ (Assert (IntegerCompare (StructInstanceMember - (Var 3 s1) - 2 x + (Var 194 s1) + 193 x (Integer 4 []) () ) Eq - (Var 3 x2) + (Var 194 x2) (Logical 4 []) () ) @@ -1224,13 +1224,13 @@ Abs [(RealBinOp (StructInstanceMember - (Var 3 s1) - 2 y + (Var 194 s1) + 193 y (Real 8 []) () ) Sub - (Var 3 y2) + (Var 194 y2) (Real 8 []) () )] @@ -1239,7 +1239,7 @@ () ) Lt - (Var 3 eps) + (Var 194 eps) (Logical 4 []) () ) @@ -1248,14 +1248,14 @@ (Assert (IntegerCompare (StructInstanceMember - (Var 3 s1) - 2 z + (Var 194 s1) + 193 z (Integer 8 []) () ) Eq (Cast - (Var 3 x2) + (Var 194 x2) IntegerToInteger (Integer 8 []) () @@ -1271,14 +1271,14 @@ Abs [(RealBinOp (StructInstanceMember - (Var 3 s1) - 2 a + (Var 194 s1) + 193 a (Real 4 []) () ) Sub (Cast - (Var 3 y2) + (Var 194 y2) RealToReal (Real 4 []) () @@ -1311,14 +1311,14 @@ (Assert (IntegerCompare (StructInstanceMember - (Var 3 s1) - 2 b + (Var 194 s1) + 193 b (Integer 2 []) () ) Eq (Cast - (Var 3 x2) + (Var 194 x2) IntegerToInteger (Integer 2 []) () @@ -1331,14 +1331,14 @@ (Assert (IntegerCompare (StructInstanceMember - (Var 3 s1) - 2 c + (Var 194 s1) + 193 c (Integer 1 []) () ) Eq (Cast - (Var 3 x2) + (Var 194 x2) IntegerToInteger (Integer 1 []) () @@ -1350,8 +1350,8 @@ ) (Assert (StructInstanceMember - (Var 3 s1) - 2 d + (Var 194 s1) + 193 d (Logical 4 []) () ) @@ -1369,16 +1369,18 @@ .false. .false. ), + lpython_builtin: + (IntrinsicModule lpython_builtin), main_program: (Program (SymbolTable - 7 + 198 { _lpython_main_program: (ExternalSymbol - 7 + 198 _lpython_main_program - 9 _lpython_main_program + 200 _lpython_main_program _global_symbols [] _lpython_main_program @@ -1388,11 +1390,5852 @@ main_program [_global_symbols] [(SubroutineCall - 7 _lpython_main_program + 198 _lpython_main_program () [] () )] + ), + numpy: + (Module + (SymbolTable + 3 + { + __lpython_overloaded_0__arccos: + (Function + (SymbolTable + 41 + { + _lpython_return_variable: + (Variable + 41 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ), + x: + (Variable + 41 + x + [] + In + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_0__arccos + (FunctionType + [(Real 8 [])] + (Real 8 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_dacos] + [(Var 41 x)] + [(= + (Var 41 _lpython_return_variable) + (FunctionCall + 3 _lfortran_dacos + () + [((Var 41 x))] + (Real 8 []) + () + () + ) + () + ) + (Return)] + (Var 41 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_0__arccosh: + (Function + (SymbolTable + 65 + { + _lpython_return_variable: + (Variable + 65 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ), + x: + (Variable + 65 + x + [] + In + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_0__arccosh + (FunctionType + [(Real 8 [])] + (Real 8 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_dacosh] + [(Var 65 x)] + [(= + (Var 65 _lpython_return_variable) + (FunctionCall + 3 _lfortran_dacosh + () + [((Var 65 x))] + (Real 8 []) + () + () + ) + () + ) + (Return)] + (Var 65 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_0__arcsin: + (Function + (SymbolTable + 37 + { + _lpython_return_variable: + (Variable + 37 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ), + x: + (Variable + 37 + x + [] + In + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_0__arcsin + (FunctionType + [(Real 8 [])] + (Real 8 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_dasin] + [(Var 37 x)] + [(= + (Var 37 _lpython_return_variable) + (FunctionCall + 3 _lfortran_dasin + () + [((Var 37 x))] + (Real 8 []) + () + () + ) + () + ) + (Return)] + (Var 37 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_0__arcsinh: + (Function + (SymbolTable + 61 + { + _lpython_return_variable: + (Variable + 61 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ), + x: + (Variable + 61 + x + [] + In + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_0__arcsinh + (FunctionType + [(Real 8 [])] + (Real 8 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_dasinh] + [(Var 61 x)] + [(= + (Var 61 _lpython_return_variable) + (FunctionCall + 3 _lfortran_dasinh + () + [((Var 61 x))] + (Real 8 []) + () + () + ) + () + ) + (Return)] + (Var 61 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_0__arctan: + (Function + (SymbolTable + 53 + { + _lpython_return_variable: + (Variable + 53 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ), + x: + (Variable + 53 + x + [] + In + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_0__arctan + (FunctionType + [(Real 8 [])] + (Real 8 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_datan] + [(Var 53 x)] + [(= + (Var 53 _lpython_return_variable) + (FunctionCall + 3 _lfortran_datan + () + [((Var 53 x))] + (Real 8 []) + () + () + ) + () + ) + (Return)] + (Var 53 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_0__arctanh: + (Function + (SymbolTable + 69 + { + _lpython_return_variable: + (Variable + 69 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ), + x: + (Variable + 69 + x + [] + In + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_0__arctanh + (FunctionType + [(Real 8 [])] + (Real 8 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_datanh] + [(Var 69 x)] + [(= + (Var 69 _lpython_return_variable) + (FunctionCall + 3 _lfortran_datanh + () + [((Var 69 x))] + (Real 8 []) + () + () + ) + () + ) + (Return)] + (Var 69 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_0__ceil: + (Function + (SymbolTable + 76 + { + _lpython_return_variable: + (Variable + 76 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ), + result: + (Variable + 76 + result + [] + Local + () + () + Default + (Integer 8 []) + Source + Public + Required + .false. + ), + x: + (Variable + 76 + x + [] + In + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_0__ceil + (FunctionType + [(Real 8 [])] + (Real 8 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 76 x)] + [(= + (Var 76 result) + (Cast + (Var 76 x) + RealToInteger + (Integer 8 []) + () + ) + () + ) + (If + (LogicalBinOp + (RealCompare + (Var 76 x) + LtE + (Cast + (IntegerConstant 0 (Integer 4 [])) + IntegerToReal + (Real 8 []) + (RealConstant + 0.000000 + (Real 8 []) + ) + ) + (Logical 4 []) + () + ) + Or + (RealCompare + (Var 76 x) + Eq + (Cast + (Var 76 result) + IntegerToReal + (Real 8 []) + () + ) + (Logical 4 []) + () + ) + (Logical 4 []) + () + ) + [(= + (Var 76 _lpython_return_variable) + (Cast + (Var 76 result) + IntegerToReal + (Real 8 []) + () + ) + () + ) + (Return)] + [] + ) + (= + (Var 76 _lpython_return_variable) + (Cast + (IntegerBinOp + (Var 76 result) + Add + (Cast + (IntegerConstant 1 (Integer 4 [])) + IntegerToInteger + (Integer 8 []) + (IntegerConstant 1 (Integer 8 [])) + ) + (Integer 8 []) + () + ) + IntegerToReal + (Real 8 []) + () + ) + () + ) + (Return)] + (Var 76 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_0__cos: + (Function + (SymbolTable + 9 + { + _lpython_return_variable: + (Variable + 9 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ), + x: + (Variable + 9 + x + [] + In + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_0__cos + (FunctionType + [(Real 8 [])] + (Real 8 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_dcos] + [(Var 9 x)] + [(= + (Var 9 _lpython_return_variable) + (FunctionCall + 3 _lfortran_dcos + () + [((Var 9 x))] + (Real 8 []) + () + () + ) + () + ) + (Return)] + (Var 9 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_0__cosh: + (Function + (SymbolTable + 23 + { + _lpython_return_variable: + (Variable + 23 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ), + x: + (Variable + 23 + x + [] + In + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_0__cosh + (FunctionType + [(Real 8 [])] + (Real 8 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_dcosh] + [(Var 23 x)] + [(= + (Var 23 _lpython_return_variable) + (FunctionCall + 3 _lfortran_dcosh + () + [((Var 23 x))] + (Real 8 []) + () + () + ) + () + ) + (Return)] + (Var 23 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_0__degrees: + (Function + (SymbolTable + 56 + { + _lpython_return_variable: + (Variable + 56 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ), + x: + (Variable + 56 + x + [] + In + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_0__degrees + (FunctionType + [(Real 8 [])] + (Real 8 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 56 x)] + [(= + (Var 56 _lpython_return_variable) + (RealBinOp + (RealBinOp + (Var 56 x) + Mul + (RealConstant + 180.000000 + (Real 8 []) + ) + (Real 8 []) + () + ) + Div + (Var 3 pi_64) + (Real 8 []) + () + ) + () + ) + (Return)] + (Var 56 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_0__exp: + (Function + (SymbolTable + 49 + { + _lpython_return_variable: + (Variable + 49 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ), + x: + (Variable + 49 + x + [] + In + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_0__exp + (FunctionType + [(Real 8 [])] + (Real 8 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_dexp] + [(Var 49 x)] + [(= + (Var 49 _lpython_return_variable) + (FunctionCall + 3 _lfortran_dexp + () + [((Var 49 x))] + (Real 8 []) + () + () + ) + () + ) + (Return)] + (Var 49 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_0__floor: + (Function + (SymbolTable + 74 + { + _lpython_return_variable: + (Variable + 74 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ), + result: + (Variable + 74 + result + [] + Local + () + () + Default + (Integer 8 []) + Source + Public + Required + .false. + ), + x: + (Variable + 74 + x + [] + In + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_0__floor + (FunctionType + [(Real 8 [])] + (Real 8 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 74 x)] + [(= + (Var 74 result) + (Cast + (Var 74 x) + RealToInteger + (Integer 8 []) + () + ) + () + ) + (If + (LogicalBinOp + (RealCompare + (Var 74 x) + GtE + (Cast + (IntegerConstant 0 (Integer 4 [])) + IntegerToReal + (Real 8 []) + (RealConstant + 0.000000 + (Real 8 []) + ) + ) + (Logical 4 []) + () + ) + Or + (RealCompare + (Var 74 x) + Eq + (Cast + (Var 74 result) + IntegerToReal + (Real 8 []) + () + ) + (Logical 4 []) + () + ) + (Logical 4 []) + () + ) + [(= + (Var 74 _lpython_return_variable) + (Cast + (Var 74 result) + IntegerToReal + (Real 8 []) + () + ) + () + ) + (Return)] + [] + ) + (= + (Var 74 _lpython_return_variable) + (Cast + (IntegerBinOp + (Var 74 result) + Sub + (Cast + (IntegerConstant 1 (Integer 4 [])) + IntegerToInteger + (Integer 8 []) + (IntegerConstant 1 (Integer 8 [])) + ) + (Integer 8 []) + () + ) + IntegerToReal + (Real 8 []) + () + ) + () + ) + (Return)] + (Var 74 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_0__log: + (Function + (SymbolTable + 27 + { + _lpython_return_variable: + (Variable + 27 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ), + x: + (Variable + 27 + x + [] + In + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_0__log + (FunctionType + [(Real 8 [])] + (Real 8 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_dlog] + [(Var 27 x)] + [(= + (Var 27 _lpython_return_variable) + (FunctionCall + 3 _lfortran_dlog + () + [((Var 27 x))] + (Real 8 []) + () + () + ) + () + ) + (Return)] + (Var 27 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_0__log10: + (Function + (SymbolTable + 31 + { + _lpython_return_variable: + (Variable + 31 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ), + x: + (Variable + 31 + x + [] + In + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_0__log10 + (FunctionType + [(Real 8 [])] + (Real 8 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_dlog10] + [(Var 31 x)] + [(= + (Var 31 _lpython_return_variable) + (FunctionCall + 3 _lfortran_dlog10 + () + [((Var 31 x))] + (Real 8 []) + () + () + ) + () + ) + (Return)] + (Var 31 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_0__log2: + (Function + (SymbolTable + 34 + { + _lpython_return_variable: + (Variable + 34 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ), + x: + (Variable + 34 + x + [] + In + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_0__log2 + (FunctionType + [(Real 8 [])] + (Real 8 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_dlog] + [(Var 34 x)] + [(= + (Var 34 _lpython_return_variable) + (RealBinOp + (FunctionCall + 3 _lfortran_dlog + () + [((Var 34 x))] + (Real 8 []) + () + () + ) + Div + (FunctionCall + 3 _lfortran_dlog + () + [((RealConstant + 2.000000 + (Real 8 []) + ))] + (Real 8 []) + () + () + ) + (Real 8 []) + () + ) + () + ) + (Return)] + (Var 34 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_0__mod: + (Function + (SymbolTable + 72 + { + _lpython_return_variable: + (Variable + 72 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Integer 8 []) + Source + Public + Required + .false. + ), + _mod: + (ExternalSymbol + 72 + _mod + 79 _mod + lpython_builtin + [] + _mod + Private + ), + _mod@__lpython_overloaded_4___mod: + (ExternalSymbol + 72 + _mod@__lpython_overloaded_4___mod + 79 __lpython_overloaded_4___mod + lpython_builtin + [] + __lpython_overloaded_4___mod + Public + ), + x1: + (Variable + 72 + x1 + [] + In + () + () + Default + (Integer 8 []) + Source + Public + Required + .false. + ), + x2: + (Variable + 72 + x2 + [] + In + () + () + Default + (Integer 8 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_0__mod + (FunctionType + [(Integer 8 []) + (Integer 8 [])] + (Integer 8 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_mod@__lpython_overloaded_4___mod] + [(Var 72 x1) + (Var 72 x2)] + [(If + (IntegerCompare + (Var 72 x2) + Eq + (Cast + (IntegerConstant 0 (Integer 4 [])) + IntegerToInteger + (Integer 8 []) + (IntegerConstant 0 (Integer 8 [])) + ) + (Logical 4 []) + () + ) + [(= + (Var 72 _lpython_return_variable) + (Cast + (IntegerConstant 0 (Integer 4 [])) + IntegerToInteger + (Integer 8 []) + (IntegerConstant 0 (Integer 8 [])) + ) + () + ) + (Return)] + [] + ) + (= + (Var 72 _lpython_return_variable) + (FunctionCall + 72 _mod@__lpython_overloaded_4___mod + 72 _mod + [((Var 72 x1)) + ((Var 72 x2))] + (Integer 8 []) + () + () + ) + () + ) + (Return)] + (Var 72 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_0__radians: + (Function + (SymbolTable + 58 + { + _lpython_return_variable: + (Variable + 58 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ), + x: + (Variable + 58 + x + [] + In + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_0__radians + (FunctionType + [(Real 8 [])] + (Real 8 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 58 x)] + [(= + (Var 58 _lpython_return_variable) + (RealBinOp + (RealBinOp + (Var 58 x) + Mul + (Var 3 pi_64) + (Real 8 []) + () + ) + Div + (RealConstant + 180.000000 + (Real 8 []) + ) + (Real 8 []) + () + ) + () + ) + (Return)] + (Var 58 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_0__sin: + (Function + (SymbolTable + 5 + { + _lpython_return_variable: + (Variable + 5 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ), + x: + (Variable + 5 + x + [] + In + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_0__sin + (FunctionType + [(Real 8 [])] + (Real 8 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_dsin] + [(Var 5 x)] + [(= + (Var 5 _lpython_return_variable) + (FunctionCall + 3 _lfortran_dsin + () + [((Var 5 x))] + (Real 8 []) + () + () + ) + () + ) + (Return)] + (Var 5 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_0__sinh: + (Function + (SymbolTable + 19 + { + _lpython_return_variable: + (Variable + 19 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ), + x: + (Variable + 19 + x + [] + In + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_0__sinh + (FunctionType + [(Real 8 [])] + (Real 8 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_dsinh] + [(Var 19 x)] + [(= + (Var 19 _lpython_return_variable) + (FunctionCall + 3 _lfortran_dsinh + () + [((Var 19 x))] + (Real 8 []) + () + () + ) + () + ) + (Return)] + (Var 19 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_0__sqrt: + (Function + (SymbolTable + 12 + { + _lpython_return_variable: + (Variable + 12 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ), + x: + (Variable + 12 + x + [] + In + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_0__sqrt + (FunctionType + [(Real 8 [])] + (Real 8 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 12 x)] + [(= + (Var 12 _lpython_return_variable) + (RealBinOp + (Var 12 x) + Pow + (RealBinOp + (Cast + (IntegerConstant 1 (Integer 4 [])) + IntegerToReal + (Real 8 []) + (RealConstant + 1.000000 + (Real 8 []) + ) + ) + Div + (Cast + (IntegerConstant 2 (Integer 4 [])) + IntegerToReal + (Real 8 []) + (RealConstant + 2.000000 + (Real 8 []) + ) + ) + (Real 8 []) + (RealConstant + 0.500000 + (Real 8 []) + ) + ) + (Real 8 []) + () + ) + () + ) + (Return)] + (Var 12 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_0__tan: + (Function + (SymbolTable + 15 + { + _lpython_return_variable: + (Variable + 15 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ), + x: + (Variable + 15 + x + [] + In + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_0__tan + (FunctionType + [(Real 8 [])] + (Real 8 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_dtan] + [(Var 15 x)] + [(= + (Var 15 _lpython_return_variable) + (FunctionCall + 3 _lfortran_dtan + () + [((Var 15 x))] + (Real 8 []) + () + () + ) + () + ) + (Return)] + (Var 15 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_0__tanh: + (Function + (SymbolTable + 45 + { + _lpython_return_variable: + (Variable + 45 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ), + x: + (Variable + 45 + x + [] + In + () + () + Default + (Real 8 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_0__tanh + (FunctionType + [(Real 8 [])] + (Real 8 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_dtanh] + [(Var 45 x)] + [(= + (Var 45 _lpython_return_variable) + (FunctionCall + 3 _lfortran_dtanh + () + [((Var 45 x))] + (Real 8 []) + () + () + ) + () + ) + (Return)] + (Var 45 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_1__arccos: + (Function + (SymbolTable + 43 + { + _lpython_return_variable: + (Variable + 43 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + x: + (Variable + 43 + x + [] + In + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_1__arccos + (FunctionType + [(Real 4 [])] + (Real 4 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_sacos] + [(Var 43 x)] + [(= + (Var 43 _lpython_return_variable) + (FunctionCall + 3 _lfortran_sacos + () + [((Var 43 x))] + (Real 4 []) + () + () + ) + () + ) + (Return)] + (Var 43 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_1__arccosh: + (Function + (SymbolTable + 67 + { + _lpython_return_variable: + (Variable + 67 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + x: + (Variable + 67 + x + [] + In + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_1__arccosh + (FunctionType + [(Real 4 [])] + (Real 4 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_sacosh] + [(Var 67 x)] + [(= + (Var 67 _lpython_return_variable) + (FunctionCall + 3 _lfortran_sacosh + () + [((Var 67 x))] + (Real 4 []) + () + () + ) + () + ) + (Return)] + (Var 67 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_1__arcsin: + (Function + (SymbolTable + 39 + { + _lpython_return_variable: + (Variable + 39 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + x: + (Variable + 39 + x + [] + In + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_1__arcsin + (FunctionType + [(Real 4 [])] + (Real 4 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_sasin] + [(Var 39 x)] + [(= + (Var 39 _lpython_return_variable) + (FunctionCall + 3 _lfortran_sasin + () + [((Var 39 x))] + (Real 4 []) + () + () + ) + () + ) + (Return)] + (Var 39 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_1__arcsinh: + (Function + (SymbolTable + 63 + { + _lpython_return_variable: + (Variable + 63 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + x: + (Variable + 63 + x + [] + In + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_1__arcsinh + (FunctionType + [(Real 4 [])] + (Real 4 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_sasinh] + [(Var 63 x)] + [(= + (Var 63 _lpython_return_variable) + (FunctionCall + 3 _lfortran_sasinh + () + [((Var 63 x))] + (Real 4 []) + () + () + ) + () + ) + (Return)] + (Var 63 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_1__arctan: + (Function + (SymbolTable + 55 + { + _lpython_return_variable: + (Variable + 55 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + x: + (Variable + 55 + x + [] + In + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_1__arctan + (FunctionType + [(Real 4 [])] + (Real 4 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_satan] + [(Var 55 x)] + [(= + (Var 55 _lpython_return_variable) + (FunctionCall + 3 _lfortran_satan + () + [((Var 55 x))] + (Real 4 []) + () + () + ) + () + ) + (Return)] + (Var 55 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_1__arctanh: + (Function + (SymbolTable + 71 + { + _lpython_return_variable: + (Variable + 71 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + x: + (Variable + 71 + x + [] + In + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_1__arctanh + (FunctionType + [(Real 4 [])] + (Real 4 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_satanh] + [(Var 71 x)] + [(= + (Var 71 _lpython_return_variable) + (FunctionCall + 3 _lfortran_satanh + () + [((Var 71 x))] + (Real 4 []) + () + () + ) + () + ) + (Return)] + (Var 71 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_1__ceil: + (Function + (SymbolTable + 77 + { + _lpython_return_variable: + (Variable + 77 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + resultf: + (Variable + 77 + resultf + [] + Local + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + x: + (Variable + 77 + x + [] + In + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_1__ceil + (FunctionType + [(Real 4 [])] + (Real 4 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 77 x)] + [(= + (Var 77 resultf) + (Cast + (Cast + (Var 77 x) + RealToInteger + (Integer 4 []) + () + ) + IntegerToReal + (Real 4 []) + () + ) + () + ) + (If + (LogicalBinOp + (RealCompare + (Var 77 x) + LtE + (Cast + (IntegerConstant 0 (Integer 4 [])) + IntegerToReal + (Real 4 []) + (RealConstant + 0.000000 + (Real 4 []) + ) + ) + (Logical 4 []) + () + ) + Or + (RealCompare + (Var 77 x) + Eq + (Var 77 resultf) + (Logical 4 []) + () + ) + (Logical 4 []) + () + ) + [(= + (Var 77 _lpython_return_variable) + (Var 77 resultf) + () + ) + (Return)] + [] + ) + (= + (Var 77 _lpython_return_variable) + (RealBinOp + (Var 77 resultf) + Add + (Cast + (IntegerConstant 1 (Integer 4 [])) + IntegerToReal + (Real 4 []) + (RealConstant + 1.000000 + (Real 4 []) + ) + ) + (Real 4 []) + () + ) + () + ) + (Return)] + (Var 77 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_1__cos: + (Function + (SymbolTable + 11 + { + _lpython_return_variable: + (Variable + 11 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + x: + (Variable + 11 + x + [] + In + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_1__cos + (FunctionType + [(Real 4 [])] + (Real 4 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_scos] + [(Var 11 x)] + [(= + (Var 11 _lpython_return_variable) + (FunctionCall + 3 _lfortran_scos + () + [((Var 11 x))] + (Real 4 []) + () + () + ) + () + ) + (Return)] + (Var 11 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_1__cosh: + (Function + (SymbolTable + 25 + { + _lpython_return_variable: + (Variable + 25 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + x: + (Variable + 25 + x + [] + In + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_1__cosh + (FunctionType + [(Real 4 [])] + (Real 4 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_scosh] + [(Var 25 x)] + [(= + (Var 25 _lpython_return_variable) + (FunctionCall + 3 _lfortran_scosh + () + [((Var 25 x))] + (Real 4 []) + () + () + ) + () + ) + (Return)] + (Var 25 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_1__degrees: + (Function + (SymbolTable + 57 + { + _lpython_return_variable: + (Variable + 57 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + x: + (Variable + 57 + x + [] + In + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_1__degrees + (FunctionType + [(Real 4 [])] + (Real 4 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 57 x)] + [(= + (Var 57 _lpython_return_variable) + (RealBinOp + (Var 57 x) + Mul + (RealBinOp + (Cast + (IntegerConstant 180 (Integer 4 [])) + IntegerToReal + (Real 4 []) + (RealConstant + 180.000000 + (Real 4 []) + ) + ) + Div + (Var 3 pi_32) + (Real 4 []) + () + ) + (Real 4 []) + () + ) + () + ) + (Return)] + (Var 57 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_1__exp: + (Function + (SymbolTable + 51 + { + _lpython_return_variable: + (Variable + 51 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + x: + (Variable + 51 + x + [] + In + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_1__exp + (FunctionType + [(Real 4 [])] + (Real 4 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_sexp] + [(Var 51 x)] + [(= + (Var 51 _lpython_return_variable) + (FunctionCall + 3 _lfortran_sexp + () + [((Var 51 x))] + (Real 4 []) + () + () + ) + () + ) + (Return)] + (Var 51 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_1__floor: + (Function + (SymbolTable + 75 + { + _lpython_return_variable: + (Variable + 75 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + resultf: + (Variable + 75 + resultf + [] + Local + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + x: + (Variable + 75 + x + [] + In + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_1__floor + (FunctionType + [(Real 4 [])] + (Real 4 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 75 x)] + [(= + (Var 75 resultf) + (Cast + (Cast + (Var 75 x) + RealToInteger + (Integer 4 []) + () + ) + IntegerToReal + (Real 4 []) + () + ) + () + ) + (If + (LogicalBinOp + (RealCompare + (Var 75 x) + GtE + (Cast + (IntegerConstant 0 (Integer 4 [])) + IntegerToReal + (Real 4 []) + (RealConstant + 0.000000 + (Real 4 []) + ) + ) + (Logical 4 []) + () + ) + Or + (RealCompare + (Var 75 x) + Eq + (Var 75 resultf) + (Logical 4 []) + () + ) + (Logical 4 []) + () + ) + [(= + (Var 75 _lpython_return_variable) + (Var 75 resultf) + () + ) + (Return)] + [] + ) + (= + (Var 75 _lpython_return_variable) + (RealBinOp + (Var 75 resultf) + Sub + (Cast + (IntegerConstant 1 (Integer 4 [])) + IntegerToReal + (Real 4 []) + (RealConstant + 1.000000 + (Real 4 []) + ) + ) + (Real 4 []) + () + ) + () + ) + (Return)] + (Var 75 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_1__log: + (Function + (SymbolTable + 29 + { + _lpython_return_variable: + (Variable + 29 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + x: + (Variable + 29 + x + [] + In + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_1__log + (FunctionType + [(Real 4 [])] + (Real 4 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_slog] + [(Var 29 x)] + [(= + (Var 29 _lpython_return_variable) + (FunctionCall + 3 _lfortran_slog + () + [((Var 29 x))] + (Real 4 []) + () + () + ) + () + ) + (Return)] + (Var 29 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_1__log10: + (Function + (SymbolTable + 33 + { + _lpython_return_variable: + (Variable + 33 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + x: + (Variable + 33 + x + [] + In + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_1__log10 + (FunctionType + [(Real 4 [])] + (Real 4 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_slog10] + [(Var 33 x)] + [(= + (Var 33 _lpython_return_variable) + (FunctionCall + 3 _lfortran_slog10 + () + [((Var 33 x))] + (Real 4 []) + () + () + ) + () + ) + (Return)] + (Var 33 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_1__log2: + (Function + (SymbolTable + 35 + { + _lpython_return_variable: + (Variable + 35 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + x: + (Variable + 35 + x + [] + In + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_1__log2 + (FunctionType + [(Real 4 [])] + (Real 4 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_slog] + [(Var 35 x)] + [(= + (Var 35 _lpython_return_variable) + (RealBinOp + (FunctionCall + 3 _lfortran_slog + () + [((Var 35 x))] + (Real 4 []) + () + () + ) + Div + (FunctionCall + 3 _lfortran_slog + () + [((Cast + (RealConstant + 2.000000 + (Real 8 []) + ) + RealToReal + (Real 4 []) + (RealConstant + 2.000000 + (Real 4 []) + ) + ))] + (Real 4 []) + () + () + ) + (Real 4 []) + () + ) + () + ) + (Return)] + (Var 35 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_1__mod: + (Function + (SymbolTable + 73 + { + _lpython_return_variable: + (Variable + 73 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Integer 4 []) + Source + Public + Required + .false. + ), + _mod: + (ExternalSymbol + 73 + _mod + 79 _mod + lpython_builtin + [] + _mod + Private + ), + _mod@__lpython_overloaded_2___mod: + (ExternalSymbol + 73 + _mod@__lpython_overloaded_2___mod + 79 __lpython_overloaded_2___mod + lpython_builtin + [] + __lpython_overloaded_2___mod + Public + ), + x1: + (Variable + 73 + x1 + [] + In + () + () + Default + (Integer 4 []) + Source + Public + Required + .false. + ), + x2: + (Variable + 73 + x2 + [] + In + () + () + Default + (Integer 4 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_1__mod + (FunctionType + [(Integer 4 []) + (Integer 4 [])] + (Integer 4 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_mod@__lpython_overloaded_2___mod] + [(Var 73 x1) + (Var 73 x2)] + [(If + (IntegerCompare + (Var 73 x2) + Eq + (IntegerConstant 0 (Integer 4 [])) + (Logical 4 []) + () + ) + [(= + (Var 73 _lpython_return_variable) + (IntegerConstant 0 (Integer 4 [])) + () + ) + (Return)] + [] + ) + (= + (Var 73 _lpython_return_variable) + (FunctionCall + 73 _mod@__lpython_overloaded_2___mod + 73 _mod + [((Var 73 x1)) + ((Var 73 x2))] + (Integer 4 []) + () + () + ) + () + ) + (Return)] + (Var 73 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_1__radians: + (Function + (SymbolTable + 59 + { + _lpython_return_variable: + (Variable + 59 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + x: + (Variable + 59 + x + [] + In + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_1__radians + (FunctionType + [(Real 4 [])] + (Real 4 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 59 x)] + [(= + (Var 59 _lpython_return_variable) + (RealBinOp + (Var 59 x) + Mul + (RealBinOp + (Var 3 pi_32) + Div + (Cast + (IntegerConstant 180 (Integer 4 [])) + IntegerToReal + (Real 4 []) + (RealConstant + 180.000000 + (Real 4 []) + ) + ) + (Real 4 []) + () + ) + (Real 4 []) + () + ) + () + ) + (Return)] + (Var 59 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_1__sin: + (Function + (SymbolTable + 7 + { + _lpython_return_variable: + (Variable + 7 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + x: + (Variable + 7 + x + [] + In + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_1__sin + (FunctionType + [(Real 4 [])] + (Real 4 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_ssin] + [(Var 7 x)] + [(= + (Var 7 _lpython_return_variable) + (FunctionCall + 3 _lfortran_ssin + () + [((Var 7 x))] + (Real 4 []) + () + () + ) + () + ) + (Return)] + (Var 7 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_1__sinh: + (Function + (SymbolTable + 21 + { + _lpython_return_variable: + (Variable + 21 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + x: + (Variable + 21 + x + [] + In + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_1__sinh + (FunctionType + [(Real 4 [])] + (Real 4 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_ssinh] + [(Var 21 x)] + [(= + (Var 21 _lpython_return_variable) + (FunctionCall + 3 _lfortran_ssinh + () + [((Var 21 x))] + (Real 4 []) + () + () + ) + () + ) + (Return)] + (Var 21 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_1__sqrt: + (Function + (SymbolTable + 13 + { + _lpython_return_variable: + (Variable + 13 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + x: + (Variable + 13 + x + [] + In + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_1__sqrt + (FunctionType + [(Real 4 [])] + (Real 4 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 13 x)] + [(= + (Var 13 _lpython_return_variable) + (RealBinOp + (Var 13 x) + Pow + (Cast + (RealBinOp + (Cast + (IntegerConstant 1 (Integer 4 [])) + IntegerToReal + (Real 8 []) + (RealConstant + 1.000000 + (Real 8 []) + ) + ) + Div + (Cast + (IntegerConstant 2 (Integer 4 [])) + IntegerToReal + (Real 8 []) + (RealConstant + 2.000000 + (Real 8 []) + ) + ) + (Real 8 []) + (RealConstant + 0.500000 + (Real 8 []) + ) + ) + RealToReal + (Real 4 []) + (RealConstant + 0.500000 + (Real 4 []) + ) + ) + (Real 4 []) + () + ) + () + ) + (Return)] + (Var 13 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_1__tan: + (Function + (SymbolTable + 17 + { + _lpython_return_variable: + (Variable + 17 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + x: + (Variable + 17 + x + [] + In + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_1__tan + (FunctionType + [(Real 4 [])] + (Real 4 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_stan] + [(Var 17 x)] + [(= + (Var 17 _lpython_return_variable) + (FunctionCall + 3 _lfortran_stan + () + [((Var 17 x))] + (Real 4 []) + () + () + ) + () + ) + (Return)] + (Var 17 _lpython_return_variable) + Public + .false. + .false. + () + ), + __lpython_overloaded_1__tanh: + (Function + (SymbolTable + 47 + { + _lpython_return_variable: + (Variable + 47 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ), + x: + (Variable + 47 + x + [] + In + () + () + Default + (Real 4 []) + Source + Public + Required + .false. + ) + }) + __lpython_overloaded_1__tanh + (FunctionType + [(Real 4 [])] + (Real 4 []) + Source + Implementation + () + .true. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [_lfortran_stanh] + [(Var 47 x)] + [(= + (Var 47 _lpython_return_variable) + (FunctionCall + 3 _lfortran_stanh + () + [((Var 47 x))] + (Real 4 []) + () + () + ) + () + ) + (Return)] + (Var 47 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_dacos: + (Function + (SymbolTable + 40 + { + _lpython_return_variable: + (Variable + 40 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 40 + x + [] + In + () + () + Default + (Real 8 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_dacos + (FunctionType + [(Real 8 [])] + (Real 8 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 40 x)] + [] + (Var 40 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_dacosh: + (Function + (SymbolTable + 64 + { + _lpython_return_variable: + (Variable + 64 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 64 + x + [] + In + () + () + Default + (Real 8 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_dacosh + (FunctionType + [(Real 8 [])] + (Real 8 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 64 x)] + [] + (Var 64 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_dasin: + (Function + (SymbolTable + 36 + { + _lpython_return_variable: + (Variable + 36 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 36 + x + [] + In + () + () + Default + (Real 8 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_dasin + (FunctionType + [(Real 8 [])] + (Real 8 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 36 x)] + [] + (Var 36 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_dasinh: + (Function + (SymbolTable + 60 + { + _lpython_return_variable: + (Variable + 60 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 60 + x + [] + In + () + () + Default + (Real 8 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_dasinh + (FunctionType + [(Real 8 [])] + (Real 8 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 60 x)] + [] + (Var 60 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_datan: + (Function + (SymbolTable + 52 + { + _lpython_return_variable: + (Variable + 52 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 52 + x + [] + In + () + () + Default + (Real 8 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_datan + (FunctionType + [(Real 8 [])] + (Real 8 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 52 x)] + [] + (Var 52 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_datanh: + (Function + (SymbolTable + 68 + { + _lpython_return_variable: + (Variable + 68 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 68 + x + [] + In + () + () + Default + (Real 8 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_datanh + (FunctionType + [(Real 8 [])] + (Real 8 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 68 x)] + [] + (Var 68 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_dcos: + (Function + (SymbolTable + 8 + { + _lpython_return_variable: + (Variable + 8 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 8 + x + [] + In + () + () + Default + (Real 8 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_dcos + (FunctionType + [(Real 8 [])] + (Real 8 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 8 x)] + [] + (Var 8 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_dcosh: + (Function + (SymbolTable + 22 + { + _lpython_return_variable: + (Variable + 22 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 22 + x + [] + In + () + () + Default + (Real 8 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_dcosh + (FunctionType + [(Real 8 [])] + (Real 8 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 22 x)] + [] + (Var 22 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_dexp: + (Function + (SymbolTable + 48 + { + _lpython_return_variable: + (Variable + 48 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 48 + x + [] + In + () + () + Default + (Real 8 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_dexp + (FunctionType + [(Real 8 [])] + (Real 8 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 48 x)] + [] + (Var 48 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_dlog: + (Function + (SymbolTable + 26 + { + _lpython_return_variable: + (Variable + 26 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 26 + x + [] + In + () + () + Default + (Real 8 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_dlog + (FunctionType + [(Real 8 [])] + (Real 8 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 26 x)] + [] + (Var 26 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_dlog10: + (Function + (SymbolTable + 30 + { + _lpython_return_variable: + (Variable + 30 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 30 + x + [] + In + () + () + Default + (Real 8 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_dlog10 + (FunctionType + [(Real 8 [])] + (Real 8 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 30 x)] + [] + (Var 30 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_dsin: + (Function + (SymbolTable + 4 + { + _lpython_return_variable: + (Variable + 4 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 4 + x + [] + In + () + () + Default + (Real 8 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_dsin + (FunctionType + [(Real 8 [])] + (Real 8 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 4 x)] + [] + (Var 4 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_dsinh: + (Function + (SymbolTable + 18 + { + _lpython_return_variable: + (Variable + 18 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 18 + x + [] + In + () + () + Default + (Real 8 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_dsinh + (FunctionType + [(Real 8 [])] + (Real 8 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 18 x)] + [] + (Var 18 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_dtan: + (Function + (SymbolTable + 14 + { + _lpython_return_variable: + (Variable + 14 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 14 + x + [] + In + () + () + Default + (Real 8 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_dtan + (FunctionType + [(Real 8 [])] + (Real 8 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 14 x)] + [] + (Var 14 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_dtanh: + (Function + (SymbolTable + 44 + { + _lpython_return_variable: + (Variable + 44 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 8 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 44 + x + [] + In + () + () + Default + (Real 8 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_dtanh + (FunctionType + [(Real 8 [])] + (Real 8 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 44 x)] + [] + (Var 44 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_sacos: + (Function + (SymbolTable + 42 + { + _lpython_return_variable: + (Variable + 42 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 42 + x + [] + In + () + () + Default + (Real 4 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_sacos + (FunctionType + [(Real 4 [])] + (Real 4 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 42 x)] + [] + (Var 42 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_sacosh: + (Function + (SymbolTable + 66 + { + _lpython_return_variable: + (Variable + 66 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 66 + x + [] + In + () + () + Default + (Real 4 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_sacosh + (FunctionType + [(Real 4 [])] + (Real 4 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 66 x)] + [] + (Var 66 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_sasin: + (Function + (SymbolTable + 38 + { + _lpython_return_variable: + (Variable + 38 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 38 + x + [] + In + () + () + Default + (Real 4 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_sasin + (FunctionType + [(Real 4 [])] + (Real 4 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 38 x)] + [] + (Var 38 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_sasinh: + (Function + (SymbolTable + 62 + { + _lpython_return_variable: + (Variable + 62 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 62 + x + [] + In + () + () + Default + (Real 4 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_sasinh + (FunctionType + [(Real 4 [])] + (Real 4 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 62 x)] + [] + (Var 62 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_satan: + (Function + (SymbolTable + 54 + { + _lpython_return_variable: + (Variable + 54 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 54 + x + [] + In + () + () + Default + (Real 4 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_satan + (FunctionType + [(Real 4 [])] + (Real 4 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 54 x)] + [] + (Var 54 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_satanh: + (Function + (SymbolTable + 70 + { + _lpython_return_variable: + (Variable + 70 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 70 + x + [] + In + () + () + Default + (Real 4 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_satanh + (FunctionType + [(Real 4 [])] + (Real 4 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 70 x)] + [] + (Var 70 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_scos: + (Function + (SymbolTable + 10 + { + _lpython_return_variable: + (Variable + 10 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 10 + x + [] + In + () + () + Default + (Real 4 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_scos + (FunctionType + [(Real 4 [])] + (Real 4 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 10 x)] + [] + (Var 10 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_scosh: + (Function + (SymbolTable + 24 + { + _lpython_return_variable: + (Variable + 24 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 24 + x + [] + In + () + () + Default + (Real 4 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_scosh + (FunctionType + [(Real 4 [])] + (Real 4 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 24 x)] + [] + (Var 24 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_sexp: + (Function + (SymbolTable + 50 + { + _lpython_return_variable: + (Variable + 50 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 50 + x + [] + In + () + () + Default + (Real 4 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_sexp + (FunctionType + [(Real 4 [])] + (Real 4 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 50 x)] + [] + (Var 50 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_slog: + (Function + (SymbolTable + 28 + { + _lpython_return_variable: + (Variable + 28 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 28 + x + [] + In + () + () + Default + (Real 4 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_slog + (FunctionType + [(Real 4 [])] + (Real 4 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 28 x)] + [] + (Var 28 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_slog10: + (Function + (SymbolTable + 32 + { + _lpython_return_variable: + (Variable + 32 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 32 + x + [] + In + () + () + Default + (Real 4 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_slog10 + (FunctionType + [(Real 4 [])] + (Real 4 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 32 x)] + [] + (Var 32 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_ssin: + (Function + (SymbolTable + 6 + { + _lpython_return_variable: + (Variable + 6 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 6 + x + [] + In + () + () + Default + (Real 4 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_ssin + (FunctionType + [(Real 4 [])] + (Real 4 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 6 x)] + [] + (Var 6 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_ssinh: + (Function + (SymbolTable + 20 + { + _lpython_return_variable: + (Variable + 20 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 20 + x + [] + In + () + () + Default + (Real 4 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_ssinh + (FunctionType + [(Real 4 [])] + (Real 4 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 20 x)] + [] + (Var 20 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_stan: + (Function + (SymbolTable + 16 + { + _lpython_return_variable: + (Variable + 16 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 16 + x + [] + In + () + () + Default + (Real 4 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_stan + (FunctionType + [(Real 4 [])] + (Real 4 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 16 x)] + [] + (Var 16 _lpython_return_variable) + Public + .false. + .false. + () + ), + _lfortran_stanh: + (Function + (SymbolTable + 46 + { + _lpython_return_variable: + (Variable + 46 + _lpython_return_variable + [] + ReturnVar + () + () + Default + (Real 4 []) + BindC + Public + Required + .false. + ), + x: + (Variable + 46 + x + [] + In + () + () + Default + (Real 4 []) + BindC + Public + Required + .true. + ) + }) + _lfortran_stanh + (FunctionType + [(Real 4 [])] + (Real 4 []) + BindC + Interface + () + .false. + .false. + .false. + .false. + .false. + [] + [] + .false. + ) + [] + [(Var 46 x)] + [] + (Var 46 _lpython_return_variable) + Public + .false. + .false. + () + ), + arccos: + (GenericProcedure + 3 + arccos + [3 __lpython_overloaded_0__arccos + 3 __lpython_overloaded_1__arccos] + Public + ), + arccosh: + (GenericProcedure + 3 + arccosh + [3 __lpython_overloaded_0__arccosh + 3 __lpython_overloaded_1__arccosh] + Public + ), + arcsin: + (GenericProcedure + 3 + arcsin + [3 __lpython_overloaded_0__arcsin + 3 __lpython_overloaded_1__arcsin] + Public + ), + arcsinh: + (GenericProcedure + 3 + arcsinh + [3 __lpython_overloaded_0__arcsinh + 3 __lpython_overloaded_1__arcsinh] + Public + ), + arctan: + (GenericProcedure + 3 + arctan + [3 __lpython_overloaded_0__arctan + 3 __lpython_overloaded_1__arctan] + Public + ), + arctanh: + (GenericProcedure + 3 + arctanh + [3 __lpython_overloaded_0__arctanh + 3 __lpython_overloaded_1__arctanh] + Public + ), + ceil: + (GenericProcedure + 3 + ceil + [3 __lpython_overloaded_0__ceil + 3 __lpython_overloaded_1__ceil] + Public + ), + cos: + (GenericProcedure + 3 + cos + [3 __lpython_overloaded_0__cos + 3 __lpython_overloaded_1__cos] + Public + ), + cosh: + (GenericProcedure + 3 + cosh + [3 __lpython_overloaded_0__cosh + 3 __lpython_overloaded_1__cosh] + Public + ), + degrees: + (GenericProcedure + 3 + degrees + [3 __lpython_overloaded_0__degrees + 3 __lpython_overloaded_1__degrees] + Public + ), + exp: + (GenericProcedure + 3 + exp + [3 __lpython_overloaded_0__exp + 3 __lpython_overloaded_1__exp] + Public + ), + floor: + (GenericProcedure + 3 + floor + [3 __lpython_overloaded_0__floor + 3 __lpython_overloaded_1__floor] + Public + ), + log: + (GenericProcedure + 3 + log + [3 __lpython_overloaded_0__log + 3 __lpython_overloaded_1__log] + Public + ), + log10: + (GenericProcedure + 3 + log10 + [3 __lpython_overloaded_0__log10 + 3 __lpython_overloaded_1__log10] + Public + ), + log2: + (GenericProcedure + 3 + log2 + [3 __lpython_overloaded_0__log2 + 3 __lpython_overloaded_1__log2] + Public + ), + mod: + (GenericProcedure + 3 + mod + [3 __lpython_overloaded_0__mod + 3 __lpython_overloaded_1__mod] + Public + ), + pi_32: + (Variable + 3 + pi_32 + [] + Local + (Cast + (RealConstant + 3.141593 + (Real 8 []) + ) + RealToReal + (Real 4 []) + (RealConstant + 3.141593 + (Real 4 []) + ) + ) + (RealConstant + 3.141593 + (Real 4 []) + ) + Default + (Real 4 []) + Source + Public + Required + .false. + ), + pi_64: + (Variable + 3 + pi_64 + [] + Local + (RealConstant + 3.141593 + (Real 8 []) + ) + (RealConstant + 3.141593 + (Real 8 []) + ) + Default + (Real 8 []) + Source + Public + Required + .false. + ), + radians: + (GenericProcedure + 3 + radians + [3 __lpython_overloaded_0__radians + 3 __lpython_overloaded_1__radians] + Public + ), + sin: + (GenericProcedure + 3 + sin + [3 __lpython_overloaded_0__sin + 3 __lpython_overloaded_1__sin] + Public + ), + sinh: + (GenericProcedure + 3 + sinh + [3 __lpython_overloaded_0__sinh + 3 __lpython_overloaded_1__sinh] + Public + ), + sqrt: + (GenericProcedure + 3 + sqrt + [3 __lpython_overloaded_0__sqrt + 3 __lpython_overloaded_1__sqrt] + Public + ), + tan: + (GenericProcedure + 3 + tan + [3 __lpython_overloaded_0__tan + 3 __lpython_overloaded_1__tan] + Public + ), + tanh: + (GenericProcedure + 3 + tanh + [3 __lpython_overloaded_0__tanh + 3 __lpython_overloaded_1__tanh] + Public + ) + }) + numpy + [lpython_builtin] + .false. + .false. ) }) [] diff --git a/tests/tests.toml b/tests/tests.toml index 71d61d9eb1..21790026c9 100644 --- a/tests/tests.toml +++ b/tests/tests.toml @@ -638,6 +638,10 @@ asr = true filename = "errors/structs_01.py" asr = true +[[test]] +filename = "errors/structs_02.py" +asr = true + [[test]] filename = "errors/const_01.py" asr = true