Carte appliqué à plusieurs arguments en Haskell

Est-il un moyen d'utiliser Haskell "carte" ou quelque chose de similaire avec plusieurs arguments?

c'est à dire à trouver la distance entre un point donné (défini comme un n-uplet) et une liste d'autres points:

map distance (-3,-3) buildings

Clairement, cela ne fonctionne pas, parce qu'il essaie de carte "à distance" (-3,-3), où la distance n'attend deux tuples:

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

distance prend deux points comme arguments: l'un est (-3,-3) dans cet exemple, et l'on est sélectionné à partir de la liste des "bâtiments".

(-3,-3) est juste un exemple. Ce devra être une variable; il ne peut pas être codé en dur dans la fonction.

Peut-être que cela fera un peu plus de sens:

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.

OriginalL'auteur Jason B | 2010-03-01

functional-programming haskell

10

vous voulez:
```
map (distance (-3, -3)) buildings
```
qui est
```
map f buildings 
  where f = distance (-3, -3)  
```
distance prend deux points comme arguments: l'un est (-3,-3) dans cet exemple, et l'on est sélectionné à partir de la liste des "bâtiments". (-3,-3) est juste un exemple. Ce devra être une variable; il ne peut pas être codé en dur dans la fonction.
de toute évidence, "carte (distance firstpoint) bâtiments", ne serait-il pas? Ou pour dire les choses crûment: "frombuilding des bâtiments = map (distance point) les bâtiments"
Bien sûr, vous pouvez remplacer (-3, -3) avec une variable.
Mon erreur, il s'avère un bug dans ma fonction de distance a été de lancer une erreur; fixation-il permis que cela fonctionne assez bien. Merci!
vous pourriez aussi avoir besoin de jeter un fromIntegral dans: distance pointA pointB = (sqrt.fromIntegral) ( (frst pointB - frst pointA) * (frst ...

OriginalL'auteur 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

Belle déduction de point de forme libre.

OriginalL'auteur ephemient

Après avoir vu le commentaire sur ja réponse je devine que vous souhaitez utiliser zipWith

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

La la documentation états:

zipWith généralise zip par compression avec la fonction donnée comme premier argument, au lieu d'un tupling fonction. Par exemple, zipWith (+) est appliqué à deux listes de produire la liste des sommes correspondantes.

Dans votre code ci-dessus, cela pourrait ressembler à:

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]

OriginalL'auteur 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 est la fonction que vous avez décrit, alors que func2 est similaire, mais plusieurs points de départ au lieu d'un seul et trouve la distance entre chaque combinaison avec les points de fin.

OriginalL'auteur Thomas Eding
0

La formule de la distance est simple:
```
distance :: Floating a => (a,a) -> (a,a) -> a
distance (x1,y1) (x2,y2) = sqrt $ (x2 - x1)^2 + (y2 - y1)^2
```
Notez l'utilisation de pattern matching pour décomposer les arguments plutôt que simplement le code avec fst et snd.

Distances respectives à partir d'un point donné à tous les points de la liste est ensuite
```
distanceFrom :: Floating a => (a,a) -> [(a,a)] -> [a]
distanceFrom p = map (distance p)
```
Bien que les arguments semblent manquer, c'est connu dans le langage Haskell comme l'application partielle. Dans distanceFrom, nous avons deux d'entre eux:
1. distance p est une fonction en un point dont la valeur est le point de distance de p
2. map (distance p) est une fonction d'une liste de points dont la valeur est de ces points de distances respectives de p
Essayer de concevoir votre Haskell fonctions pour l'application partielle pour le rendre facile à combiner des petites fonctions en plus gros. Comme indiqué dans ephemient réponse, vous pourriez faire un pas de plus pour obtenir pointfree définition (pas explicite arguments)—plus d'élégance, un style avancé.

La distance de chaque point dans buildings de tous les points de lPoints est alors
```
main :: IO ()
main = do
  mapM_ (putStrLn . unwords . map (printf "%6.3f")) score
  where
    score = [ distanceFrom x buildings | x <- lPoints ]
```
Par exemple, de faire lPoints et buildings l'égalité, la sortie est
```
 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
```
Mais c'est un peu ennuyeux dans ce cas particulier, compte tenu de toutes les redondances. Au lieu d'imprimer le stricte triangle supérieur, utilisez
```
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
```
De sortie:
```
 3.162 5.385 5.099 1.414 
3.606 2.828 2.828 
1.000 4.123 
4.000
```
Je n'ai pas l'obtenir. Quel est le point de l'impression des choses comme ça? C'est seulement redondant si lPpoints et les bâtiments sont égaux.
"Dans ce cas" qui était dans ma tête de ne pas le faire à ma réponse. Merci et édité!

OriginalL'auteur Greg Bacon

Vous devez vous connecter pour publier un commentaire.