Karte angewendet, um mehrere Argumente in Haskell

Gibt es eine Möglichkeit, die Verwendung von Haskell ist "Karte" oder etwas ähnliches mit mehreren Argumenten?

d.h. der Abstand zwischen einem gegebenen Punkt (definiert als Tupel) und eine Liste von anderen Punkte:

map distance (-3,-3) buildings

Klar, das funktioniert nicht, weil es versucht, die Karte "Abstand" zu (-3,-3), wo die Entfernung erwartet zwei Tupel:

let distance pointA pointB = sqrt ( (frst pointB - frst pointA) * (frst pointB - frst pointA) + (scnd pointB - scnd pointA) * (scnd pointB - scnd pointA) )

Abstand nimmt zwei Punkte als Argumente: man (-3,-3) in diesem Beispiel, und man wird aus der Liste ausgewählt "Gebäude".

(-3,-3) ist nur ein Beispiel. Dieser muss eine variable sein; es kann nicht hardcoded in die Funktion.

Vielleicht wird dies ein bisschen mehr Sinn machen:

buildings = [(3,-2),(2,1),(5,3),(4,3),(4,-1)]

firstDiff pointA pointB = subtract ( fst pointA ) ( fst pointB )

secondDiff pointA pointB = subtract ( snd pointA ) ( snd pointB )

distance pointA pointB = sqrt ( (firstDiff pointA pointB) * (firstDiff pointA pointB) +     (secondDiff pointA pointB) * (secondDiff pointA pointB))

--- What I need to happen here is a list "score" to be created by taking all distances from a point in a list lPoints to a point in list buildings.

InformationsquelleAutor Jason B | 2010-03-01

functional-programming haskell

11

