Comment faire de l'exponentiation dans clojure?

Comment puis-je faire exponentiation en clojure?
Pour l'instant je suis le seul à en avoir besoin entier élévation à la puissance, mais la question vaut pour les fractions de trop.

  • Comme quelqu'un qui ne sait pas clojure, mais il est prédisposé à aimer ça (étant un fan de lisps, la programmation fonctionnelle, et avoir beaucoup de pratique des bibliothèques), je suis déçu que cette simple question a donc beaucoup de réponses, ni que cela a dû être demandé à tous. J'aurais pensé que l'exponentiation serait juste l'une des fonctions de base sans avoir à faire quoi que ce soit de spécial. Je suis heureux, il a été demandé, si.
  • eh bien oui, probablement une version de celui-ci devrait être à la base... mais je pense que beaucoup de réponses, c'est toujours un bon signe. les "chemins d'accès multiples à la mise en œuvre" semble être la raison pour laquelle beaucoup de ces choses ne sont pas fournis-l'utilisateur doit connaître les détails de la fonction qu'ils utilisent pour des raisons d'efficacité. par exemple (comme il est indiqué dans la réponse choisie) certains égards, il peut potentiellement coup de la pile, d'autres le sont moins susceptibles de le faire. peut-être que certains sont paresseux, enthousiastes... tous les détails qui doivent être payés à un peu d'attention en Clojure, qui est pourquoi je pense que la plupart des non-trivial libs ne sont pas fournies en raison de la philosophie
  • Je pense que la raison il n'y a pas seulement une fonction exp dans le cœur est parce que clojure numérique de la tour est mal rompu pour des raisons d'efficacité. Donc, il ya toutes sortes de choses que vous pourriez dire par exponentiation. Ce qui devrait (exp 2 (exp 2 200)) être? Une erreur ou d'un énorme entier qui prend du temps à calculer? Si vous voulez juste l'habitude de virgule flottante exp, puis le java est construit en. Si vous voulez une langue où les chiffres font de leur mieux pour agir comme le corps des réels, et accrocher le coût, l'utilisation de régime au lieu de clojure.
