Generiert eine zufällige ganze Zahl in einem Bereich in Haskell ohne Samen

Wie kann ich eine Zufallszahl erzeugen in Haskell die aus einem Bereich (a, b) ohne Saatgut?

Die Funktion muss Int zurückgeben und nicht ein E /a-Int.
Ich habe eine Funktion X, die dauert und Int und andere Argumente-und Ausgänge etwas, was nicht IO.

Wenn dies nicht möglich ist, wie kann ich erstellen ein samenkorn mit der Zeit, die Bibliothek und das generieren einer zufälligen Zahl im Bereich mit den mkStdGen ?

Jede Hilfe wäre wirklich zu schätzen.

stackoverflow.com/a/2738824/570689 - nette Antwort für eine ähnliche Frage
Es klingt wie das beste, was Sie hoffen kann, ist randomInt lo hi = lo oder etwas in der Art. Ohne irgendeine Art von Samen oder IO die Funktion wieder den gleichen Wert jedes mal. Und die Untergrenze ist so zufällig wie jeder andere Int. 🙂
"Wer meint, dass sich der rechnerische Methoden zur Herstellung von Zufallszahlen ist, natürlich, in einem Zustand der Sünde." Zugeschrieben John Von Neumann in Knuth, D. The Art of Computer Programming, vol. 2, p. 1 (1981).
Ich glaube, der beste Weg, um eine zufällige Zahl in Haskell ohne IO-oder seed-Wert ist mit eine Funktion wie diese.

InformationsquelleAutor | 2011-12-07

haskell random

40

Einer Funktion zurückgeben kann eine Int ohne IO, es sei denn, es ist eine Reine Funktion, d.h. die gleiche Eingabe immer die gleiche Ausgabe. Dies bedeutet, dass wenn Sie ein zufällige Nummer, ohne IO, werden Sie brauchen, um einen Samen als argument.
- Wenn Sie sich dazu entschließen, ein samenkorn, es sollte vom Typ StdGen, und Sie können randomR zu generieren, die eine Reihe von es. Verwenden newStdGen zum erstellen einer neuen Samen (diese werden in IO).
```
> import System.Random
> g <- newStdGen
> randomR (1, 10) g
(1,1012529354 2147442707)
```
  Ergebnis randomR ist ein Tupel, wo das erste element ist der zufällige Wert, und die zweite ist eine neue Saatgut für die Erzeugung von mehr-Werten.
- Ansonsten können Sie randomRIO um eine Zufallszahl direkt in die IO Monade, mit allen StdGen Sachen kümmern für Sie:
```
> import System.Random
> randomRIO (1, 10)
6
```
- Für diejenigen, die dies tun, vergessen Sie nicht import System.Random!
InformationsquelleAutor hammar
5

Ohne Rückgriff auf alle Arten von unsicheren Praktiken, ist es nicht möglich, eine solche Funktion zu haben, geben Int eher als Typ IO Int oder etwas ähnliches. Funktionen (oder, in diesem Fall, Konstanten) vom Typ Int rein sind, was bedeutet, dass jedes mal, dass Sie "berufen" ist, die Funktion (abrufen des Werts der Konstanten) Sie werden garantiert, um den gleichen Wert "zurückgegeben".

Wenn Sie möchten, um einen anderen, zufällig gewählten Wert, der zurückgegeben wird, bei jedem Aufruf, werden Sie brauchen, um die Nutzung IO-Monade.

