v0.6.4 update

.github/workflows/build.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: configure
       run:  |
         sudo apt update

.github/workflows/nonanboxing2.yml

@@ -0,0 +1,42 @@
+name: NoNANBoxing-2
+
+on:
+  push:
+    branches: [ "dev", "help" ]
+  pull_request:
+    branches: [ "dev", "help" ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: configure
+      run:  |
+        sudo apt update
+        sudo apt install libsuitesparse-dev
+        sudo apt install liblapacke-dev
+        sudo apt install libunistring-dev
+        python -m pip install --upgrade pip
+        python -m pip install regex colored
+    - name: make
+      run: |
+        mkdir build
+        cd build
+        cmake -DMORPHO_DISABLENANBOXING=ON ..
+        sudo make install
+        sudo mkdir /usr/local/lib/morpho
+    - name: getcli
+      run: |
+        git clone https://github.com/Morpho-lang/morpho-cli.git
+        cd morpho-cli 
+        mkdir build
+        cd build
+        cmake -DMORPHO_DISABLENANBOXING=ON ..
+        sudo make install
+    - name: test 
+      run: |
+        cd test
+        python3 test.py

.gitignore

@@ -76,3 +76,5 @@ build-xcode/*
 build-win/*
 *.valgrind
 /.vs
+/dist
+/vcpkg_installed

CMakeLists.txt

@@ -23,6 +23,7 @@ option(MORPHO_GCSTRESSTEST "Stress tests the garbage collector" OFF)
 option(MORPHO_BUILD_LINALG "Builds with linear algebra" ON)
 option(MORPHO_BUILD_SPARSE "Builds with sparse matrix support" ON)
 option(MORPHO_BUILD_GEOMETRY "Builds with geometry library" ON)
+option(MORPHO_BUILD_PROFILER "Builds with profiler" ON)
 
 #-------------------------------------------------------------------------------
 # Process options
@@ -53,6 +54,11 @@ if(MORPHO_BUILD_GEOMETRY)
 target_compile_definitions(morpho PUBLIC MORPHO_INCLUDE_GEOMETRY)
 endif()
 
+# Build with profiler
+if(MORPHO_BUILD_PROFILER)
+target_compile_definitions(morpho PUBLIC _DEBUG_PROFILER)
+endif()
+
 #-------------------------------------------------------------------------------
 # BLAS and LAPACK
 #-------------------------------------------------------------------------------
@@ -64,7 +70,7 @@ message(STATUS "Searching for BLAS and LAPACK")
 # Currently we prefer LAPACKE 
 # TODO: Fix morpho source to select between lapack and lapacke
 find_library(LAPACK_LIBRARY
-    NAMES lapacke liblapacke lapack liblapack libopenblas
+    NAMES lapacke liblapacke lapack liblapack openblas libopenblas 
     HINTS 
         "C:\\Program Files\\Morpho\\lib\\"
 )
@@ -85,7 +91,7 @@ endif()
 # Find cblas.h header file 
 find_path(CBLAS_INCLUDE cblas.h 
           HINTS 
-            "C:\\Program Files\\Morpho\\include\\lapack")
+            "C:\\Program Files\\Morpho\\include\\openblas")
 
 # Add cblas headers to include folders
 target_include_directories(morpho PUBLIC ${CBLAS_INCLUDE})

examples/elementtypes/qtensorCG2.morpho

@@ -64,7 +64,6 @@ class QTensor {
     self.problem.addenergy(anchor, selection=self.bnd, prefactor = self.EA)
 
     // The elastic energy is the grad-squared of the q-tensor
-
     fn elasticity(x, q) {
       var g = grad(q)
       return g[0].inner(g[0]) + g[1].inner(g[1]) 

help/classes.md

@@ -174,3 +174,22 @@ is equivalent to:
 The `clss` method is used to get the class to which an object belongs. 
 
     print a.clss() 
+
+## Superclass
+[tagsuperclass]: # (superclass)
+
+The `superclass` method returns the superclass of an object or class:
+
+    print a.superclass()
+
+## Serialize
+[tagserialize]: # (serialize)
+
+The `serialize` method is provided as part of the base `Object` interface for objects that support serialization.
+
+## Linearization
+[taglinearization]: # (linearization)
+
+The `linearization` method returns a list describing the class linearization used for method lookup:
+
+    print a.linearization()

help/complex.md

@@ -34,10 +34,42 @@ Returns the angle `phi` associated with the polar representation of a complex nu
 
     print z.angle() 
 
+## Real
+[tagreal]: # (real)
+
+Returns the real part of a complex number:
+
+    print z.real()
+
+## Imag
+[tagimag]: # (imag)
+
+Returns the imaginary part of a complex number:
+
+    print z.imag()
+
 ## Conj
 [tagconjugate]: # (conjugate)
 [tagconj]: # (conj)
 
 Returns the complex conjugate of a number:
 
     print z.conj() 
+
+## Abs
+[tagabs]: # (abs)
+
+Returns the magnitude of a complex number:
+
+    print z.abs()
+
+## ComplexMatrix
+[tagcomplexmatrix]: # (complexmatrix)
+
+The `ComplexMatrix` class provides complex-valued matrices. See also `Matrix`.
+
+Useful methods include:
+
+    print c.real()
+    print c.imag()
+    print c.conjTranspose()

help/controlflow.md

@@ -13,6 +13,8 @@ Control flow statements are used to determine whether and how many times a selec
 * `for` - Repeatedly execute a section of code with a counter
 * `while` - Repeatedly execute a section of code while a condition is true.
 
+[showsubtopics]: # (subtopics)
+
 ## If
 [tagif]: # (if)
 [tagelse]: # (else)

help/dictionary.md

@@ -28,24 +28,70 @@ Loop over keys in a dictionary:
 
     for (k in dict) print k
 
-The `keys` method returns a Morpho List of the keys.
+[showsubtopics]: # (subtopics)
+
+## Keys
+[tagkeys]: # (keys)
+
+The `keys` method returns a Morpho `List` of the keys.
 
     var keys = dict.keys() // will return ["Massachusetts", "New York", "Vermont"]
 
-The `contains` method returns a Bool value for whether the Dictionary
-contains a given key.
+## Contains
+[tagcontains]: # (contains)
+
+The `contains` method returns a `Bool` value for whether the `Dictionary` contains a given key.
 
     print dict.contains("Vermont") // true
     print dict.contains("New Hampshire") // false
 
-The `remove` method removes a given key from the Dictionary.
+## Remove
+[tagremove]: # (remove)
+
+The `remove` method removes a given key from the `Dictionary`.
 
     dict.remove("Vermont")
     print dict // { New York : Albany, Massachusetts : Boston }
 
-The `clear` method removes all the (key, value) pairs fromt the
-dictionary, resulting in an empty dictionary. 
+## Clear
+[tagclear]: # (clear)
 
-    dict.clear()
+The `clear` method removes all the `(key, value)` pairs from the dictionary, resulting in an empty dictionary.
 
+    dict.clear()
     print dict // {  }
+
+## Union
+[tagunion]: # (union)
+
+The `union` method combines two dictionaries. If the same key is present in both, the value from the second dictionary is used:
+
+    var a = { "x" : 1, "y" : 2 }
+    var b = { "y" : 5, "z" : 3 }
+    print a.union(b) // { x : 1, y : 5, z : 3 }
+
+The `+` operator provides the same operation for dictionaries:
+
+    print a+b
+
+## Intersection
+[tagintersection]: # (intersection)
+
+The `intersection` method returns a dictionary containing only the keys present in both dictionaries:
+
+    var a = { "x" : 1, "y" : 2 }
+    var b = { "y" : 5, "z" : 3 }
+    print a.intersection(b)
+
+## Difference
+[tagdifference]: # (difference)
+
+The `difference` method returns a dictionary containing only the keys present in the first dictionary but not the second:
+
+    var a = { "x" : 1, "y" : 2 }
+    var b = { "y" : 5 }
+    print a.difference(b)
+
+The `-` operator provides the same operation for dictionaries:
+
+    print a-b