Merge pull request #189 from corywalker/corywalker

Corywalker

expreduce/atoms/ex_expression.go

@@ -274,6 +274,15 @@ func newEmptyExpressionOfLength(n int) *Expression {
 	}
 }
 
+// NewStringList transforms a list of strings in Go format into Expreduce format.
+func NewStringList(items []string) *Expression {
+	list := NewHead("System`List")
+	for _, item := range items {
+		list.AppendEx(NewString(item))
+	}
+	return list
+}
+
 func (thisExpr *Expression) GetParts() []expreduceapi.Ex {
 	return thisExpr.Parts
 }

expreduce/atoms/gob.go

@@ -0,0 +1,14 @@
+package atoms
+
+import "encoding/gob"
+
+// RegisterGobAtoms performs gob registration for the atoms package.
+func RegisterGobAtoms() {
+	gob.RegisterName("E", &Expression{})
+	gob.RegisterName("S", &Symbol{})
+	gob.RegisterName("C", &Complex{})
+	gob.RegisterName("I", &Integer{})
+	gob.RegisterName("R", &Rational{})
+	gob.RegisterName("F", &Flt{})
+	gob.RegisterName("T", &String{})
+}

expreduce/builtin_rubi.go

@@ -5,5 +5,13 @@ func getRubiDefinitions() (defs []Definition) {
 		Name:              "LoadRubi",
 		expreduceSpecific: true,
 	})
+	defs = append(defs, Definition{
+		Name:              "LoadRubiSnapshot",
+		expreduceSpecific: true,
+	})
+	defs = append(defs, Definition{
+		Name:              "SaveRubiSnapshot",
+		expreduceSpecific: true,
+	})
 	return
 }

expreduce/builtin_system.go