InformationsquelleAutor Peter | 2011-02-20
  1. 128

    classique de la récursivité (regardez cela, il souffle sur la pile)

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

    queue de récursivité 

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

    fonctionnelle

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

    sournois (aussi coups de pile, mais pas si facilement)

    (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))))))

    bibliothèque

    (require 'clojure.contrib.math)
    • Divertissant réponse!
    • voir entièrement itératif version de sournois solution ci-dessous stackoverflow.com/a/22977674/231589
    • Clojure.contrib.math est maintenant obsolète, voir Math.Numérique-Tour
    • La deuxième suggestion (queue récursive) a débordement d'entier pour le n < 0.
    • Fantastique réponse. Voici comment le faire avec une macro: (defmacro exp [x n] `(* ~@(prendre n (répétition x))))
    • Terminal de récursivité pour l'exponentiation rapide de l'algorithme: (def exp (letfn [(rexp [x n r] (cond (zero? n) r (even? n) (recur (*' x x) (/ n 2) r) :else (recur (*' x x) (/ (dec n) 2) (*' x r))))] (fn [x n] (rexp x n 1)))). Il n'a jamais fait sauter la pile. Test (exp 1 (exp 2 30000))

    InformationsquelleAutor John Lawrence Aspden
  2. 75

    Clojure a une fonction de puissance qui fonctionne bien: je vous recommande d'utiliser le présent, plutôt que de passer par Java interop puisqu'il gère l'ensemble de la Clojure précision arbitraire des types de numéro correctement.

    Il est appelé expt pour exponentiation plutôt que power ou pow qui explique peut-être pourquoi il est un peu difficile à trouver ... en tout cas voici un petit exemple:

    (use 'clojure.math.numeric-tower)  ; as of Clojure 1.3
;; (use 'clojure.contrib.math)     ; before Clojure 1.3

(expt 2 200)
=> 1606938044258990275541962092341162602522202993782792835301376
    • Oui, c'est ce que je cherchais! Curieusement inconnu...
    • Probablement inconnu car il ne semble pas faire partie de la norme Clojure. 1.3.0 lance des erreurs à propos de ne pas être en mesure de localiser les mathématiques.clj quand j'essaie de le faire de cette façon.
    • Je pense qu'il est maintenant dans "clojure.les mathématiques.numérique-tour de 1,3 (depuis clojure.contrib s'est cassé vers le haut dans les bibliothèques)
    InformationsquelleAutor mikera
  3. 52

    Vous pouvez utiliser java Math.pow ou BigInteger.pow méthodes:

    (Math/pow base exponent)

(.pow (bigint base) exponent)
    • +1, même si je sais que vous pouvez l'interopérabilité avec java libs; cependant, 1) Math.pow travaille avec des doubles, j'ai besoin d'Entiers, pouvez-vous donner un exemple? 2) avez-vous vraiment l'utilisation de l'interopérabilité pour les géohelminthiases. simple comme pouvoirs?
    • Clojure est construit autour de la bibliothèques java, il ne tentez pas de réparer ce qui n'est pas cassé et en Mathématiques/pow fonctionne très bien. Pourquoi avez-vous besoin de soin pour les doubles ou les entiers? Vous pouvez également utiliser ce richhickey.github.com/clojure-contrib/...
    • 1) à Moins que vos pouvoirs sont tellement gros qu'ils ne peuvent pas être représentés avec précision par double plus, il n'y a vraiment pas de problème avec simplement jeter le résultat de type int. 2) je ne vois pas comment l'écriture Math/pow est plus compliqué que math-pow ou quel que soit le nom serait si il y avait un clojure équivalent. Si il y a déjà une simple méthode java qui fait ce que vous voulez, il n'y a pas de raison de recréer les fonctionnalités en clojure. Java interopérabilité n'est pas intrinsèquement nocifs.
    • vinci : étrange remarque, c'est une langue propre, et a beaucoup de fonctions qui sont en Java (comme stringreverse)
    • C'est en effet sur les gros nummers (projet euler comme truc)
    • Vinci : merci pour le lien!
    • Pour bigints vous pouvez utiliser java BigInteger.pow méthode d'instance.
    • merci man!
    • Je pense que vous êtes mieux à l'aide de Clojure du clojure.contrib.math/expt si vous voulez précis biginteger pouvoirs. Probablement fait la même chose sous le capot, mais beaucoup plus agréable que de passer par Java interop.....
    • Je suis No matching method pow ... for class clojure.lang.BigInt -- ne devrait-elle pas être (.pow (biginteger base) exponent)?

    InformationsquelleAutor sepp2k
  4. 11

    Lorsque cette question a été initialement demandé, clojure.contrib.math/expt était la langue officielle de la bibliothèque de fonction pour ce faire. Depuis, il a déménagé à clojure.les mathématiques.numérique-tour

    InformationsquelleAutor amalloy
  5. 7
    user=> (.pow (BigInteger. "2") 10)
1024
user=> (.pow (BigInteger. "2") 100)
1267650600228229401496703205376
    • vous pouvez aussi utiliser la notation littérale pour cela: (.pow 2M 100)
    • Leurs types sont différents. utilisateur=> (type 2M) de java.les mathématiques.BigDecimal utilisateur=> (type (BigInteger. "2")) java.les mathématiques.BigInteger
    • omi meilleure solution, showr, en utilisant les bibliothèques existantes, et y compris la manutention de type bigint. +1
    • Pour moi (Math/pow Math/E x) fait le tour (en remplacement de Math/E avec la base de votre choix).
    InformationsquelleAutor KIM Taegyoon
  6. 5

    Si vous avez vraiment besoin d'une fonction et non pas une méthode, vous pouvez simplement envelopper:

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

    Et dans cette fonction, vous pouvez le convertir en int ou similaire. Les fonctions sont souvent plus utiles que les méthodes parce que vous pouvez passer en paramètres à une autre des fonctions - dans ce cas map vient à mon esprit.

    Si vous avez vraiment besoin pour éviter de Java interop, vous pouvez écrire votre propre fonction de la puissance. Par exemple, c'est une fonction simple:

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

    Qui calcule la puissance pour l'entier de l'exposant (c'est à dire pas de racines).

    Aussi, si vous traitez avec grand numéros, vous pouvez utiliser BigInteger au lieu de int.

    Et si vous avez affaire avec très grande numéros, vous pouvez exprimer sous forme de listes de chiffres, et d'écrire vos propres fonctions mathématiques pour les flux au-dessus d'eux, comme ils calculer le résultat et la sortie de la suite à certains autres flux.

    InformationsquelleAutor Goran Jovic
  7. 4

    Je pense que ce serait trop de travail:

    (defn expt [x pow] (apply * (repeat pow x)))
    • mais il semble qu'max à 2^63... def pas capable de 2^200
    • Essayez (expt 2N 200), fonctionne très bien.
    InformationsquelleAutor TJ Trapp
  8. 3

    SICP inspiré plein itératif rapide version de "sournois" de mise en œuvre ci-dessus.

    (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)))
    InformationsquelleAutor Karl Rosaen
  9. 2

    Utilisation clojure.les mathématiques.numérique-tour, anciennement clojure.contrib.math.

    La Documentation de l'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))
    • merci, mais c'est déjà mentionné à plusieurs reprises
    InformationsquelleAutor micrub
  10. 2

    Mise en œuvre de "sournois" la méthode avec la queue de la récursivité et de soutien de l'exposant négatif:

    (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)))))))
    InformationsquelleAutor Tolstoyevsky
  11. 2

    Un simple one-liner à l'aide de réduire:

    (defn pow [a b] (reduce * 1 (repeat b a)))
    InformationsquelleAutor Alan R. Soares
  12. 1

    Essayer

    (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)))))

    pour une queue-récursive O(log n) solution, si vous voulez mettre en œuvre vous-même (prend en charge uniquement les entiers positifs). Évidemment, la meilleure solution est d'utiliser les fonctions de la bibliothèque que d'autres l'ont souligné.

    InformationsquelleAutor Retief
  13. 0

    Comment sur clojure.contrib.genric.mathématiques-fonctions

    Il y a une fonction pow dans le clojure.contrib.génériques.mathématiques-fonctions de la bibliothèque. C'est juste une macro pour les Mathématiques.pow et est plus un "clojureish" de l'appel de la Java de fonction mathématique.

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

    InformationsquelleAutor fido