Newlinalg

src/builtin/builtin.c

@@ -162,6 +162,39 @@ objecttypedefn objectbuiltinfunctiondefn = {
     .cmpfn=NULL
 };
 
+/* **********************************************************************
+ * Signature parsing
+ * ********************************************************************** */
+
+/** This mechanism allows builtin classes to cross-reference one another in method signature declarations */
+
+typedef struct _sigparses {
+    const char *sig;
+    signature *dest;
+} _sigparse;
+
+DECLARE_VARRAY(_sigparse, _sigparse)
+DEFINE_VARRAY(_sigparse, _sigparse)
+
+varray__sigparse sigparseworklist;
+
+/** Add a signature to be parsed on the next call to builtin_parsesignatures  */
+void builtin_addparsesignature(const char *sig, signature *dest) {
+    _sigparse s = { .sig = sig, .dest = dest };
+    varray__sigparsewrite(&sigparseworklist, s);
+}
+
+/** Parses all signatures on the worklist */
+bool builtin_parsesignatures(void) {
+    _sigparse s;
+    while (varray__sigparsepop(&sigparseworklist, &s)) {
+        if (!signature_parse(s.sig, s.dest)) {
+            return false;
+        }
+    }
+    return true;
+}
+
 /* **********************************************************************
  * Create and find builtin functions
  * ********************************************************************** */
