fmod EnviosYPaques is

protecting FLOAT .

protecting INT .

protecting STRING .

protecting BOOL .

sorts Cliente LCliente Envio LEnvio Paque LPaque .

subsort Cliente < LCliente .

subsort Envio < LEnvio .

subsort Paque < LPaque .

op nilLCliente : -> LCliente [ctor] .

op _ _ : LCliente LCliente -> LCliente [ctor assoc id: nilLCliente] .

op Cliente(_,_,_) : Int String Int -> Cliente [ctor] .

op nilLEnvio : -> LEnvio [ctor] .

op _ _ : LEnvio LEnvio -> LEnvio [ctor assoc id: nilLEnvio] .

op Envio(_,_,_,_,_,_,_) : Int String String Float Float Float Float -> Envio
[ctor] .

op nilLPaque : -> LPaque [ctor] .

op _ _ : LPaque LPaque -> LPaque [ctor assoc id: nilLPaque] .

op Paque(_,_) : Float Float -> Paque [ctor] .

vars IDE IDC IDCA PT : Int .

vars IDP F T M: Int .

vars ND NDB CT MD : String .

vars PW PV VC VP :Float .
 vars W V PR : Float .

vars E A : Envio .

vars LP TP : LPaque .

vars LE TE : LEnvio .

vars LC TC : LCliente .

var C : Cliente .

var P : Paque .

*** Calcula monto bruto

op montoBruto(_,_,_) : Envio Paque Cliente -> Float .

ceq montoBruto(Envio(_,_,_,PW,PV,VC,VP,_),Paque(_,_,W,V),_) =(W *

PW + (V - VC) * PV) if( V < VC) .

ceq montoBruto(Envio(_,ND,_,PW,_,_,_,_),Paque(_,_,W,_),Cliente(_, MD,

_)) = (W * PW) if(MD =/= ND) .

*** Calcula el Iva a pagar

op Iva(_,_,_) : Envio Paque Cliente -> Float .

ceq Iva(Envio(_,_,CT,_,_,_,_,_),P,C) =
(montoBruto(Envio(_,_,CT,_,_,_,_,_),P,C) * 0.15) if(CT == "aereo") .

ceq Iva(Envio(_,_,CT,_,_,_,_,_),P,C) =
(montoBruto(Envio(_,_,CT,_,_,_,_,_),P,C) * 0.1) if(CT == "terrestre") .

ceq Iva(Envio(_,_,CT,_,_,_,_,_),P,C) =
(montoBruto(Envio(_,_,CT,_,_,_,_,_),P,C) * 0.05) if(CT == "barco") .

*** Calcula el monto neto

op montoNeto(_,_,_): Envio Paque Cliente -> Float .

