UTNianos

Estimados,
Alguno tiene el final de pdep tomado 06/12/2014 (ayer)?

gracias

Aca te lo dejo:

gracias

1) Conceptos: Redefinicion de métodos, variables de clases (extra).
La idea era decir que en la solución actual habría que modificar cada método de instancia.

Si modificamos nuestra solución, solo habría que modificar un método:
#EntradaConMiTarjeta
>>precio
(super precio) - 25

#EntradaMiercoles
>>precio
(super precio) * 0.50

y se podría proponer una variable de clase, para así poder modificar el precio de TODAS las entradas desde el workspace (si utilizara una VI tendría que cambiar 1 x 1).

#Entrada
vc: PrecioBase
>>precio (mi)
PrecioBase

2) Nos dicen que:


a. Conceptos: Polimorfismo, LookUp
Cuando Pelicula le pide el precio a todas las entradas, Entrada3D y sus subclases no lo entienden, entonces devolverán el precio de Entrada (por el método lookup).

b.Conceptos: Repetición de lógica.
Debido a que no hay reutilización de código, se repite (self precio +30).
Pero tambien existe otra repetición de lógica en los descuentos.

c.


#DescuentoMiercoles
>>descuento: precioBase
^(precioBase) * 0.50

#DescuentoConMiTarjeta
>>descuento: precioBase
^(precioBase) - 25

#SinDescuento
>>descuento: precioBase
^(precioBase)

#Entrada
>>precio
^ (descuento: PrecioBase)

#Entrada3D
>>precio
^(super precio + 30)

d. Conceptos: Efecto de Lado
En el Paradigma Objetos, existe efecto de lado, por lo que la venta de una entrada, generaría una nueva instancia de Entrada que se agregaría a la lista de entradasVendidas de una Película. En el Paradigma Funcional existe transparencia referencial, lo que nos limita a que cada vez que realicemos una venta, nos de el mismo resultado. La coleccción de Entradas volverá a su estado original luego de ejecutar la función.

sos ayudande de pdep?

si, por?

5) a.
f h m p z | h `elem` z = (head.filter (m h)) z
| otherwise = fst p

f es una funcion claro;
z es una lista, por ser el segundo parámetro de la funciones elem y filter;
h es del mismo tipo que los elementos de z, así puedo hacer el elem, ej: elem 'a' "hola", elem 1 [1,2,3,4];
* ademas h debe ser igualable, ya que elem se fija si los elementos de una lista son iguales al primer parámetro;
p es una tupla de 2 componentes por poder hacerle fst;
m es una funcion a la que pasada como parámetro h, queda aplicada parcialmente, ej: filter (==3) [2,3,4], filter (=='a') "hola" en ambos casos m es (==)

Si h se encuentra en z = la funcion devuelve el primer elemento de z que cumpla con (m h), osea que devuelve un elemento del tipo de los elementos de la lista z.
En cualquier otro caso = devuelve el primer elemento de la tupla p.

El tipo de dato que devuelve f siempre debe ser el mismo, osea que "el primer elemento de la tupla p" es del mismo tipo que "los elementos de la lista z"

Por tanto:
f:: Eq a => a -> ( a -> a -> Bool ) -> ( a , b ) -> [a] -> a

Me podrías ayudar a revisar mi resolución, la hice sin ver la tuya, creo que tarde 2 horas. Cuanto tiempo estan dando para rendir?2:30hs?

--------------------------------------------------------------------------------------------------------------------------------------------------

final 6/12/14

1) En la solucion actual se deberia modificar el valor de la entrada normal, se debería
modificar la clase Entrada, y ademas sería necesario modificar las subclases "entradaConmitarjeta"
y "entradamiercoles", ya que estas ya tiene el valor con el descuento, y no lo calcula.

Una solucion posible sería hacer que cada Subclase le pregunta a la clase "Entrada por el valor de la entrada"
normal, y que estas subclase realicen el calculo, de esa manera si cambia el valor
de la entrada solo seria necesario modificar el clase "Entrada" y nos sus subclases.

ejemplo:

#Entrada
>>precio

^110.

#EntradaConMiTarjeta

>>precio

^ super precio - 25

{aqui la pregunta a su superclase el valor de la entrada normal}

#EntradaMiercoles

>>precio

^ super precio*0.5

2)

a) Estas nuevas subclases calculan su precio usando el metodo "precio3D", y en la implementacion
de la clase "Pelicula" el metodo "recaudacion" recorren la coleccion preguntando "precio",
lo cual estas subclases van a devolver el valor del metodo "precio" y no el correcto
que debería ser "precio3D", por lo cual el metodo "recaudacion" estaría calculando
mal la recaudacion de las entradas vendidas.
La ausencia de poliformismo enlas subclases, generan este inconveniente, la clase
"pelicula" deber tratar a cada entrada como si fueron todas iguales.

b)
La logica repetida se puede apreciar en cada metodo "precio3D", en cada instante
consulta el metodo "precio", cuando podía consulta direcmaente a la superclase, tambien
se repite el codigo con las otras clases "EntradaConmiTarjeta" y "EntradaMiercoles"
todas realizar el descuentor por si solas, cuandor podrian todas estas subclases
pregunta a una sola clase el descuento.

c)

Cree una clase llamada "Descuento" con sus respectivas subclases " DescuentoMitarjeta"
y "DescuentoMiercoles", estas se van a encargar de calcular los decuentos, ademas
si necesito agregar algun descuento, solo seria necesario modificar la clase
descuento, y todos las demas clases no serían afectadas, tampoco se enterarian.

