Aldor and SPAD allow domains to have parameters. For example
let's generalize the previous Complex domain to form complex
numbers over any ring.
First define a simple category MyRing and two domains that satisfy
this category.
\begin{aldor}[myring]
#pile
#include "axiom.as"
define MyRing: Category == with
0: %
-: % -> %
-: (%,%) -> %
+: (%,%) -> %
*: (%,%) -> %
coerce: % -> OutputForm
MyInteger: MyRing with
coerce: Integer -> %
== Integer add
coerce(i: Integer): % == i pretend %
MyFloat: MyRing with
coerce: Float -> %
== Float add
coerce(i: Float): % == i pretend %
\end{aldor}
Now we can define the domain Complex2 which takes a ring as
parameter. Such a domain is sometimes called a functor since
it behaves as a function mapping a category into a category.
\begin{aldor}
#pile
#include "axiom.as"
#library myring "myring.ao";
import from myring
Complex2(R: MyRing): MyRing with
new: (R,R) -> %
coerce: R -> %
real: % -> R
imag: % -> R
== add
Rep == Record(r:R,i:R)
import from Rep, R, OutputForm, Symbol
new(realpart:R,imagpart:R):% == per [realpart,imagpart]
0: % == new(0,0)
coerce(x:R):% == new(x,0)
real(x:%):R == rep(x).r
imag(x:%):R == rep(x).i
(x:%) + (y:%):% == new(real(x)+real(y), imag(x)+imag(y))
(x:%) - (y:%):% == new(real(x)-real(y), imag(x)-imag(y))
-(x:%):% == new(-real(x), -imag(x))
(x:%) (y:%):% == new(real(x)real(y) - imag(x)imag(y),
real(x)imag(y) + imag(x)*real(y))
local i: OutputForm == outputForm(i)
macro OUT == OutputForm
coerce(x:%):OUT ==
if R has with {<: (%,%) -> Boolean} then
import from R
if imag x < 0 then
[real(x)::OUT - (-imag(x))::OUT * i]
else
[real(x)::OUT + imag(x)::OUT * i]
else
[real(x)::OUT + (imag(x)::OUT) * i]
\end{aldor}
\begin{axiom}
macro CI == Complex2 MyInteger;
a: CI := new(2, 1)
b: CI := new(0, 3)
c: CI := a + b
\end{axiom}
Note that the inner and the outer appearance of the imaginary i are treated as different entities with similar properties.
\begin{axiom}
macro CCI == Complex2 CI;
a: CI := new(2, 1)
b: CI := new(0, 3)
c: CI := a + b
u: CCI := new(a, b)
v: CCI := new(a, c)
u - v
u v
\end{axiom}
\begin{axiom}
ii: CI := new(0,1)
innerI: CCI := new(ii, 0)
outerI: CCI := new(0, 1)
innerI outerI
\end{axiom}
Obviously Complex2 Complex2 MyInteger rather behaves like
quaternions, but not exactly, since:
innerI*outerI = outerI*innerI
\begin{axiom}
macro CF == Complex2 MyFloat?;
macro CCF == Complex2 CF
new(new(1.0,2.0)$CF,new(3.0,-4.0)$CF)$CCF
\end{axiom}
So now how would we do this in Python?
First of all, notice that since Python in dynamically typed,
i.e. it is the values that carry the types, not the variables,
so it is not necessary to specify any type parameter to the
class. In the original code we only implicitly required that
the values passed to the __init__ parameters, realpart and
imagpart support certain methods, namely: -, +, *, < and 0.
So if we wish to write:
Complex2(Complex2(1.0,2.0),Complex2(3.0,-4.0))
then all we need to do is add operators for -, take care of
the case where we may not have a < operator and call __str__
directly to get the printed form.
\begin{sageblock}
class Complex2:
"Example to demonstrate SPAD equivalent of Python Classes"
def __init__(self, realpart, imagpart):
self.r = realpart
self.i = imagpart
def real(self):
return self.r
def imag(self):
return self.i
def __str__(self):
if __cmp__ in dir(self.i):
if self.i<0:
return "[%s - %s i]"%(self.r.__str__(),(-self.i).__str__())
else:
return "[%s + %s i]"%(self.r.__str__(),self.i.__str__())
else:
return "[%s + %s i]"%(self.r.__str__(),self.i.__str__())
def __coerce__(self,b):
if isinstance(b,Complex2):
return(self,b)
else:
return(self,Complex2(b,0))
def __add__(self,b):
return Complex2(self.r+b.r, self.i+b.i)
def __sub__(self,b):
return Complex2(self.r-b.r, self.i-b.i)
def __mul__(self,b):
return Complex2(self.rb.r - self.ib.i,
self.rb.i + self.ib.r)
\end{sageblock}
Reference
Now we can write:
\begin{verbatim}
Complex2(Complex2(1.0,-2.0),Complex2(3.0,-4.0))
\end{verbatim}
\begin{equation}
\label{eq1}
\sage{Complex2(Complex2(1.0,2.0),Complex2(3.0,-4.0))}
\end{equation}
Compare the following to the output from Axiom above:
\begin{sageblock}
ii = Complex2(0,1)
\end{sageblock}
\begin{verbatim}
print ii
\end{verbatim}
\begin{equation}
\label{eq2}
\sage{ii}
\end{equation}
\begin{sageblock}
innerI = Complex2(ii, 0)
\end{sageblock}
\begin{verbatim}
print innerI
\end{verbatim}
\begin{equation}
\label{eq3}
\sage{innerI}
\end{equation}
\begin{sageblock}
outerI = Complex2(0, 1)
\end{sageblock}
\begin{verbatim}
print outerI
\end{verbatim}
\begin{equation}
\label{eq4}
\sage{outerI}
\end{equation}
\begin{verbatim}
print innerI * outerI
\end{verbatim}
\begin{equation}
\label{eq5}
\sage{innerI outerI}
\end{equation*}
This Python code seems to do the same thing as the Aldor code
but without the "complication" of categories!
Ondrej: The __cmp__ in dir(..) is ugly, but that's because you are using the python integers and stuff. In SymPy?, we have our own class for Numbers and for Mul and str(x-y) prints the + and - correctly (the Mul and Add takes care of it). But in this simple example, the __cmp__ in dir(..) is the easiest solution.