@@ -1,13 +1,17 @@
 package expreduce
 
 import (
+	"bytes"
+	"encoding/gob"
 	"flag"
 	"fmt"
 	"io/ioutil"
 	"log"
 	"math/big"
 	"os"
+	"regexp"
 	"runtime/pprof"
+	"sort"
 	"strings"
 	"time"
 
@@ -19,6 +23,13 @@ import (
 
 var mymemprofile = flag.String("mymemprofile", "", "write memory profile to this file")
 
+var exprFileHeader = []byte{26, 166, 245, 29, 69, 251, 144, 0}
+
+type encodedDef struct {
+	Name string
+	Def  expreduceapi.Def
+}
+
 func hashEx(e expreduceapi.Ex) uint64 {
 	return e.Hash()
 }
@@ -69,19 +80,19 @@ func exprToN(es expreduceapi.EvalStateInterface, e expreduceapi.Ex) expreduceapi
 	return e.DeepCopy()
 }
 
-func tryReadFile(fn expreduceapi.Ex, es expreduceapi.EvalStateInterface) (string, string, bool) {
+func tryReadFile(fn expreduceapi.Ex, es expreduceapi.EvalStateInterface) ([]byte, string, bool) {
 	pathSym := atoms.NewSymbol("System`$Path")
 	path, isDef, _ := es.GetDef("System`$Path", pathSym)
 	if !isDef {
-		return "", "", false
+		return []byte{}, "", false
 	}
 	pathL, pathIsList := atoms.HeadAssertion(path, "System`List")
 	if !pathIsList {
-		return "", "", false
+		return []byte{}, "", false
 	}
 	filenameString, fnIsStr := fn.(*atoms.String)
 	if !fnIsStr {
-		return "", "", false
+		return []byte{}, "", false
 	}
 	rawFn := filenameString.Val
 
@@ -90,7 +101,7 @@ func tryReadFile(fn expreduceapi.Ex, es expreduceapi.EvalStateInterface) (string
 
 		fileData, err := Asset("resources/" + rawFn[8:])
 		if err == nil {
-			return string(fileData), rawFn, true
+			return fileData, rawFn, true
 		}
 	}
 
@@ -111,10 +122,9 @@ func tryReadFile(fn expreduceapi.Ex, es expreduceapi.EvalStateInterface) (string
 		if err != nil {
 			continue
 		}
-		fileData := string(dat)
-		return fileData, rawPath, true
+		return dat, rawPath, true
 	}
-	return "", "", false
+	return []byte{}, "", false
 }
 
 func snagUnique(context string, prefix string, es expreduceapi.EvalStateInterface) (string, bool) {
@@ -640,7 +650,77 @@ func getSystemDefinitions() (defs []Definition) {
 			if !ok {
 				return atoms.NewSymbol("System`$Failed")
 			}
-			return EvalInterpMany(fileData, rawPath, es)
+			if len(fileData) >= len(exprFileHeader) && bytes.Equal(fileData[:len(exprFileHeader)], exprFileHeader) {
+
+				// TODO: Read as a stream and not a byte string.
+				r := bytes.NewReader(fileData[len(exprFileHeader):])
+				atoms.RegisterGobAtoms()
+				decoder := gob.NewDecoder(r)
+				definitions := []encodedDef{}
+				if err := decoder.Decode(&definitions); err != nil {
+					panic(err)
+				}
+
+				for _, def := range definitions {
+					es.SetDefined(def.Name, def.Def)
+				}
+
+				return atoms.NewSymbol("System`Null")
+			}
+			return EvalInterpMany(string(fileData), rawPath, es)
+		},
+	})
+	defs = append(defs, Definition{
+		Name: "Save",
+		legacyEvalFn: func(this expreduceapi.ExpressionInterface, es expreduceapi.EvalStateInterface) expreduceapi.Ex {
+			if this.Len() != 2 {
+				return this
+			}
+
+			filenameStr, ok := this.GetPart(1).(*atoms.String)
+			if !ok {
+				return this
+			}
+			filename := filenameStr.GetValue()
+
+			definitions := []encodedDef{}
+			symList, ok := atoms.HeadAssertion(this.GetPart(2), "System`List")
+			if !ok {
+				return this
+			}
+			for _, symEx := range symList.GetParts()[1:] {
+				symStr, symIsStr := symEx.(*atoms.String)
+				if !symIsStr {
+					return this
+				}
+				symName := symStr.GetValue()
+				def, ok := es.GetDefined(symName)
+				if !ok {
+					return this
+				}
+				definitions = append(definitions, encodedDef{
+					Name: symName,
+					Def:  def,
+				})
+			}
+			if len(definitions) == 0 {
+				return this
+			}
+
+			atoms.RegisterGobAtoms()
+
+			file, err := os.Create(filename)
+			if err == nil {
+				// Write the header.
+				file.Write(exprFileHeader)
+				encoder := gob.NewEncoder(file)
+				if err := encoder.Encode(definitions); err != nil {
+					panic(err)
+				}
+			}
+			file.Close()
+
+			return atoms.NewSymbol("System`Null")
 		},
 	})
 	defs = append(defs, Definition{
@@ -692,7 +772,7 @@ func getSystemDefinitions() (defs []Definition) {
 			if !ok {
 				return atoms.NewSymbol("System`$Failed")
 			}
-			return ReadList(fileData, rawPath, es)
+			return ReadList(string(fileData), rawPath, es)
 		},
 	})
 	defs = append(defs, Definition{Name: "BeginPackage"})
@@ -841,5 +921,34 @@ func getSystemDefinitions() (defs []Definition) {
 			return es.GetStreamManager().AsExpr()
 		},
 	})
+	defs = append(defs, Definition{
+		Name: "Names",
+		legacyEvalFn: func(this expreduceapi.ExpressionInterface, es expreduceapi.EvalStateInterface) expreduceapi.Ex {
+			regex := ""
+			if this.Len() == 0 {
+				regex = ".*"
+			}
+			if this.Len() == 1 {
+				filter, filterIsString := this.GetPart(1).(*atoms.String)
+				if filterIsString {
+					replacedVal := strings.Replace(filter.GetValue(), "*", ".*", -1)
+					regex = "^" + replacedVal + "$"
+				}
+			}
+			if regex == "" {
+				fmt.Println("Unsupported call to Names.")
+				return this
+			}
+			var namesRegex = regexp.MustCompile(regex)
+			names := []string{}
+			for _, name := range es.GetDefinedMap().Keys() {
+				if namesRegex.MatchString(name) {
+					names = append(names, name)
+				}
+			}
+			sort.Strings(names)
+			return atoms.NewStringList(names)
+		},
+	})
 	return
 }

