aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--journal/21jan2009.html23
-rw-r--r--other/all.py43
-rw-r--r--other/mitscheme.py353
-rw-r--r--other/sage-scheme-notes.txt37
4 files changed, 452 insertions, 4 deletions
diff --git a/journal/21jan2009.html b/journal/21jan2009.html
index d451c90..72ab84b 100644
--- a/journal/21jan2009.html
+++ b/journal/21jan2009.html
@@ -46,6 +46,29 @@ the best way to "do" scheme.
In other news I just learned the vim command I was missing: <code>gq}</code>
will rewrap the current paragraph to ~70 columns width; <code>gq</code> will do
the same to the current selection in visual mode. FINALLY.
+<hr />
+Got mechanics sort of running in sage. Was able to plot and (se ...) from
+within the browser notebook interface which was a... strange experience.
+<p />
+See <a href="../other/sage-scheme-notes.txt">sage-scheme-notes.txt</a> for
+installation instructions...
+<p />
+I should either write up a patch or submit a bug/request for a --version
+flag for mit-scheme, it needs one!
+
+<p />Todo for scmutils in sage:
+<span style="color:red;">
+<ul>
+ <li />Handle multiline inputs properly (now echos a lot)
+ <li />Handle multiple S-expressions in one notebook cell
+ <li />Either basic wrappers or reimplementations for (se ...) and the plotting
+ functions so their results will pop up in the notebook
+ <li />Interact examples!
+ <li />Either drop or finish object wrapping... maybe look through the other
+ interface examples more carefully?
+ <li />Wrap as an .spkg? Compilation issues on other platforms? Documentation
+ and tests?
+</ul>
<br /><br />
<a href="19jan2009.html"><i>(previous entry)</i></a>
diff --git a/other/all.py b/other/all.py
new file mode 100644
index 0000000..33e2717
--- /dev/null
+++ b/other/all.py
@@ -0,0 +1,43 @@
+# interfaces to other interpreters
+
+from frobby import frobby
+from axiom import Axiom, axiom, axiom_console
+
+from expect import is_ExpectElement
+from gap import gap, gap_reset_workspace, gap_console, gap_version, is_GapElement, Gap
+from genus2reduction import genus2reduction, Genus2reduction
+from gfan import gfan, Gfan
+from gp import gp, gp_console, gp_version, is_GpElement, Gp
+from gnuplot import gnuplot, gnuplot_console
+from kash import kash, kash_console, kash_version, is_KashElement, Kash
+from lisp import lisp, lisp_console, Lisp
+from magma import magma, magma_console, magma_version, Magma, is_MagmaElement
+from magma_free import magma_free
+from macaulay2 import macaulay2, macaulay2_console, Macaulay2
+from maple import maple, maple_console, Maple
+from maxima import maxima, maxima_console, is_MaximaElement, Maxima
+from mathematica import mathematica, mathematica_console, Mathematica
+from matlab import matlab, matlab_console, matlab_version, Matlab
+from mitscheme import mitscheme, mitscheme_console, MitScheme
+from mupad import mupad, mupad_console, Mupad # NOT functional yet
+from mwrank import mwrank, Mwrank, mwrank_console
+from octave import octave, octave_console, octave_version, Octave
+from qepcad import qepcad, qepcad_console, qepcad_version, qepcad_formula
+from qsieve import qsieve
+from scm import scm, scm_console, SCM
+from singular import singular, singular_console, singular_version, is_SingularElement, Singular
+from sage0 import sage0 as sage0, sage0_console, sage0_version, Sage
+from tachyon import tachyon_rt
+from psage import PSage
+from ecm import ECM, ecm
+from povray import povray
+from lie import lie, lie_console, LiE
+from r import r, r_console, R, r_version, is_RElement
+
+# signal handling
+from get_sigs import *
+
+interfaces = ['gap', 'gp', 'mathematica', 'gnuplot', \
+ 'kash', 'magma', 'macaulay2', 'maple', 'maxima', \
+ 'mathematica', 'mitscheme', 'mwrank', 'octave', 'r', \
+ 'singular', 'sage0', 'sage', 'scm']
diff --git a/other/mitscheme.py b/other/mitscheme.py
new file mode 100644
index 0000000..826f26e
--- /dev/null
+++ b/other/mitscheme.py
@@ -0,0 +1,353 @@
+r"""nodoctest [[remove the nodoctest, so doctests will run]]
+Interface Template
+
+[[Describe the math software you are interfacing with here.]]
+
+[[Replace this by something relevant to your system.]]
+ Type \code{gp.[tab]} for a list of all the functions available
+ from your Gp install. Type \code{gp.[tab]?} for Gp's
+ help about a given function. Type \code{gp(...)} to create
+ a new Gp object, and \code{gp.eval(...)} to run a string
+ using Gp (and get the result back as a string).
+
+
+EXAMPLES:
+
+[[Go through a standard tutorial for your software package
+and do it via your SAGE interface.]]
+
+AUTHORS:
+ -- William Stein (template)
+"""
+
+##########################################################################
+#
+# Copyright (C) 2006 William Stein <wstein@gmail.com>
+#
+# Distributed under the terms of the GNU General Public License (GPL)
+#
+# http://www.gnu.org/licenses/
+#
+##########################################################################
+
+from __future__ import with_statement
+from expect import Expect, ExpectElement, ExpectFunction, FunctionElement, gc_disabled
+from sage.misc.misc import verbose
+
+class MitScheme(Expect):
+ """
+ [[Some basic help about your system. This is what
+ will be displayed when somebody write mitscheme?.]]
+ """
+ def __init__(self,
+ maxread=100000, script_subdirectory=None,
+ logfile=None,
+ server=None,
+ server_tmpdir=None):
+ Expect.__init__(self,
+
+ # The capitalized version of this is used for printing.
+ name = 'MIT/GNU Scheme',
+
+ # This is regexp of the input prompt. If you can change
+ # it to be very obfuscated that would be better. Even
+ # better is to use sequence numbers.
+ prompt = '\d? \]=> ',
+
+ # This is the command that starts up your program
+ command = "/usr/local/scmutils/mit-scheme/bin/scheme --library /usr/local/scmutils/mit-scheme/lib/ --heap 12000 --band edwin-mechanics.com",
+ #command = "mit-scheme",
+
+ maxread = maxread,
+
+ server=server,
+ server_tmpdir=server_tmpdir,
+
+ script_subdirectory = script_subdirectory,
+
+ # If this is true, then whenever the user presses Control-C to
+ # interrupt a calculation, the whole interface is restarted.
+ restart_on_ctrlc = True,
+
+ # If true, print out a message when starting
+ # up the command when you first send a command
+ # to this interface.
+ verbose_start = True,
+
+ logfile=logfile,
+
+ # If an input is longer than this number of characters, then
+ # try to switch to outputing to a file.
+ eval_using_file_cutoff=1024)
+
+ self.__seq = 0
+ self.eval('(set! standard-error-hook (lambda (x) (begin (warn x) (cmdl-interrupt/abort-top-level))))')
+
+ def chdir(self, dir):
+ raise NotImplemented
+
+ def eval(self, code, strip=True, synchronize=False, **kwds):
+ """
+ For Scheme, don't listen for prompt except for the last line
+ Also, for MIT/GNU Scheme strip the ;Value: part of results
+
+ INPUT:
+ code -- text to evaluate
+ strip -- bool; whether to strip output prompts, etc.
+ (ignored in the base class).
+ **kwds -- All other arguments are passed onto the _eval_line method.
+ An often useful example is reformat=False.
+ """
+ if synchronize:
+ try:
+ self._synchronize()
+ except AttributeError:
+ pass
+
+ if strip:
+ try:
+ code = self._strip_prompt(code)
+ except AttributeError:
+ pass
+
+ if not isinstance(code, basestring):
+ raise TypeError, 'input code must be a string.'
+
+ #Remove extra whitespace
+ code = code.strip()
+
+ try:
+ with gc_disabled():
+ return self._strip_prompt(self._eval_line(code, **kwds))
+ except KeyboardInterrupt:
+ # DO NOT CATCH KeyboardInterrupt, as it is being caught
+ # by _eval_line
+ # In particular, do NOT call self._keyboard_interrupt()
+ raise
+ except TypeError, s:
+ raise TypeError, 'error evaluating "%s":\n%s'%(code,s)
+
+ def _strip_prompt(self, code):
+ return code.strip().replace(';Value: ','')
+
+ def _repr_(self):
+ return 'MIT/GNU Scheme Interpreter'
+
+ def __reduce__(self):
+ return reduce_load_mitscheme, tuple([])
+
+ def __getattr__(self, attrname):
+ if attrname[:1] == "_":
+ raise AttributeError
+ return MitSchemeFunction(self, attrname)
+
+ def _quit_string(self):
+ return '(quite)'
+
+ def _read_in_file_command(self, filename):
+ raise NotImplementedError
+
+ def trait_names(self):
+ ## [[implement giving a list of all functions and identifiers in the system]]
+ raise NotImplementedError
+
+ def read(self, filename):
+ # [[implement loading of the contents of filename into the system]]
+ raise NotImplementedError
+
+
+ def kill(self, var):
+ # [[send code that kills the variable with given name in the system.]]
+ pass
+
+ def console(self):
+ # run the console command (defined below).
+ mitscheme_console()
+
+ def version(self):
+ # run the version command (defined below)
+ pass
+
+ def _object_class(self):
+ return MitSchemeElement
+
+ def _left_list_delim(self):
+ raise NotImplementedError
+
+ def _right_list_delim(self):
+ raise NotImplementedError
+
+ def _assign_symbol(self):
+ raise NotImplementedError
+
+ def _true_symbol(self):
+ # return the string rep of truth, i.e., what the system outputs
+ # when you type 1==1.
+ return '#t'
+
+ def _false_symbol(self):
+ # return the string rep of truth, i.e., what the system outputs
+ # when you type 1==2.
+ return '#f'
+
+ def _equality_symbol(self):
+ # return the symbol for checking equality, e.g., == or eq.
+ raise NotImplementedError
+
+ def help(self, command):
+ # return help on a given command.
+ raise NotImplementedError
+
+ def set(self, var, value):
+ """
+ Set the variable var to the given value.
+ """
+ cmd = '(define %s %s)'%(var, value)
+ self.eval(cmd)
+
+ def get(self, var):
+ """
+ Get the value of the variable var.
+ """
+ cmd = '%s'%var
+ return self.eval(var)
+
+ def function_call(self, function, args=[], kwds={}):
+ """
+ EXAMPLES:
+ sage: maxima.quad_qags(x, x, 0, 1, epsrel=1e-4)
+ [0.5,5.5511151231257...E-15,21,0]
+ sage: maxima.function_call('quad_qags', [x, x, 0, 1], {'epsrel':'1e-4'})
+ [0.5,5.5511151231257...E-15,21,0]
+ """
+ if function == '':
+ raise ValueError, "function name must be nonempty"
+ if function[:2] == "__":
+ raise AttributeError
+ if not isinstance(args, list):
+ args = [args]
+ for i in range(len(args)):
+ if not isinstance(args[i], ExpectElement):
+ args[i] = self.new(args[i])
+ for key, value in kwds.iteritems():
+ kwds[key] = self.new(value)
+
+ return self.new("(%s %s)"%(function, " ".join([s.name() for s in args]+
+ ['%s'%(key,value.name()) for key, value in kwds.items()])))
+
+
+class MitSchemeElement(ExpectElement):
+ """
+ Describe elements of your system here.
+ """
+ def trait_names(self):
+ # This is if your system doesn't really have types. If you have types
+ # this function should only return the relevant methods that take self
+ # as their first argument.
+ return self.parent().trait_names()
+
+ def __cmp__(self, other):
+ P = self.parent()
+ if P.eval("(eq? %s %s)"%(self.name(), other.name())) == P._true_symbol():
+ return 0
+ elif P.eval("(< %s %s)"%(self.name(), other.name())) == P._true_symbol():
+ return -1
+ elif P.eval("(> %s %s)"%(self.name(), other.name())) == P._true_symbol():
+ return 1
+
+ # everything is supposed to be comparable in Python, so we define
+ # the comparison thus when no comparable in interfaced system.
+ if (hash(self) < hash(other)):
+ return -1
+ else:
+ return 1
+
+ def hasattr(self, attrname):
+ """
+ Scheme things don't have attributes (unless SOS...)
+ """
+ raise NotImplementedError
+
+ def attribute(self, attrname):
+ """
+ Scheme things don't have attributes (unless SOS...)
+ """
+ raise NotImplementedError
+
+ def __getitem__(self, n):
+ """
+ Scheme things don't have attributes (unless SOS...)
+ """
+ raise NotImplementedError
+
+ def bool(self):
+ P = self.parent()
+ t = P._true_symbol()
+ cmd = '%s'%self._name
+ return P.eval(cmd) == t
+
+ def __nonzero__(self):
+ """
+ EXAMPLES:
+ sage: bool(mitscheme('#t'))
+ True
+ sage: bool(mitscheme('#f'))
+ False
+ """
+ P = self.parent()
+ t = P._true_symbol()
+ cmd = '(zero? %s)'%self._name
+ return P.eval(cmd) == t
+
+ def _operation(self, operation, right):
+ P = self._check_valid()
+ try:
+ return P.new('(%s %s %s)'%(operation, self._name, right._name))
+ except Exception, msg:
+ raise TypeError, msg
+
+ def __pow__(self, n):
+ """
+ EXAMPLES:
+ sage: a = maxima('2')
+ sage: a^(3/4)
+ 2^(3/4)
+ """
+ P = self._check_valid()
+ if not hasattr(n, 'parent') or P is not n.parent():
+ n = P(n)
+ return self._operation("expt", n)
+
+
+class MitSchemeFunctionElement(FunctionElement):
+ def _sage_doc_(self):
+ M = self._obj.parent()
+ return M.help(self._name)
+
+
+class MitSchemeFunction(ExpectFunction):
+ def _sage_doc_(self):
+ M = self._parent
+ return M.help(self._name)
+
+
+def is_MitSchemeElement(x):
+ return isinstance(x, MitSchemeElement)
+
+# An instance
+mitscheme = MitScheme()
+
+def reduce_load_MitScheme():
+ return mitscheme
+
+import os
+def mitscheme_console():
+ # This will only spawn local processes
+ os.system('mitscheme')
+
+
+def mitscheme_version():
+ """
+ UGH hard to implement
+ """
+ raise NotImplemented
diff --git a/other/sage-scheme-notes.txt b/other/sage-scheme-notes.txt
index 0b88a90..b366683 100644
--- a/other/sage-scheme-notes.txt
+++ b/other/sage-scheme-notes.txt
@@ -1,9 +1,38 @@
+scm or MIT/GNU Scheme in Sage
+=======================================
-in sage-###/devel/sage/sage/interfaces/, copy template.py to mitscheme.py
-edit all.py and add appropriate objects, strings
+First install scm, MIT/GNU Scheme, or scmutils on your system. If you're doing
+scmutils do it in /usr/local/ as recommended.
-then compile everything:
-./sage -b
+Then copy mitscheme.py and/or scm.py to SAGE_ROOT/devel/sage/sage/interfaces/
+and edit all.py to include the lines:
+ from mitscheme import mitscheme, mitscheme_console, MitScheme
+ from scm import scm, scm_console, SCM
+and edit the list of interfaces to include 'scm' and 'mitscheme'. For notebook
+cell use, edit SAGE_ROOT/devel/sage/server/notebook/notebook.py and add
+'scm (optional)' and 'scmutils (optional)' to the list of interfaces.
+If you want plain mit-scheme instead of all the scmutils packages, edit
+mitscheme.py and replace the long 'command' declaration near the top with the
+short commented out declaration.
+
+Then return to your root sage directory (SAGE_ROOT) and do:
+
+ $ ./sage -b
+
+See if it works, eg:
+
+ sage: m = MitScheme()
+ Starting MIT/GNU Scheme Interpreter
+ sage: m.eval('(+ 1 1)')
+ '2'
+ sage: one = mitscheme(1)
+ '1'
+ sage: two = mitscheme(2)
+ '2'
+ sage: one + two
+ '3'
+
+Much to do!