ceq montoNeto(Envio(_,_,_,_,_,_,VP,_),P,Cliente(_,_,PT)) =
(montoBruto(Envio(_,_,_,_,_,_,VP,_),P,Cliente(_,_,PT)) +
Iva(Envio(_,_,_,_,_,_,VP,_),P,Cliente(_,_,PT)) - (VP * float(PT)) if((VP * float(PT))
< (montoBruto(Envio(_,_,_,_,_,_,VP,_),P,Cliente(_,_, PT)))) .

ceq montoNeto(Envio(_,_,_,_,_,_,VP,_),P,Cliente(_,_,PT)) =
(Iva(Envio(_,_,_,_,_,_,VP,_),P,Cliente(_,_, PT))) if((VP * float(PT)) > =
(montoBruto(Envio(_,_,_,_,_,_,VP,_),P,Cliente(_,_, PT))).

*** Halla los envios con un destino dado.

op bDestino(_,_,_): String LEnvio LEnvio-> LEnvio .

ceq bDestino(NDB,Envio(_,ND,_,_,_,_,_,_) LE,TE)= bDestino(NDB,LE,TE

Envio(_,ND,_,_,_,_,_,_)) if(NDB == ND) .

ceq bDestino(NDB,Envio(_,ND,_,_,_,_,_,_) LE,TE)= bDestino(NDB,LE,TE)

if(not(NDB == ND)) .

eq bDestino(_,nilLEnvio,TE)= TE .

*** Halla el mejor envio para un cliente con un paquete , de una lista
de envios , de manera iterativa

op bEnvio(_,_,_,_): Cliente Paque LEnvio Envio -> Envio .

ceq
bEnvio(Cliente(IDC,MD,PT),Paque(_,_,W,V),Envio(IDE,ND,CT,PW,PV,VC,VP,_)
LE, A)= bEnvio(Cliente(IDC,MD,PT),Paque(_,_,W,V),LE,A)
if(not(motnoNeto(Envio(IDE,ND,CT,PW,PV,VC,VP,_),Paque(_,_,W,V),Cliente(IDC
,MD,PT)) < motnoNeto(A,Paque(_,_,W,V),Cliente(IDC,MD,PT)))) .

ceq
bEnvio(Cliente(IDC,MD,PT),Paque(_,_,W,V),Envio(IDE,ND,CT,PW,PV,VC,VP,_)
LE, A)=
bEnvio(Cliente(IDC,MD,PT),Paque(_,_,W,V),LE,Envio(IDE,ND,CT,PW,PV,VC,VP,_)
if(motnoNeto(Envio(IDE,ND,CT,PW,PV,VC,VP,_),Paque(_,_,W,V),Cliente(IDC,MD
,PT)) < motnoNeto(A,Paque(_,_,W,V),Cliente(IDC,MD,PT))) .

ceq
bEnvio(Cliente(IDC,MD,PT),Paque(_,_,W,V),Envio(IDE,ND,CT,PW,PV,VC,VP,_)
LE, A)= bEnvio(Cliente(IDC,MD,PT),Paque(_,_,W,V),bDestino(NDB,E
LE,nilLEnvio), A) if(not(ND == NDB) .

eq bEnvio(_,_,nilLEnvio,A)=A .

*** Halla lista de envios candidatos, para un paquete cuyo monto neto
por unidad de peso es menor que el presupuesto del cliente

op lCandidatos(_,_,_,_,_): Cliente Paque LEnvio Float LEnvio -> LEnvio .

ceq lCandidatos(C,Paque(_,_,W,V)),E LE,PR,TE)=

lCandidatos(C,Paque(_,_,W,V),LE,PR,TE)
if(not((montoNeto(E,Paque(_,_,W,V),C) / W) < PR)) .
 ceq lCandidatos(C,Paque(_,_,W,V),E LE,PR,TE)=
lCandidatos(C,Paque(_,_,W,V),LE,PR,TE E) if((montoNeto(E,Paque(_,_,W,V),C) /
W) < PR) .

ceq lCandidatos(C,Paque(_,_,W,V),E LE,PR,TE)=

lCandidatos(C,Paque(_,_,W,V),bDestino(NDB,E LE,nilLEnvio),PR,TE) if(not(ND
== NDB) .

eq lCandidatos(_,_,nilLEnvio,_,TE)= TE .

***Halla lista de envios con solo un paquete enviado por un cliente

op bcEnvio(_,_,_): Cliente LEnvio LEnvio -> LEnvio .

eq
bcEnvio(Cliente(IDC,MD,PT),Envio(IDE,ND,CT,PW,PV,VC,VP,nilLPaque) LE,TE)
= bcEnvio(Cliente(IDC,MD,PT),LE,TE) .

eq
bcEnvio(Cliente(IDC,MD,PT),Envio(IDE,ND,CT,PW,PV,VC,VP,Paque(IDP,IDCA,W,
V) LP) LE,TE)= bcEnvio(Cliente(IDC,MD,PT),Envio(IDE,ND,CT,PW,PV,VC,VP,LP)
LE,TE) .

eq
bcEnvio(Cliente(IDC,MD,PT),Envio(IDE,ND,CT,PW,PV,VC,VP,Paque(IDP,IDC,W,V
) LP) LE,TE)= bcEnvio(Cliente(IDC,MD,PT),Envio(IDE,ND,CT,PW,PV,VC,VP,LP)
LE, TE Envio(IDE,ND,CT,PW,PV,VC,VP,Paque(IDP,IDC,W,V)) .

eq bcEnvio(_,nilLEnvio,LE)= LE .

***Calcula MD y PT de un cliente de una lista de envios con un solo

paquete enviado por ese cliente

op recalMD(_,_,_,_,_): Cliente LEnvio Int Int Int -> Cliente .

eq
recalMD(Cliente(IDC,MD,PT),Envio(IDE,ND,"aereo",PW,PV,VC,VP,Paque(_,_,W,_
)) LE,F,T,M)= recalMD(Cliente(IDC,MD,(PT + 20 * W)),LE,(F + 1),T,M) .

eq
recalMD(Cliente(IDC,MD,PT),Envio(IDE,ND,"terrestre",PW,PV,VC,VP,Paque(_,_,
W,_)) LE,F,T,M)= recalMD(Cliente(IDC,MD,(PT + 10 * W)),LE,F,(T + 1),M) .

eq
recalMD(Cliente(IDC,MD,PT),Envio(IDE,ND,"barco",PW,PV,VC,VP,Paque(_,_,W,_
)) LE,F,T,M)=recalMD(Cliente(IDC,MD,(PT + 5 * W)),LE,F,T,(M + 1)) .

ceq recalMD(Cliente(IDC,MD,PT),nilLEnvio,F,T,M)=
Cliente(IDC,"aereo",PT) if(F > T and F > M) .
 ceq recalMD(Cliente(IDC,MD,PT),nilLEnvio,F,T,M)=
Cliente(IDC,"terrestre",PT) if(T > F and T > M) .

ceq recalMD(Cliente(IDC,MD,PT),nilLEnvio,F,T,M)=
Cliente(IDC,"barco",PT) if(M > F and M > T) .

***Actualiza MD y PT a una lista de clientes en base a una lista de

envios

op ActuaMD(_,_,_): LCliente LEnvio LCliente -> LCliente .

eq ActuaMD(Cliente(IDC,MD,(PT / 2)) LC,LE,TC)= ActuaMD(LC,LE,TC

(recalMD(Cliente(IDC,MD,(PT / 2)),bcEnvio(Cliente(IDC,MD,(PT /
2)),LE,nilLEnvio),0,0,0))) .

eq ActuaMD(nilLCliente,_,LC)= LC .

endfm

***punto T.8

Calcule el orden de complejidad del operador del punto anterior

suponiendo que lo defini siguiendo los alineamientos que se muestran a
continuacin.

Asuma que tiene m clientes, n envos y k paquetes en promedio en cada

envo.

Iter sobre la lista de clientes tomando cada uno para recalcular sus
atributos.

Dado un cliente iter sobre la lista de envos tomando cada uno para
establecer si el cliente tena paquetes en el envo.

Dado el cliente y el envo, iter sobre la lista de paquetes para hallar los
paquetes del cliente en el envo, acumulando puntos y contando los
paquetes en cada tipo de transporte.

Dado que en promedio cada envio tiene K paquetes registrados y que se

deben realizar operaciones de suma para acomular los puntos y contar los
paquetes enviados en cada tipo de trasnporte para cada paquete, est
operacion costar C*K, donde C es una constante. asumiendo que existen N
envios y que para cada da uno de los envios se debe realizar la operacion
anterior, entonces la operacin costar por el orden de P*N*K, donde P es
una constante que representa las operaciones de orden uno necesarias para
el operador; Esto se da en el peor de los casos, cuando el ultimo paquete por
revisar es eviado por el un cliente dado, y adems se repetir para los M
clientes, as P*M*N*K.