Dúvidas exercícios triângulos e raízes

[Rafaela Soares]

Boa noite! 🙂

Desculpem estar a incomodar... Não consigo perceber quais são os erros que fiz nestes dois exercícios:

1) A função nRaizes que recebe os (3) coeficientes de um polinómio de 2º grau e que calcula o número de raízes (reais) desse polinómio:

No sublime, coloquei:

raizes :: Float -> Float -> Float -> [Float]
raizes a b c = ( ((-b) + sqrt(b^2 - 4 * a * c)) / (2 * a) ,
                 ((-b) - sqrt(b^2 - 4 * a * c)) / (2 * a) )

E, depois, apareceu no terminal:

rafaela@rafaela-X541UV ~/Documents/LI1 $ ghci
GHCi, version 7.10.3: http://www.haskell.org/ghc/ :? for help
Prelude> :l ra.hs
[1 of 1] Compiling Main             ( ra.hs, interpreted )

ra.hs:2:16:
    Couldn't match expected type ‘[Float]’
                with actual type ‘(Float, Float)’
    In the expression:
      (((- b) + sqrt (b ^ 2 - 4 * a * c)) / (2 * a),
       ((- b) - sqrt (b ^ 2 - 4 * a * c)) / (2 * a))
    In an equation for ‘raizes’:
        raizes a b c
          = (((- b) + sqrt (b ^ 2 - 4 * a * c)) / (2 * a),
             ((- b) - sqrt (b ^ 2 - 4 * a * c)) / (2 * a))
Failed, modules loaded: none.

 

2)  Defina uma função que recebe 3 pontos que são os vértices de um triângulo e devolve um tuplo com o comprimento dos seus lados.

No sublime, meti:

type Ponto = (Float,Float)
compr :: Ponto -> Ponto -> Ponto -> (Float, Float, Float)
compr a b c = sqrt ((fst b-fst a)^2 + (snd b-snd a)^2))
              sqrt ((fst c-fst b)^2 + (snd c-snd b)^2))
              sqrt ((fst c-fst a)^2 + (snd c-snd a)^2))

No terminal, aparece:

rafaela@rafaela-X541UV ~/Documents/LI1 $ ghci
GHCi, version 7.10.3: http://www.haskell.org/ghc/ :? for help
Prelude> :l rafs.hs
[1 of 1] Compiling Main             ( rafs.hs, interpreted )

rafs.hs:3:55: parse error on input ‘)’
Failed, modules loaded: none.
Prelude>

Obrigada a quem teve paciência para ler até aqui... Aguardo alguma resposta...

 

Beijinhos 👍

Edited October 1, 2016 at 07:14 PM by pwseo
syntax highlight...

[pwseo]

@Rafaela Soares,

Os erros que tens no teu código dizem todos respeito a falhas na sintaxe, a qual não dominas ainda. No primeiro caso, é-te dito claramente que estás a devolver um tuplo ((Float, Float)) onde se esperava uma lista ([Float]). No segundo caso o erro é menos directo: tens um ) inesperado em todas as linhas e, se reparares bem, não é esse o único problema. Consegues descobrir o que falta?

[Rafaela Soares]

9 minutes ago, pwseo said:

@Rafaela Soares,

Os erros que tens no teu código dizem todos respeito a falhas na sintaxe, a qual não dominas ainda. No primeiro caso, é-te dito claramente que estás a devolver um tuplo ((Float, Float)) onde se esperava uma lista ([Float]). No segundo caso o erro é menos directo: tens um ) inesperado em todas as linhas e, se reparares bem, não é esse o único problema. Consegues descobrir o que falta?

A primeira já funciona, thanks!! Se bem que quando coloco raizes 1 2 3 aparece [NaN,NaN].

Relativamente à segunda, não faço a mínima :/

[pwseo]

Tens que ler as mensagens de erro que o ghci emite:

rafs.hs:3:55: parse error on input ‘)’

Como se pode ver facilmente, no ficheiro rafs.hs, linha 3, coluna 55, tens um erro num ) (que provavelmente está a mais). Corrige isso e vê que erro o ghci te vai emitir a seguir (se é que vai haver erro)

[Rafaela Soares]

16 hours ago, pwseo said:

Tens que ler as mensagens de erro que o ghci emite:

rafs.hs:3:55: parse error on input ‘)’

