我该如何在Clojure中求幂？现在，我只需要整数幂，但是问题也适用于分数。

经典递归（观看此文章，它会发散堆栈）

(defn exp [x n]
     (if (zero? n) 1
         (* x (exp x (dec n)))))

尾递归

(defn exp [x n]
  (loop [acc 1 n n]
    (if (zero? n) acc
        (recur (* x acc) (dec n)))))

功能性

(defn exp [x n]
  (reduce * (repeat n x)))

偷偷摸摸的（也打击堆栈，但不那么容易）

(defn exp-s [x n]
  (let [square (fn[x] (* x x))]
    (cond (zero? n) 1
          (even? n) (square (exp-s x (/ n 2)))
          :else (* x (exp-s x (dec n))))))

图书馆

(require 'clojure.contrib.math)

Clojure具有强大的功能，可以很好地发挥作用：我建议您使用此函数，而不要通过Java interop，因为它可以正确处理所有Clojure任意精度数字类型。它在命名空间clojure.math.numeric-tower中。

它被称为expt求幂而不是power或pow可能解释了为什么很难找到它的原因……无论如何，这是一个小例子（请注意，它use可以工作，但使用得更好require）：

(require '[clojure.math.numeric-tower :as math :refer [expt]])  ; as of Clojure 1.3
;; (use 'clojure.contrib.math)     ; before Clojure 1.3

(expt 2 200)
=> 1606938044258990275541962092341162602522202993782792835301376

提醒安装软件包

您必须首先安装Java软件包，org.clojure.math.numeric-tower以使Clojure名称空间clojure.math.numeric-tower可访问！

在命令行上：

$ lein new my-example-project
$ cd lein new my-example-project

然后编辑project.clj并添加[org.clojure/math.numeric-tower "0.0.4"]到依赖向量。

启动lein REPL（不是clojure REPL）

$ lein repl

现在：

(require '[clojure.math.numeric-tower :as math])
(math/expt 4 2)
;=> 16

要么

(require '[clojure.math.numeric-tower :as math :refer [expt]])
(expt 4 2)
;=> 16

您可以使用Java Math.pow或BigInteger.pow方法：

(Math/pow base exponent)

(.pow (bigint base) exponent)

最初提出此问题时，clojure.contrib.math / expt是执行此操作的官方库函数。从那时起，它已移至clojure.math.numeric-tower

user=> (.pow (BigInteger. "2") 10)
1024
user=> (.pow (BigInteger. "2") 100)
1267650600228229401496703205376

如果您确实需要一个函数而不是一个方法，则可以将其包装：

 (defn pow [b e] (Math/pow b e))

在此功能中，您可以将其强制转换为int或类似。函数通常比方法有用，因为您可以将它们作为参数传递给另一个函数-在这种情况下map，我想到了。

如果确实需要避免Java互操作，则可以编写自己的幂函数。例如，这是一个简单的函数：

 (defn pow [n p] (let [result (apply * (take (abs p) (cycle [n])))]
   (if (neg? p) (/ 1 result) result)))

这将计算整数指数（即无根）的幂。

另外，如果要处理大量数字，则可能要使用BigInteger而不是int。

而且，如果要处理非常大的数字，则可能需要将它们表示为数字列表，并编写自己的算术函数以在它们计算结果并将它们输出到其他流时在它们上进行流式处理。

我认为这也会起作用：

(defn expt [x pow] (apply * (repeat pow x)))

SICP启发了上面“偷偷摸摸”的实现的完整迭代快速版本。

(defn fast-expt-iter [b n]
  (let [inner (fn [a b n]
                (cond
                  (= n 0) a
                  (even? n) (recur a (* b b) (/ n 2))
                  :else (recur (* a b) b (- n 1))))
        ]
    (inner 1 b n)))

clojure.math.numeric-tower以前使用clojure.contrib.math。

API文档

(ns user
  (:require [clojure.math.numeric-tower :as m]))

(defn- sqr
  "Uses the numeric tower expt to square a number"
  [x]
  (m/expt x 2))

具有尾递归并支持负指数的“偷偷摸摸”方法的实现：

(defn exp
  "exponent of x^n (int n only), with tail recursion and O(logn)"
   [x n]
   (if (< n 0)
     (/ 1 (exp x (- n)))
     (loop [acc 1
            base x
            pow n]
       (if (= pow 0)
         acc                           
         (if (even? pow)
           (recur acc (* base base) (/ pow 2))
           (recur  (* acc base) base (dec pow)))))))

使用reduce的简单单线：

(defn pow [a b] (reduce * 1 (repeat b a)))

尝试

(defn pow [x n]
  (loop [x x n n r 1]
    (cond
      (= n 0) r
      (even? n) (recur (* x x) (/ n 2) r)
      :else (recur x (dec n) (* r x)))))

对于尾递归O（log n）解决方案，如果您想自己实现（仅支持正整数）。显然，更好的解决方案是使用其他人指出的库函数。

clojure.contrib.genric.math函数如何

clojure.contrib.generic.math-functions库中有一个pow函数。它只是Math.pow的宏，更像是一种调用Java数学函数的“ clojureish”方式。

http://clojure.github.com/clojure-contrib/generic.math-functions-api.html#clojure.contrib.generic.math-functions/pow