小编Gab*_*ell的帖子

简短版本:我对一些Clojure代码很感兴趣,它允许我指定x的变换(例如置换,旋转),在该变换下函数f(x)的值是不变的,这样我就可以有效地生成x的序列满足r = f(x).Clojure的计算机代数有一些发展吗？对于(一个微不足道的)例子

(defn #^{:domain #{3 4 7} 
         :range #{0,1,2}
         :invariance-group :full} 
          f [x]  (- x x))

我可以打电话(preimage f#{0}),它会有效地返回#{3 4 7}.当然,它也能够正确地注释codomain.有什么建议？

更长的版本:我有一个特定的问题让我有兴趣了解Clojure计算机代数的开发.谁能指点我这样的项目？我的具体问题涉及找到满足F(x)= r的所有单词组合,其中F是排名函数,ra是正整数.在我的特定情况下,f可以作为总和来计算

F(x)= f(x [0])+ f(x [1])+ ... f(x [N-1])

此外,我有一组不相交的集合S = {s_i},使得f(a)= f(b)表示a,b表示s,s表示S.所以生成所有x的策略使得F(x)= r应该依赖于F的这种因式分解和每个s_i下f的不变性.换句话说,我计算包含S元素的站点的所有排列,这些元素总和为r,并用每个s_i中元素的所有组合组成它们.以下内容非常简单:

(use 'clojure.contrib.combinatorics)
(use 'clojure.contrib.seq-utils)


(defn expand-counter [c]
 (flatten (for [m c] (let [x (m 0) y (m 1)] (repeat y x)))))

(defn partition-by-rank-sum [A N f r]
  (let [M (group-by f A)
    image-A (set (keys M))
    ;integer-partition computes restricted integer partitions,
    ;returning a multiset …

在一个let形式(Clojure在这里)我可以做类似的事情

(let [[u s v] (svd A)] 
   (do-something-with u v))

其中svd返回长度为3的列表.这是一件很自然的事情,为什么我们不这样做呢？

(def [u s v] (svd A))

及其各种概括作为def表单的默认行为？我不知道这会如何干扰def已经在做的事情.理解Lisp或Clojure的Zen的人能解释为什么def不支持绑定(与解构)一样强大let吗？

Stuart Halloway举了这个例子

(re-seq #"\w+" "The quick brown fox")

作为在Clojure中查找正则表达式匹配匹配的自然方法.在他的书中,这种结构与对匹配器的迭代形成对比.如果所有人都关心的是一系列比赛,这将是很棒的.但是,如果我想要匹配及其在字符串中的位置怎么办？是否有更好的方法可以让我利用java.util.regex中的现有功能,对原始字符串中的每个索引采用类似于序列的理解？换句话说,人们想输入类似的东西

(re-seq-map#"[0-9] +""3a1b2c1d")

这将返回一个带有键的地图作为位置和值作为匹配,例如

{0 "3", 2 "1", 4 "2", 6 "1"}

是否已经在现存的图书馆中实现了这一点,或者我应该写它(不应该是代码行)？

我很困惑.我想生成一个例子(在Clojure中),演示如何使用定点组合器来评估在无限数量的应用之后在数学上收敛的序列的固定点,但事实上,在有限数量的步骤之后收敛有限的浮点精度.我显然在这里遗漏了一些东西.

(defn Y [r]
  ((fn [f] (f f))
   (fn [f]
     (r (fn [x] ((f f) x))))))

(defn simple-convergent [func]
  (fn [x]
    (if (zero? x)
      0.0
      (* 0.5 (func x)))))

我可以得到

user=> ((Y simple-convergent) 0.)
0.0
user=> ((Y simple-convergent) 0.2)
java.lang.StackOverflowError (NO_SOURCE_FILE:0)

我不明白这个堆栈溢出.更一般地说,与我之前的帖子有关,我想知道是否有人可以呈现定点组合器的"正确"版本,其可以用于以这种方式近似序列的固定点.

我试图实现迭代器对象的延迟分区,当迭代器的元素上的函数更改值时,该对象生成迭代器的切片.这将模仿Clojure的分区行为(虽然输出的语义会有所不同,因为Python会真正"消耗"元素).我的实现在它执行的操作数量上是最佳的,但在内存中并不是最佳的.我不明白为什么一个好的实现需要超过O(1)内存,但我的实现需要O(k)内存,其中k是分区的大小.我希望能够处理k很大的情况.有谁知道一个好的实现？

正确的行为应该是这样的

>>>unagi = [-1, 3, 4, 7, -2, 1, -3, -5]
>>> parts = partitionby(lambda x: x < 0,unagi)
>>> print [[y for y in x] for x in parts]
[[-1], [3, 4, 7], [-2], [1], [-3, -5]]

这是我目前的版本

from itertools import *

def partitionby(f,iterable):
    seq = iter(iterable)
    current = next(seq)
    justseen = next(seq)
    partition = iter([current])
    while True:
        if f(current) == f(justseen): 
            partition = chain(partition,iter([justseen]))
            try:
                justseen = next(seq)
            except StopIteration:
                yield partition
                break
        else:
            yield partition
            current …

我试图在Clojure中编写一个宏,允许评估一系列简单的"def"表达式.对于宏来说,我是一个n00b.这个想法就是这样

(my-defs y1 1
     y2 "taco")

应该扩展到

(do (def y1 1) (def y2 "taco"))

以下代码针对两个defs的特殊情况完成了此操作

(defmacro my-defs 
  [& args]
  `(do
     (def ~(first args) ~(second args))
     (def ~(nth args 2) ~(nth args 3) )))

这很好,但我很难概括这一点.我尝试了一些天真的事情,涉及循环通过元素的绑定,(partition 2 args)但我总是有垃圾(我知道这不是非常具体,但垃圾的多样性和范围似乎有点太多,无法在此报告).我如何循环这些并评估我的defs？

PS宏my-defs是玩具.我最终想要完成的是一个小小的帮助宏来实例化一堆多方法实例.目前我有大量的代码看起来像

(defmethod f [A B] [x] "AB")
(defmethod f [A A] [x] "AA")
(defmethod f [C B] [x] "CB")

这有点不雅观.如果我可以做类似的事情会很好

(defmethods f
  [A B] [x] "AB"
  [A A] [x] "AA"
  [C B] [x] "CB")

代替.

我写了一个小课程来持续记住一些昂贵的函数,这些函数对随机网络进行各种统计分析.

这些都是纯粹的功能; 所有数据都是不可变的.但是,某些函数将函数作为参数.

基于这些参数创建密钥是一个小问题,因为在Python中,函数对象相等等同于函数对象标识,即使函数实现没有改变,它也不会在会话之间保持不变.

我暂时使用函数名作为字符串来解决这个问题,但是当我开始考虑更改函数或匿名函数的实现等时,这会引发自己的一大堆问题.但我可能不是第一个担心这类事情的人.

有没有人有任何策略在Python中持久记忆函数参数的函数？