expreduce/definition_map.go

@@ -45,6 +45,10 @@ func (dm threadSafeDefinitionMap) UnlockKey(key string) {
 	shard.Unlock()
 }
 
+func (dm threadSafeDefinitionMap) Keys() []string {
+	return dm.internalMap.Keys()
+}
+
 func (dm threadSafeDefinitionMap) CopyDefs() expreduceapi.DefinitionMap {
 	out := newDefinitionMap()
 	for mapTuple := range dm.internalMap.IterBuffered() {

expreduce/evalstate.go

@@ -39,6 +39,10 @@ func (es *EvalState) GetDefined(name string) (expreduceapi.Def, bool) {
 	return es.GetDefinedMap().Get(name)
 }
 
+func (es *EvalState) SetDefined(name string, def expreduceapi.Def) {
+	es.GetDefinedMap().Set(name, def)
+}
+
 func (es *EvalState) GetStringFn(headStr string) (expreduceapi.ToStringFnType, bool) {
 	fn, ok := es.toStringFns[headStr]
 	return fn, ok

expreduce/resources/rubi.m

@@ -20,3 +20,10 @@
         ESameTest[-(3/8) ArcTanh[Cos[a+x]]-3/8 Cot[a+x] Csc[a+x]-1/4 Cot[a+x] Csc[a+x]^3, Rubi`Int[csc[a+x]^5,x]],
     ]
 };
+
+expreduceRubiSnapshotLoc = "/tmp/rubi.expred";
+LoadRubiSnapshot[] := (
+  Get[expreduceRubiSnapshotLoc];
+  $ContextPath = Prepend[$ContextPath, "Rubi`"];
+);
+SaveRubiSnapshot[] := Save[expreduceRubiSnapshotLoc, "Rubi`*"];

expreduce/resources/system.m

@@ -127,6 +127,10 @@
 Get::usage = "`Get[file]` loads `file` and returns the last expression.";
 Attributes[Get] = {Protected};
 
+Save::usage = "`Save[filename, {sym1, sym2, ...}]` saves a list of symbols into a file."
+Save[fn_String, pattern_String] := Save[fn, syms] /. syms -> Names[pattern];
+Attributes[Save] = {HoldRest, Protected};
+
 Module::usage = "`Module[{locals}, expr]` evaluates `expr` with the local variables `locals`.";
 Attributes[Module] = {HoldAll, Protected};
 Tests`Module = {
@@ -353,3 +357,13 @@
         ESameTest[{OutputStream["stdout", 1], OutputStream["stderr", 2]}, Streams[]],
     ]
 };
+
+Names::usage = "`Names[]` returns a list of all defined symbols.
+
+`Names[\"pattern\"]` returns a list of all defined symbols matching the regex pattern.";
+Attributes[Names] = {Protected};
+Tests`Names = {
+    ETests[
+        ESameTest[True, Length[Names[]] > 1],
+    ]
+};

pkg/expreduceapi/cas.go

@@ -48,6 +48,7 @@ type EvalStateInterface interface {
 	Eval(expr Ex) Ex
 
 	GetDefined(name string) (Def, bool)
+	SetDefined(name string, def Def)
 	GetStringFn(headStr string) (ToStringFnType, bool)
 	Init(loadAllDefs bool)
 	IsDef(name string) bool
@@ -107,6 +108,7 @@ type DefinitionMap interface {
 	GetDef(key string) Def
 	LockKey(key string)
 	UnlockKey(key string)
+	Keys() []string
 	CopyDefs() DefinitionMap
 }