@@ -264,10 +297,7 @@ bool morpho_addfunction(char *name, char *signature, builtinfunction func, built
     if (!name) goto morpho_addfunction_cleanup;
 
     // Parse function signature if provided
-    if (signature &&
-        !signature_parse(signature, &new->sig)) {
-        UNREACHABLE("Syntax error in signature definition.");
-    }
+    if (signature) builtin_addparsesignature(signature, &new->sig);
 
     value newfn = MORPHO_OBJECT(new);
 
@@ -340,9 +370,7 @@ bool morpho_addclass(char *name, builtinclassentry desc[], int nparents, value *
             newmethod->klass=new;
             newmethod->name=object_stringfromcstring(desc[i].name, strlen(desc[i].name));
             newmethod->flags=desc[i].flags;
-            if (desc[i].signature) {
-                success &= signature_parse(desc[i].signature, &newmethod->sig);
-            }
+            if (desc[i].signature) builtin_addparsesignature(desc[i].signature, &newmethod->sig);
 
             dictionary_intern(&builtin_symboltable, newmethod->name);
             value method = MORPHO_OBJECT(newmethod);
@@ -425,10 +453,12 @@ void builtin_initialize(void) {
     builtin_setclasstable(&builtin_classtable);
 
     // Initialize core object types
-    objectstringtype=object_addtype(&objectstringdefn);
     objectclasstype=object_addtype(&objectclassdefn);
+    objectstringtype=object_addtype(&objectstringdefn);
     objectbuiltinfunctiontype=object_addtype(&objectbuiltinfunctiondefn);
 
+    varray__sigparseinit(&sigparseworklist);
+
     /* Initialize builtin classes and functions */
     instance_initialize(); // Must initialize first so that Object exists
 
@@ -462,7 +492,7 @@ void builtin_initialize(void) {
 
     // Initialize linear algebra
 #ifdef MORPHO_INCLUDE_LINALG
-    matrix_initialize();
+    linalg_initialize();
 #endif
 
 #ifdef MORPHO_INCLUDE_SPARSE
@@ -473,6 +503,10 @@ void builtin_initialize(void) {
     // Initialize geometry
     geometry_initialize();
 #endif
+
+    if (!builtin_parsesignatures()) {
+        UNREACHABLE("Syntax error in signature.");
+    }
 
     morpho_addfinalizefn(builtin_finalize);
 }
@@ -484,6 +518,8 @@ void builtin_finalize(void) {
         builtin_objects=next;
     }
 
+    varray__sigparseclear(&sigparseworklist);
+
     dictionary_clear(&builtin_functiontable);
     dictionary_clear(&builtin_classtable);
     dictionary_clear(&builtin_symboltable);

src/builtin/builtin.h

@@ -16,6 +16,9 @@
 
 #include "signature.h"
 
+/** Call to pase method and function signatures */
+bool builtin_parsesignatures(void);
+
 /* -------------------------------------------------------
  * Built in function objects
  * ------------------------------------------------------- */

src/builtin/functiondefs.c

@@ -14,7 +14,7 @@
 #include "common.h"
 #include "cmplx.h"
 
-#include "matrix.h"
+#include "linalg.h"
 #include "sparse.h"
 
 #include "mesh.h"
@@ -324,7 +324,7 @@ value builtin_arctan(vm *v, int nargs, value *args) {
 
         morpho_runtimeerror(v, MATH_NUMARGS, "arctan");
         return MORPHO_NIL;
-    }
+    } 
 }
 
 /** Remainder */
@@ -747,7 +747,6 @@ void functiondefs_initialize(void) {
     /* Define errors */
     morpho_defineerror(MATH_ARGS, ERROR_HALT, MATH_ARGS_MSG);
     morpho_defineerror(MATH_NUMARGS, ERROR_HALT, MATH_NUMARGS_MSG);
-    morpho_defineerror(MATH_ATANARGS, ERROR_HALT, MATH_ATANARGS_MSG);
     morpho_defineerror(TYPE_NUMARGS, ERROR_HALT, TYPE_NUMARGS_MSG);
     morpho_defineerror(MAX_ARGS, ERROR_HALT, MAX_ARGS_MSG);
     morpho_defineerror(APPLY_ARGS, ERROR_HALT, APPLY_ARGS_MSG);

src/builtin/functiondefs.h

@@ -52,9 +52,6 @@
 #define MATH_NUMARGS                 "ExpctArgNm"
 #define MATH_NUMARGS_MSG             "Function '%s' expects a single numerical argument."
 
-#define MATH_ATANARGS                "AtanArgNm"
-#define MATH_ATANARGS_MSG            "Function 'arctan' expects either 1 or 2 numerical arguments."
-
 #define TYPE_NUMARGS                 "TypArgNm"
 #define TYPE_NUMARGS_MSG             "Function '%s' expects one argument."
 

src/classes/array.c

@@ -180,7 +180,7 @@ void array_print(vm *v, objectarray *a) {
 errorid array_error(objectarrayerror err) {
     switch (err) {
         case ARRAY_OUTOFBOUNDS: return VM_OUTOFBOUNDS;
-        case ARRAY_WRONGDIM: return VM_ARRAYWRONGDIM;
+        case ARRAY_WRONGDIM: return ARRAY_DIMENSION;
         case ARRAY_NONINTINDX: return VM_NONNUMINDX;
         case ARRAY_ALLOC_FAILED: return ERROR_ALLOCATIONFAILED;
         case ARRAY_OK: UNREACHABLE("array_error called incorrectly.");
@@ -193,9 +193,9 @@ errorid array_error(objectarrayerror err) {
 errorid array_to_matrix_error(objectarrayerror err) {
 #ifdef MORPHO_INCLUDE_LINALG
     switch (err) {
-        case ARRAY_OUTOFBOUNDS: return MATRIX_INDICESOUTSIDEBOUNDS;
-        case ARRAY_WRONGDIM: return MATRIX_INVLDNUMINDICES;
-        case ARRAY_NONINTINDX: return MATRIX_INVLDINDICES;
+        case ARRAY_OUTOFBOUNDS: return LINALG_INDICESOUTSIDEBOUNDS;
+        case ARRAY_WRONGDIM: return ARRAY_DIMENSION;
+        case ARRAY_NONINTINDX: return ARRAY_INVLDINDICES;
         case ARRAY_ALLOC_FAILED: return ERROR_ALLOCATIONFAILED;
         case ARRAY_OK: UNREACHABLE("array_to_matrix_error called incorrectly.");
     }
@@ -457,7 +457,7 @@ value array_constructor(vm *v, int nargs, value *args) {
         new = array_constructfromlist(ndim, dim, MORPHO_GETLIST(initializer));
         if (!new) morpho_runtimeerror(v, ARRAY_CMPT);
     } else {
-        morpho_runtimeerror(v, ARRAY_ARGS);
+        morpho_runtimeerror(v, ARRAY_INIT);
     }
 
     // Bind the new array to the VM
@@ -630,4 +630,6 @@ void array_initialize(void) {
     morpho_defineerror(ARRAY_ARGS, ERROR_HALT, ARRAY_ARGS_MSG);
     morpho_defineerror(ARRAY_INIT, ERROR_HALT, ARRAY_INIT_MSG);
     morpho_defineerror(ARRAY_CMPT, ERROR_HALT, ARRAY_CMPT_MSG);
+    morpho_defineerror(ARRAY_DIMENSION, ERROR_HALT, ARRAY_DIMENSION_MSG);
+    morpho_defineerror(ARRAY_INVLDINDICES, ERROR_HALT, ARRAY_INVLDINDICES_MSG);
 }

src/classes/array.h

@@ -65,6 +65,12 @@ objectarray *object_arrayfromvalueindices(unsigned int ndim, value *dim);
 #define ARRAY_CMPT                        "ArrayCmpt"
 #define ARRAY_CMPT_MSG                    "Array initializer is not compatible with the requested dimensions."
 
+#define ARRAY_DIMENSION                   "ArrayDim"
+#define ARRAY_DIMENSION_MSG               "Incorrect number of dimensions for Array."
+
+#define ARRAY_INVLDINDICES                "ArrayIndx"
+#define ARRAY_INVLDINDICES_MSG            "Array requires integers as indices."
+
 /* -------------------------------------------------------
  * Array interface
  * ------------------------------------------------------- */

src/classes/classes.h

@@ -35,6 +35,6 @@
 //#include "system.h"
 #include "json.h"
 
-#include "matrix.h"
+#include "linalg.h"
 
 #endif /* classes_h */

src/classes/clss.c

@@ -196,5 +196,4 @@ void class_initialize(void) {
     // No constructor function; classes are generated by the compiler
 
     // Class error messages
-    morpho_defineerror(CLASS_INVK, ERROR_HALT, CLASS_INVK_MSG);
 }

src/classes/clss.h

@@ -46,9 +46,6 @@ typedef struct sobjectclass {
  * Class error messages
  * ------------------------------------------------------- */
 
-#define CLASS_INVK                        "ClssInvk"
-#define CLASS_INVK_MSG                    "Cannot invoke method '%s' on a class."
-
 /* -------------------------------------------------------
  * Class interface
  * ------------------------------------------------------- */

src/classes/invocation.c

@@ -156,5 +156,4 @@ void invocation_initialize(void) {
 
     // Invocation error messages
     morpho_defineerror(INVOCATION_ARGS, ERROR_HALT, INVOCATION_ARGS_MSG);
-    morpho_defineerror(INVOCATION_METHOD, ERROR_HALT, INVOCATION_METHOD_MSG);
 }

src/classes/invocation.h

@@ -52,9 +52,6 @@ objectinvocation *object_newinvocation(value receiver, value method);
 #define INVOCATION_ARGS                   "InvocationArgs"
 #define INVOCATION_ARGS_MSG               "Invocation must be called with an object and a method name as arguments."
 
-#define INVOCATION_METHOD                 "InvocationMethod"
-#define INVOCATION_METHOD_MSG             "Method not found."
-
 /* -------------------------------------------------------
  * Invocation interface
  * ------------------------------------------------------- */

src/classes/list.c

@@ -130,35 +130,45 @@ int list_sortfunction(const void *a, const void *b) {
 }
 
 /** Sort the contents of a list */
-void list_sort(objectlist *list) {
-    qsort(list->val.data, list->val.count, sizeof(value), list_sortfunction);
+void list_sortcontents(value *values, size_t count) {
+    qsort(values, count, sizeof(value), list_sortfunction);
 }
 
-static vm *list_sortwithfn_vm;
-static value list_sortwithfn_fn;
-static bool list_sortwithfn_err;
-
-/** Sort function for list_sort */
-int list_sortfunctionwfn(const void *a, const void *b) {
-    value args[2] = {*(value *) a, *(value *) b};
-    value ret;
+/** Sort the contents of a list */
+void list_sort(objectlist *list) {
+    list_sortcontents(list->val.data, list->val.count);
+}
 
-    if (morpho_call(list_sortwithfn_vm, list_sortwithfn_fn, 2, args, &ret)) {
+/** Sort the contents of a list using a re-entrant comparison function */
+typedef struct {
+    vm *v;
+    value cmpfn;
+    bool errq;
+} _sortfninfo;
+
+static int _sortfn(const void *a, const void *b, void *context) {
+    _sortfninfo *info = (_sortfninfo *) context;
+    value ret, args[2] = {*(value *) a, *(value *) b};
+
+    if (morpho_call(info->v, info->cmpfn, 2, args, &ret)) {
         if (MORPHO_ISINTEGER(ret)) return MORPHO_GETINTEGERVALUE(ret);
         if (MORPHO_ISFLOAT(ret)) return morpho_comparevalue(MORPHO_FLOAT(0), ret);
     }
-
-    list_sortwithfn_err=true;
+    
+    info->errq=true;
     return 0;
 }
 
+/** Sort a list of values */
+bool list_sortcontentswithfn(vm *v, value cmpfn, value *values, size_t count) {
+    _sortfninfo info = { .v = v, .cmpfn = cmpfn, .errq=false };
+    platform_qsort_r(values, count, sizeof(value), &info, _sortfn);
+    return !info.errq;
+}
+
 /** Sort the contents of a list */
-bool list_sortwithfn(vm *v, value fn, objectlist *list) {
-    list_sortwithfn_vm=v;
-    list_sortwithfn_fn=fn;
-    list_sortwithfn_err=false;
-    qsort(list->val.data, list->val.count, sizeof(value), list_sortfunctionwfn);
-    return !list_sortwithfn_err;
+bool list_sortwithfn(vm *v, value cmpfn, objectlist *list) {
+    return list_sortcontentswithfn(v, cmpfn, list->val.data, list->val.count);
 }
 
 /** Sort function for list_order */
@@ -612,21 +622,6 @@ value List_roll(vm *v, int nargs, value *args) {
     return out;
 }
 
-/** Sorts a list */
-value XList_sort(vm *v, int nargs, value *args) {
-    objectlist *slf = MORPHO_GETLIST(MORPHO_SELF(args));
-
-    if (nargs==0) {
-        list_sort(slf);
-    } else if (nargs==1 && MORPHO_ISCALLABLE(MORPHO_GETARG(args, 0))) {
-        if (!list_sortwithfn(v, MORPHO_GETARG(args, 0), slf)) {
-            morpho_runtimeerror(v, LIST_SRTFN);
-        }
-    }
-
-    return MORPHO_NIL;
-}
-
 /** Sorts a list */
 value List_sort(vm *v, int nargs, value *args) {
     list_sort(MORPHO_GETLIST(MORPHO_SELF(args)));

src/classes/list.h

@@ -77,7 +77,11 @@ bool list_resize(objectlist *list, int size);
 void list_append(objectlist *list, value v);
 unsigned int list_length(objectlist *list);
 bool list_getelement(objectlist *list, int i, value *out);
+void list_sortcontents(value *values, size_t count);
 void list_sort(objectlist *list);
+bool list_sortcontentswithfn(vm *v, value cmpfn, value *values, size_t count);
+bool list_sortwithfn(vm *v, value cmpfn, objectlist *list);
+
 objectlist *list_clone(objectlist *list);
 
 void list_initialize(void);

src/classes/tuple.c

@@ -257,6 +257,33 @@ value Tuple_join(vm *v, int nargs, value *args) {
     return out;
 }
 
+/** Sorts the contents of a tuple, returning a new tuple */
+value Tuple_sort(vm *v, int nargs, value *args) {
+    objecttuple *src = MORPHO_GETTUPLE(MORPHO_SELF(args));
+
+    objecttuple *new = object_newtuple(src->length, src->tuple);
+    if (new) list_sortcontents(new->tuple, new->length);
+
+    return morpho_wrapandbind(v, (object *) new);
+}
+
+/** Sorts the contents of a tuple using a comparison function, returning a new tuple */
+value Tuple_sort_fn(vm *v, int nargs, value *args) {
+    objecttuple *src = MORPHO_GETTUPLE(MORPHO_SELF(args));
+
+    objecttuple *new=object_newtuple(src->length, src->tuple);
+    if (new) {
+        bool success=list_sortcontentswithfn(v, MORPHO_GETARG(args, 0), new->tuple, new->length);
+        if (!success) {
+            morpho_runtimeerror(v, LIST_SRTFN);
+            object_free((object *) new);
+            return MORPHO_NIL;
+        }
+    }
+
+    return morpho_wrapandbind(v, (object *) new);
+}
+
 /** Tests if a tuple has a value as a member */
 value Tuple_ismember(vm *v, int nargs, value *args) {
     objecttuple *slf = MORPHO_GETTUPLE(MORPHO_SELF(args));
@@ -276,6 +303,8 @@ MORPHO_METHOD(MORPHO_GETINDEX_METHOD, Tuple_getindex, BUILTIN_FLAGSEMPTY),
 MORPHO_METHOD(MORPHO_SETINDEX_METHOD, Tuple_setindex, BUILTIN_FLAGSEMPTY),
 MORPHO_METHOD(MORPHO_ENUMERATE_METHOD, Tuple_enumerate, BUILTIN_FLAGSEMPTY),
 MORPHO_METHOD_SIGNATURE(MORPHO_JOIN_METHOD, "Tuple (_)", Tuple_join, BUILTIN_FLAGSEMPTY),
+MORPHO_METHOD_SIGNATURE(LIST_SORT_METHOD, "Tuple ()", Tuple_sort, BUILTIN_FLAGSEMPTY),
+MORPHO_METHOD_SIGNATURE(LIST_SORT_METHOD, "Tuple (_)", Tuple_sort_fn, BUILTIN_FLAGSEMPTY),
 MORPHO_METHOD_SIGNATURE(LIST_ISMEMBER_METHOD, "Bool (_)", Tuple_ismember, BUILTIN_FLAGSEMPTY),
 MORPHO_METHOD_SIGNATURE(MORPHO_CONTAINS_METHOD, "Bool (_)", Tuple_ismember, BUILTIN_FLAGSEMPTY)
 MORPHO_ENDCLASS