du willst:
```
map (distance (-3, -3)) buildings
```
ist
```
map f buildings 
  where f = distance (-3, -3)  
```
- Abstand nimmt zwei Punkte als Argumente: man (-3,-3) in diesem Beispiel, und man wird aus der Liste ausgewählt "Gebäude". (-3,-3) ist nur ein Beispiel. Dieser muss eine variable sein; es kann nicht hardcoded in die Funktion.
- offensichtlich "Karte (Entfernung firstpoint) Gebäuden" arbeiten würden, wäre es nicht? Oder um es klar zu sagen: "frombuilding Punkt Gebäude = map (Abstand Punkt -) Gebäude"
- Natürlich kann man ersetzen, (-3, -3) mit einer Variablen.
- Mein Fehler, es stellt sich heraus einen Fehler in meiner Strecke wurde die Funktion wirft einen Fehler; Befestigung erlaubt dies ganz gut zu funktionieren. Danke!
- möglicherweise müssen Sie auch zu werfen fromIntegral in: Distanz pointA pointB = (sqrt.fromIntegral) ( (frst pointB - frst pointA) * (frst ...
- Das ist genau das, was aufgewickelt zu fixieren
InformationsquelleAutor ja.

allDistances src dests = map (\point -> distance src point) dests

allDistances src dests = map (distance src) dests

allDistances src = map (distance src)

allDistances = map . distance

Schöner Abzug der point-free-Formular.

InformationsquelleAutor ephemient

Nachdem ich den Kommentar ja die Antwort, die ich vermute die Sie verwenden möchten zipWith

Prelude>:type zipWith
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

Den Dokumentation Staaten:

zipWith vergröbert zip zippen und mit der Funktion, die als erstes argument anstelle eines tupling-Funktion. Zum Beispiel, zipWith (+) wird angewendet, um zwei Listen zu erzeugen, die Liste der entsprechenden Summen.

Also in deinem obigen code könnte dies so Aussehen:

Prelude> let dist a b = sqrt ( (fst b - fst a) * (fst b - fst a) + (snd b - snd a) * (snd b - snd a) )
Prelude> let buildings = [(1.0,1.0 ), (3.0,3.0 ), (4.0,4.0)]
Prelude> let points = [ (1.2, 2.23), (2.23, 34.23), (324.3, 34.3) ]
Prelude> zipWith dist points buildings
[1.2461540835707277,31.239491032985793,321.7299799521332]

InformationsquelleAutor Bas Bossink

0
```
distance (x, y) (z, w) = sqrt $ (x - z) ^ 2 + (y - w) ^ 2

func1 = map . distance

func2 starts ends = starts >>= flip func1 ends
```
func1 ist die Funktion, die Sie beschrieben, in der Erwägung, dass func2 ist ähnlich, aber nimmt in mehreren start-Punkte statt nur einem und findet den Abstand zwischen jeder Kombination mit den Endpunkten.

InformationsquelleAutor Thomas Eding
0

Den Abstand Formel ist einfach:
```
distance :: Floating a => (a,a) -> (a,a) -> a
distance (x1,y1) (x2,y2) = sqrt $ (x2 - x1)^2 + (y2 - y1)^2
```
Beachten Sie die Verwendung von pattern-matching, um zu zerlegen die Argumente eher als littering-code mit fst und snd.

Die jeweiligen Entfernungen ab einem bestimmten Punkt alle Punkte in einer Liste wird dann
```
distanceFrom :: Floating a => (a,a) -> [(a,a)] -> [a]
distanceFrom p = map (distance p)
```
Obwohl die Argumente scheinen zu fehlen, diese ist bekannt, dass im Haskell-Jargon als partielle Anwendung. In distanceFrom haben wir zwei von Ihnen:
1. distance p ist eine Funktion von einem Punkt, dessen Wert ist der Punkt, der Abstand von p
2. map (distance p) ist eine Funktion, der eine Liste von Punkten, deren Wert diese Punkte den jeweiligen Entfernungen von p
Versuchen, Ihre design-Haskell-Funktionen für die partielle Anwendung machen es einfach, zu kombinieren, kleine Funktionen in größeren. Wie bereits in ephemient Antwort, könnten Sie tragen diese einen Schritt weiter zu kommen pointfree definition (keine expliziten Argumente)—ein eleganter, fortschrittliche Stil.

Den Abstand zu jedem Punkt in buildings aus alle Punkte in lPoints ist dann
```
main :: IO ()
main = do
  mapM_ (putStrLn . unwords . map (printf "%6.3f")) score
  where
    score = [ distanceFrom x buildings | x <- lPoints ]
```
Zum Beispiel, indem lPoints und buildings gleich, der Ausgang ist
```
 0.000 3.162 5.385 5.099 1.414 
3.162 0.000 3.606 2.828 2.828 
5.385 3.606 0.000 1.000 4.123 
5.099 2.828 1.000 0.000 4.000 
1.414 2.828 4.123 4.000 0.000
```
Aber das ist ein wenig langweilig in diesem speziellen Fall angesichts all der Redundanz. Stattdessen drucken Sie die strikte Obere Dreieck, verwenden Sie
```
strictUpperTriangle :: [[a]] -> [[a]]
strictUpperTriangle [] = []
strictUpperTriangle xs = go (init xs)
  where go (x:xs) = tail x : map tail (go xs)
        go [] = []

printSUT :: PrintfArg a => [[a]] -> IO ()
printSUT sut = putStr (unlines $ map pad sut)
  where n = length sut
        pad xs = let k = n - length xs in
                 unwords $ take k blanks ++ map (printf "%*.3f" w) xs
        blanks = repeat (take w $ repeat ' ')
        w = 6 :: Int

main :: IO ()
main = printSUT tri
  where
    score = [ distanceFrom x buildings | x <- lPoints ]
    tri = strictUpperTriangle score
```
Ausgabe:
```
 3.162 5.385 5.099 1.414 
3.606 2.828 2.828 
1.000 4.123 
4.000
```
- Ich verstehe es nicht. Was ist der Punkt der Druck, Dinge wie das? Es ist nur redundant, wenn lPpoints und Gebäuden gleich sind.
- "In diesem Fall", dass war in meinem Kopf schaffte es nicht auf meine Antwort. Danke und geändert!
InformationsquelleAutor Greg Bacon

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.