#Entrada (Vi precio, midescuento)

>>precio

^ miescuento descuento:precio.

#Entrada3D (Vi valor3D, midescuento)

>>precio
^ valor3D + midescuento descuento:super precio.

#DescuentoCero
>>descuento:UnPrecio
^Unprecio

#DescuentoMiercoles
>>descuento:unPrecio
^unPrecio*0.5

#DescuetoMitarjeta
>>descuento:unPrecio
^unPrecio + 25

{aca se puede ver que agregando cualquier otro descuento, como subclase}

Diagrama de Clases {no lo dibujar, pero es puede armar en base a la relaciones y clases}


[PELICULA] ------*-> [ENTRADA] <--Subclase-- [[Entrada3d]]

{Esta clase se relaciona con ENTRADA}
[DESCUENTO]<--3subclases-- [[DescuentoMitarjeta]]
[[DescuentoCero]]
[[DecuentoMiercoles]]


d)Funcional solo acepta listas del mismo tipo, en cambio en objetos las colecciones
no necesitan ser del mismo tipo.
Si la lista de entradas es de diferentes tipo, no se podra implemntar dicha solucion
en FUNCIONAL (haskell), fuera esa detalla, la ventaja que podemos notar entre funcioal
y objtos, en los que respecta listas y colecciones,es que es haskell las listas puende
ser infinitas (gracias a evaluacion diferida) y esto no es posible en objetos.
Ademas en haskell no hay asignacion, ni efecto colateral, por lo cual no podríamos
guardar las peliculas vendidas y las No. En objeto existe la asignacion y efecto de lado.

3) Propongo crear una relacion llamada precioTotal(Pelicula,PrecioTotal), esta misma
acepta tanto "entrada(Pelicula,Tipo)" como "entrada(Pelicula,Tipo,Descuento)", lo cual la
hace poliformica gracias al patternmatchin, aceptando cualquier tipo de pelicula, y evitando repetir codigo.


precioTotal(Pelicula, PrecioTotal):-

entrada(Pelicula, Tipo),
precio(Tipo,Precio),
Preciototal is Precio

precioTotal(Pelicula, PrecioTotal):-

entrada(Pelicula, Tipo, Descuento),
precioDescontado(Tipo,Descuento,Precio),
PrecioTotal is Precio.

recaudacion(Pelicula, Recaudacion):-

pelicula(Pelicula),
findall(Precio, precioTotal(Peli,Precio), ListaDeprecios),
sumlist(ListaDeprecios, Racaudacion).

4)
La solucion de lista recursiva tiene mas detalle de codigo, lo cual la hace menos declarativa,
tambien eso afecta a su expresividad, ya que es mas dificil de entenderla al leer, la solucion
2 emplea mas logica realacional, ya que utiliza los predicados existentes,

la solucion 1 devuelve la Pelicula que mas recaudo, en cambio la solucion 2 solo devuelva si
la pelicula Evaluada es la Mas recaudadora o NO.

En la solucion 2 busca peliculas con mayor recaudacion, mientras que en la solucion1 se
contempla recaudaciones mayores o iguales.


5)
a) Tipo d ela funcion
f :: a ->(a->a->bool)->(a,b)->[a]-> a

b)
Orden superior: Se ven reflejados a pasar la funcion "m", como parametro,
tambien el uso del filter, simplica la funcion y evita repetir codigo.


composicion: se ve en Head.filter , componer funciones permite unir funcionalidades
, reducir codigo, hacer que sea mas expresiva y declarativo, evitando tanto detalles de codigo.

aplicacion parcial:


c) Si es posible, gracias a que funcional utiliza evalucion diferida,

ejemplo1:

f 5 max (100,"tv") [1...]

>> 6

ejemplo2:


f 5 min (100,"tv") [100...]

>> 100

Cita:{aqui la pregunta a su superclase el valor de la entrada normal}

Le pide, no le pregunta.

Recomiendo escribir el concepto del cual queres hablar en la primer o segunda oración.
Por ejemplo en 2.b escribir literalmente:
"Falta Polimorfismo: Estas nuevas subclases ..."
Hasta hay alguna gente que subraya, remarca, o escribe con otro color los conceptos.

en el 2.d te fuiste por las ramas.
Para que vas a tener una lista de entradas vendidas infinitas?
Lo importante es el efecto de lado / transparencia referencial.

Cita:ademas
si necesito agregar algun descuento, solo seria necesario modificar la clase
descuento, y todos las demas clases no serían afectadas, tampoco se enterarian.

En realidad deberias agregar una subclase de descuento y redefinir su método precio.

Hay algunos errores de codigo, pero son pequeños.

Si puedo lo veo mas en detalle en la semana.
Saludos

dale. genial.

gracias por los tips, tengo que rendir el prox. sabado, y quería ver si estoy en condiciones.
muchas gracias

Alguno me diría cuales son las condiciones de aprobación del final? Hay que tener bien algo de cada paradigma o no importa?

Y cuanto tiempo dan para resolverlo?

Gracias

2 horas para resolverlo y
hay que tener cosas bien de los 3 paradigmas

(11-12-2014 13:21)facundoaita escribió: [ -> ]2 horas para resolverlo y
hay que tener cosas bien de los 3 paradigmas

Un Roca y me corregís vos el final?. .

Gracias por el aporte.

uuuh, la bajaste con lo de los 3 paradigmas jaja.

FacundoAita, como estas?
Lograste ver mi desarrollo? quisiera saber en que situacion esta mi desarrollo, ya que voy a rendir este sabado.
muchas gracias