duplicates = multiple editions
A Classical Introduction to Modern Number Theory, Kenneth Ireland Michael Rosen
A Classical Introduction to Modern Number Theory, Kenneth Ireland Michael Rosen
"""Pexpect is a Python module for spawning child applications and controlling | |
them automatically. Pexpect can be used for automating interactive applications | |
such as ssh, ftp, passwd, telnet, etc. It can be used to a automate setup | |
scripts for duplicating software package installations on different servers. It | |
can be used for automated software testing. Pexpect is in the spirit of Don | |
Libes' Expect, but Pexpect is pure Python. Other Expect-like modules for Python | |
require TCL and Expect or require C extensions to be compiled. Pexpect does not | |
use C, Expect, or TCL extensions. It should work on any platform that supports | |
the standard Python pty module. The Pexpect interface focuses on ease of use so | |
that simple tasks are easy. |
import sys; from PIL import Image; import numpy as np | |
chars = np.asarray(list(' .,:;irsXA253hMHGS#9B&@')) | |
if len(sys.argv) != 4: print( 'Usage: ./asciinator.py image scale factor' ); sys.exit() | |
f, SC, GCF, WCF = sys.argv[1], float(sys.argv[2]), float(sys.argv[3]), 7/4 | |
img = Image.open(f) | |
S = ( round(img.size[0]*SC*WCF), round(img.size[1]*SC) ) | |
img = np.sum( np.asarray( img.resize(S) ), axis=2) |
-module(horr). | |
-export([malloc/0, free/1, read/1, write/2, test/0]). | |
% You can use `malloc` to get a globally sharable, mutable cell of memory. | |
% A difference to C's `malloc` is that such a cell doesn't have a certain size (you can't overflow) | |
% Memory is initialised with the atom `null`. | |
malloc() -> | |
spawn(fun() -> mem(null) end). | |
% As processes are not garbage collected, you have to call `free` when you're done with your memory: |
(define (unify a b) | |
(cond ((and (pair? a) | |
(pair? b)) (cons (unify (car a) (car b)) | |
(unify (cdr a) (cdr b)))) | |
((symbol? a) b) ; here i just return b, because a symbol matches anything. a more complex system would have a third argument | |
; , the environment, that tracks existing bindings for a, and prevents conflicts. then, instead of returning b | |
; we could update the environment with the binding for a = b, or issue a failure (in kanren language, #u) | |
((eq? a b) b) ; a and b trivially unify without updating any bindings. here I just return their mutual value |
## Principal type-schemes for functional programs | |
**Luis Damas and Robin Milner, POPL '82** | |
> module W where | |
> import Data.List | |
> import Data.Maybe | |
> import Data.Function |