提交: dbe659ea06d7ace0bb1d85f756f3de54a249aa33 - cammy (git)

A categorical programming language

Commit MetaInfo

• 修订版: dbe659ea06d7ace0bb1d85f756f3de54a249aa33 (tree)
• 时间: 2022-07-02 12:06:13
• 作者: Corbin <cds@corb...>
• Commiter: Corbin

Log Message

Logarithms for floats.

更改概述

• modified: cammy-rpy/cammylib/arrows.py
• modified: cammy-rpy/cammylib/cam.py
• add: hive/f/ln.cammy
• add: start-repl.sh
• modified: todo.txt

差异

--- a/cammy-rpy/cammylib/arrows.py
+++ b/cammy-rpy/cammylib/arrows.py
@@ -3,7 +3,7 @@ import math
 from rpython.rlib.jit import isconstant, we_are_jitted
 # from rpython.rlib.rbigint import rbigint
 
-from cammylib.elements import B, F, L, N, R, T
+from cammylib.elements import B, F, N, T
 
 
 class Arrow(object):
@@ -316,17 +316,11 @@ FZero = makeConstantF(0.0)
 FOne = makeConstantF(1.0)
 FPi = makeConstantF(math.pi)
 
-def sign(f): return abs(f) == f
 class FSign(Arrow):
     _immutable_ = True
     def compile(self, compiler): compiler.sign()
     def types(self, cs): return cs.concrete("F"), cs.concrete("2")
 
-def floor(f):
-    try:
-        return L(F(float(math.floor(f))))
-    except (ValueError, OverflowError):
-        return R(T())
 class FFloor(Arrow):
     _immutable_ = True
     def compile(self, compiler): compiler.floor()
@@ -408,8 +402,6 @@ class FATan2(Arrow):
         f = cs.concrete("F")
         return cs.functor("pair", [f, f]), f
 
-def sqrt(f):
-    return L(F(math.sqrt(f))) if sign(f) else R(T())
 class FSqrt(Arrow):
     _immutable_ = True
     def compile(self, compiler): compiler.sqrt()
@@ -417,6 +409,13 @@ class FSqrt(Arrow):
         f = cs.concrete("F")
         return f, cs.functor("sum", [f, cs.concrete("1")])
 
+class FLog1Plus(Arrow):
+    _immutable_ = True
+    def compile(self, compiler): compiler.log1p()
+    def types(self, cs):
+        f = cs.concrete("F")
+        return f, cs.functor("sum", [f, cs.concrete("1")])
+
 
 class BuildProblem(Exception):
     def __init__(self, message):
@@ -458,6 +457,7 @@ unaryFunctors = {
     "f-cos": FCos(),
     "f-atan2": FATan2(),
     "f-exp": FExp(),
+    "f-log1p": FLog1Plus(),
 }
 
 def buildUnary(name):

--- a/cammy-rpy/cammylib/cam.py
+++ b/cammy-rpy/cammylib/cam.py
@@ -1,9 +1,9 @@
-from math import atan2, cos, exp, sin
+import math
 
 from rpython.rlib.jit import JitDriver
 from rpython.rlib.rvmprof import get_unique_id, register_code, register_code_object_class, vmprof_execute_code
 
-from cammylib.arrows import add, floor, mul, recip, sign, sqrt
+from cammylib.arrows import add, mul, recip
 from cammylib.elements import B, F, L, N, P, R, T, equal
 
 # A basic CAM, as in the original paper:
@@ -44,6 +44,18 @@ def lessThan(term):
     f2 = term.second().f()
     return B(True) if f1 == -0.0 and f2 == 0.0 else B(f1 < f2)
 
+def floor(f):
+    try:
+        return L(F(float(math.floor(f))))
+    except (ValueError, OverflowError):
+        return R(T())
+
+def sign(f): return abs(f) == f
+
+def sqrt(f): return L(F(math.sqrt(f))) if sign(f) else R(T())
+
+def log1p(f): return L(F(math.log1p(f))) if f > -1.0 else R(T())
+
 termOps = [
     # Core term ops.
     TermOp("fst", lambda term: term.first()),
@@ -73,11 +85,12 @@ termOps = [
     TermOp("fAdd", lambda term: add(term.first().f(), term.second().f())),
     TermOp("mul", lambda term: mul(term.first().f(), term.second().f())),
     TermOp("sqrt", lambda term: sqrt(term.f())),
-    TermOp("sin", lambda term: F(sin(term.f()))),
-    TermOp("cos", lambda term: F(cos(term.f()))),
+    TermOp("sin", lambda term: F(math.sin(term.f()))),
+    TermOp("cos", lambda term: F(math.cos(term.f()))),
     TermOp("atan2",
-        lambda term: F(atan2(term.first().f(), term.second().f()))),
-    TermOp("exp", lambda term: F(exp(term.f()))),
+        lambda term: F(math.atan2(term.first().f(), term.second().f()))),
+    TermOp("exp", lambda term: F(math.exp(term.f()))),
+    TermOp("log1p", lambda term: log1p(term.f())),
 ]
 print "CAM: Created %d term ops" % len(termOps)
 

--- /dev/null
+++ b/hive/f/ln.cammy
@@ -0,0 +1 @@
+(comp (comp (comp (pair id (fun/const f-one)) f/sub) f-log1p) (case id (comp (comp f-zero f-recip) f-negate)))
\ No newline at end of file

--- /dev/null
+++ b/start-repl.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+find hive -name \*.cammy | awk '{ split($0,a,"."); print substr(a[1],6) }' > tab.txt 
+rlwrap -b ' ()' -f tab.txt result-bin/bin/cammy repl hive/

--- a/todo.txt
+++ b/todo.txt
@@ -1,24 +1,3 @@
-* Idea for new subcommands
-  * cammy dissolve
-    * Takes no arguments, just hive and input expr
-    * Returns equivalent to input, but using as much of hive as possible
-    * Implementation strategy: build up hash-cons structure in memory
-      * Iterate over hive, adding each expression to hash-cons
-      * Also build up partial dissolution map from hash-cons nodes to hive paths
-    * In unlikely case of ambiguity, guess
-      * Later on, we can make an informed guess by looking at neighboring nodes
-    * implemented as cammy freeze
-  * cammy crystallize
-    * Again, just hive and input
-    * Returns equivalent to input, mostly dissolved, but top few nodes are
-      deliberately tracked or expanded
-      * Each expanded node has its trail appended
-      * A weave is generated, including documentation
-    * Output is ready to feed to pandoc
-      * Output is a "crystal grown from $EXPR"; it explains the algorithm
-        incrementally, piece-by-piece
-        * Still not real literate programming, but getting closer
-    * Should use same underlying tools as dissolve
 * REPL improvements
   * allow mid-functor newlines
   * : commands
@@ -33,6 +12,9 @@
       * Okasaki-style red-black trees?
     * Skew heaps for priority queues https://themonadreader.files.wordpress.com/2010/05/issue16.pdf
     * Efficient maps keyed by N
+  * Attempted to implement them, but ran into a problem: tree traversals on
+    CAM are not obvious
+    * Defunctionalization might work: can the tree traversal be linearized?
 * I know how to compile to cats!
   * For cat of interest, make hive/cats/cat/id, hive/cats/cat/comp, etc.
   * Then, we'll apply a stack of functors by just looking up each layer in the