In einigen Fällen, möchten Sie vielleicht einen einzigen zufällig erzeugten Wert für das gesamte Programm, das heißt, einer, der, aus der Sicht des Programms verhält sich, als wäre es ein reiner Wert. Jedes mal, wenn die Abfrage den Wert in der gleichen Ausführung des Programms erhalten Sie den gleichen Wert zurück. Als das ganze Programm ist im wesentlichen eine IO-Aktion könnte man dann zu erzeugen, dass der Wert einmal, und übergeben Sie es herum, aber das kann sich ein wenig ungeschickt. Man könnte argumentieren, dass, in dieser situation, es ist immer noch sicher zu zuordnen, wird der Wert mit einer top-level-Konstante vom Typ Int und verwenden unsafePerformIO zu konstruieren, die Konstante:
```
import System.IO.Unsafe  -- be careful!                                         
import System.Random

-- a randomly chosen, program-scoped constant from the range [0 .. 9]            
c :: Int
c = unsafePerformIO (getStdRandom (randomR (0, 9)))
```
- Tun Sie das nicht!!
- Vor allem, tun Sie dies nicht ohne den sorgfältigen Lesen der Hinweise und Vorsichtsmassnahmen erwähnt in haskell.org/ghc/docs/latest/html/libraries/base/....
- Ihr link ist tot
- haskell.org/ghc/docs/latest/html/libraries/base/...
InformationsquelleAutor Stefan Holdermans

fmap yourFunctionX $ randomRIO (a, b)

oder

fmap (\x -> yourFunctionX aParam x anotherParam) $ randomRIO (a, b)

Das Ergebnis wird dann der Typ IO whateverYourFunctionXReturns.

Wenn Sie import Control.Applicative Sie sagen können

yourFunctionX <$> randomRIO (a, b)

oder

(\x -> yourFunctionX aParam x anotherParam) <$> randomRIO (a, b)

dem finden Sie klarere

InformationsquelleAutor dave4420

2

Beachten Sie, dass Sie eine unendliche Liste von zufälligen Werte mit Hilfe der IO-Monade und verwenden, die [Int] im nicht-IO-Funktionen. Auf diese Weise müssen Sie nicht haben, um zu tragen die Samen zusammen mit Ihnen, aber immer noch brauchen, um die Liste natürlich. Glücklicherweise gibt es eine fülle von list processing-Funktionen zu vereinfachen, wie threading-und Sie können noch State Monade in komplizierten Fällen.

Beachten Sie auch, dass Sie können leicht umwandeln ein IO Int zu Int. Wenn foo erzeugt ein IO Int, und die bar nimmt einen Int als parameter und gibt ein nicht-IO-Wert, wird Folgendes tun:
```
foo >>= return . bar
```
Oder mit do-notation:
```
do 
    a <- foo
    return $ bar a
```
Oder mit fmap (Monaden sind funktoren, und <$> ist ein infix-version von fmap):
```
bar <$> foo
```
InformationsquelleAutor nponeccop

Ich verwendet SipHash für diesen Zweck

import Data.ByteArray.Hash
import Data.ByteString (pack, cons)
import Data.Word (Word8, Word64)

random :: Word64 -> Word64 -> [Word8] -> Double
random a b cs = (subtract 1) . (/(2**63)) . read . drop 8 . show $ sipHash (SipKey a b) (pack cs)

lese-und drop 8 und zeigen Sie dem Zweck dienen, fallen, newtype, die nicht (oder nicht, wenn ich umgesetzt) unterstützt alle casting

jetzt willst du ein Int in einer Reihe. Integer ist einfacher aber:

random :: Word64 -> Word64 -> [Word8] -> (Integer, Integer) -> Integer
random a b cs (low,high) = let
    span = high-low
    rand = read . drop 8 . show $ sipHash (SipKey a b) (pack cs)
    in (rand `mod` span) + low

natürlich erhalten Sie noch die gleiche Nummer für die gleichen Argumente, jedes mal, so müssen Sie variieren Sie, dh Sie passieren noch um Argumente, nur keine Werte zu. Ob das bequemer ist, als eine Monade, hängt (für meinen Zweck)

dies ist, wie ich sicher Argumente (speziell die [Word8] - argument) würde immer anders sein:

foo bytes = doSomethingRandom bytes
bar bytes = map (\i -> foo (i:bytes)) [1..n]
baz bytes = doSomething (foo (0:bytes)) (bar (1:bytes))

InformationsquelleAutor some idiot

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.