2

我想使用 Clojure 哈希图来定义广义向量。在这张图中，hashmap {:x 3 :y 2 :z (- 3)} 表示符号表达式 3x + 2y - 3z。

我想要一个函数 gen+，它充当哈希图上的加法运算，并且满足以下约束：

  • 将 gen+ 应用于两个具有重叠键的哈希图会返回一个哈希图，其中这些键值求和。例如，

(gen+ {:x 1} {:x 2})

;= {:x 3}

  • 将 gen+ 应用于具有不同键的两个哈希图会返回一个包含这些键值组合的哈希图。例如，

(gen+ {:x 1} {:y 2})

;= {:x 1 :y 2}

  • 空的 hashmap {} 是 gen+ 函数的附加标识。例如，

(gen+ {:x 1} {})

:= {:x 1}

  • 通过上述约束，任何条目为零的哈希图也是一个加法标识。例如，{:z 0}。由于这种冗余，gen+ 函数应始终返回不带任何 0 值的哈希图。例如，

(gen+ {:x 1 :y 0} {:z 0})

;= {:x 1}

  • Clojure 将缺少的键解释为具有值 nil，而不是 0，就像({:x 3} :y) ;= nil. 因此，gen+ 应该以与 0 相同的方式处理 nil 值。例如，

(gen+ {:x 1 :y 0} {:x nil :y nil})

{:x 1}

  • 我的问题：我们如何编写满足上述约束的函数 gen+？一旦到位，是否可以使用 gen+ 函数重载 + 运算符，从而使用哈希图实现基本加法？

为什么这种形式主义将哈希图视为广义向量应该是显而易见的。Clojure 将 [x0 x1 x2] 之类的向量解释为与哈希图 {:0 x0 :1 x1 :2 x2} 几乎相同，但有一点我不太理解的差异。因此，如果我们将 gen+ 应用于两个向量，那么它实际上应该与应用于它们的 + 相同。这使我们能够轻松地使用稀疏向量，以及添加不同大小的向量。例如，

(gen+ [0 0 0 4] [0 0 0 0 0 0 0 0 0 9])

;= {:4 4 :9 9}

这是我对哈希图和向量的不理解。如果我将哈希图称为函数，我需要应用一个关键参数，例如：2。另一方面，如果我将向量称为函数，则需要应用像 2 这样的索引参数。例如，

({:2 2} :2)

;= 2

([0 1 2] 2]

;= 2

即使您无法使用 gen+ 函数，您能否解释一下为什么哈希图和向量在作为函数调用时表现不同？

4

2 回答 2

4

你第一个问题的答案是使用merge-withSee http://clojuredocs.org/clojure_core/clojure.core/merge-with

从文档：

返回一个映射，该映射由合并到第一个映射的其余映射组成。如果一个键出现在多个映射中，则从后者（从左到右）的映射将通过调用 (f val-in-result val-in-latter) 与结果中的映射组合。

然后，您可以编写一个函数来组合合并的值（也许+）。然后折腾 nil 和 0 值。

在 Clojure 中重载 + 并不是一个好主意，因为它并不是真正重载而是替换。

map 和 vector 的区别就像一个数组，而 map 更像是一个键值对的字典。这两种结构也是它们成员的功能。对于通过偏移量访问其成员的向量/数组，接受偏移量是有意义的。对于通过键访问其成员的地图/字典，它接受一个键是有意义的。

于 2013-10-29T22:47:21.860 回答
2

这将首先删除nil和0值，然后merge-with按照 M Smith 的建议添加带有 的映射：

(defn filter-vals
  [pred m]
  (into {} (filter (fn [[k v]] (pred v))
                   m)))

(defn gen+
  [m1 m2]
  (letfn [(keep-val? [val]
            (and (not (nil? val))
                 (not (zero? val))))]
    (merge-with +
                (filter-vals keep-val? m1)
                (filter-vals keep-val? m2))))

您需要nil在开始添加之前过滤掉任何 s - 否则您最终会尝试添加nil到数字，这是一个错误。但是， gen+我概述的可能会返回一个带有0值的条目（考虑(gen+ {:x 1} {:x -1})）。

如果根据您的输入这是可能的，并且需要避免，您需要在合并后添加另一个过滤器：

(defn gen+
  [m1 m2]
  (letfn [(keep-val? [val]
            (and (not (nil? val))
                 (not (zero? val))))]
    (->> (merge-with +
                     (filter-vals keep-val? m1)
                     (filter-vals keep-val? m2))
         (filter-vals keep-val?))))

最后，这是一个可以处理可变数量输入映射的版本：

(defn gen+
  [& maps]
  (letfn [(keep-val? [val]
            (and (not (nil? val))
                 (not (zero? val))))]
    (->> (apply merge-with
                +
                (map #(filter-vals keep-val? %) maps))
         (filter-vals keep-val?))))

因此，例如：

(gen+ {:x 1} {:x 3} {:x 4 :y 5}) ;=> {:x 8, :y 5}

关于映射和向量之间的区别，可以这样想：映射是从键到值的函数，而向量是从索引到值的函数。在这两种情况下，如果您有一个“键”（对于向量来说就是索引），您可以使用它来查找关联的值。

我同意你到目前为止关于超载的答案和评论clojure.core/+（我不推荐它）；也就是说，这是一种方法，有很多警告：

(ns overload.example
  (:refer-clojure :exclude [+])
  (:require [clojure.core :as clj]))

(in-ns 'overload.example)

(defn gen+ ...)

(defn + [& xs]
  (if (every? number? xs)
    (reduce clj/+ 0 xs)
    (apply gen+ xs)))
于 2013-10-30T00:27:14.160 回答