Como se pode ver facilmente, no ficheiro rafs.hs, linha 3, coluna 55, tens um erro num ) (que provavelmente está a mais). Corrige isso e vê que erro o ghci te vai emitir a seguir (se é que vai haver erro)

Sim, esse eu percebi. O outro é que não :/

[pwseo]

Pois, o outro erro é capaz de ser mais complicado de compreender. Vamos fazer de outra forma. Imagina que tens uma função dist que calcula a distância entre dois pontos:

dist :: Ponto -> Ponto -> Float
dist = ...

De que forma escreverias a função compr utilizando a função dist?

compr :: Ponto -> Ponto -> Ponto -> (Float, Float, Float)
compr a b c = undefined   -- completa isto

[Rafaela Soares]

2 horas atrás, pwseo disse:

Pois, o outro erro é capaz de ser mais complicado de compreender. Vamos fazer de outra forma. Imagina que tens uma função dist que calcula a distância entre dois pontos:

dist :: Ponto -> Ponto -> Float
dist = ...

De que forma escreverias a função compr utilizando a função dist?

compr :: Ponto -> Ponto -> Ponto -> (Float, Float, Float)
compr a b c = undefined   -- completa isto

Acho que fiz de uma forma muito extensiva, mas consegui. Obrigada!!

 

type Ponto = (Float,Float)
compr :: Ponto -> Ponto -> Ponto -> (Float, Float, Float)
compr (a,b) (c,d) (e,f) = (dist (a,b) (c,d), dist (c,d) (e,f), dist (a,b) (e,f))

              
dist :: Ponto -> Ponto -> Float
dist (a,b) (c,d)= sqrt ((c-a)^2 + (d-b)^2)
dist (c,d) (e,f)= sqrt ((e-c)^2 + (f-d)^2)
dist (a,b) (e,f)= sqrt ((e-a)^2 + (f-a)^2)

 

Edited October 2, 2016 at 03:36 PM by pwseo
syntax highlight

[pwseo]

@Rafaela Soares,

A forma que utilizaste para resolver mostra que não compreendeste bem o conceito da definição de uma função. Tens 3 definições exactamente iguais de dist, apenas mudaste os nomes das variáveis; para o compilador, escreveste exactamente a mesma coisa em cada uma das linhas onde definiste dist. A única definição que precisavas era:

dist :: Ponto -> Ponto -> Float
dist (x1,y1) (x2,y2) = sqrt ( (x2-x1)^2 + (y2-y1)^2 )

Como se pode ver, dist não precisa de saber quais os pontos que lhe passaste. Basta que receba quaisquer dois pontos para que depois te devolva o valor da distância entre eles.

Depois, bastaria utilizar essa função na definição de compr. No entanto, também nesta parte foste demasiado exaustiva (só precisavas de referir que a função recebe os argumentos a b c em vez dos tuplos (a,b) (c,d) (e,f)), bastando na realidade o seguinte:

compr :: Ponto -> Ponto -> Ponto -> (Float, Float, Float)
compr a b c = (dist a b, dist b c, dist c a)

Da forma que fizeste é muito fácil perderes-te nos argumentos e fazer asneira ao confundir alguma das coordenadas/argumentos. Da forma que eu mostrei ser mais adequada reduzes muito a possibilidade de erro, e a leitura do código fica também muito mais fácil.

Adicionalmente, podes definir dist apenas no contexto de compr, assim:

compr :: Ponto -> Ponto -> Ponto -> (Float, Float, Float)
compr a b c = (dist a b, dist b c, dist c a)
  where
    dist (x1,y1) (x2,y2) = sqrt ( (x2-x1)^2 + (y2-y1)^2 )

[Rafaela Soares]

Obrigadaaaaa e desculpa estar sempre a incomodar. Ainda me faz alguma confusão ter de ser tão sintética...

[pwseo]

A questão não é teres de ser sintética (não é obrigatório); Haskell permite-te dizer muita coisa em poucas linhas de código e, normalmente, quanto menos código utilizas, mais legível fica a ideia que lhe está subjacente. Mas isso é algo que se consegue com a prática, sendo perfeitamente normal escrever código maior no início.

Adicionalmente, ali onde colocaste a mesma definição 3x deu para perceber que não compreendeste completamente a que se referiam os nomes dos argumentos, algo que deverás estudar melhor, portanto. 🙂