Reestructuración.
authorLeandro Lucarella <llucax@gmail.com>
Wed, 11 May 2005 23:52:46 +0000 (23:52 +0000)
committerLeandro Lucarella <llucax@gmail.com>
Wed, 11 May 2005 23:52:46 +0000 (23:52 +0000)
1.1.a.oz [new file with mode: 0644]
1.1.b.oz [new file with mode: 0644]
1.10.oz [new file with mode: 0644]
1.5.oz [new file with mode: 0644]
1.6.oz [new file with mode: 0644]
1.7.oz [new file with mode: 0644]
1.8.oz [new file with mode: 0644]
1.9.oz [new file with mode: 0644]

diff --git a/1.1.a.oz b/1.1.a.oz
new file mode 100644 (file)
index 0000000..afcd53b
--- /dev/null
+++ b/1.1.a.oz
@@ -0,0 +1,33 @@
+/****************************************************************************
+Ejercicio: 1.1.a
+Alumno: Leandro Lucarella
+Fecha: dom mar 26 21:17:41 ART 2005
+****************************************************************************/
+
+functor
+import
+    Application
+    System
+define
+    % Numerador
+    fun {Num N X}
+        if X == 0.0 then N else {Num N X-1.0} end
+    end
+    % Denominador (factorial)
+    fun {Fact X}
+        if X == 0.0 then 1.0 else X * {Fact X-1.0} end
+    end
+    % Combinatoria
+    fun {Comb N K}
+        if K == 0.0 then
+            1.0
+        else
+            {Num N K+1.0} / {Fact K}
+        end
+    end
+    % Imprimimos algo de ejemplo
+    {System.show {Comb 5.0 2.0}}
+    {Application.exit 0}
+end
+
+% vim: set et sw=4 sts=4 filetype=oz :
diff --git a/1.1.b.oz b/1.1.b.oz
new file mode 100644 (file)
index 0000000..a4f8135
--- /dev/null
+++ b/1.1.b.oz
@@ -0,0 +1,37 @@
+/****************************************************************************
+Ejercicio: 1.1.b
+Alumno: Leandro Lucarella
+Fecha: dom mar 26 22:17:35 ART 2005
+****************************************************************************/
+
+functor
+import
+    Application
+    System
+define
+    % Numerador
+    fun {Num N X}
+        if X == 0.0 then N else {Num N X-1.0} end
+    end
+    % Denominador (factorial)
+    fun {Fact X}
+        if X == 0.0 then 1.0 else X * {Fact X-1.0} end
+    end
+    % Combinatoria
+    fun {Comb2 N K}
+        if K == 0.0 then
+            1.0
+        else
+            {Num N K+1.0} / {Fact K}
+        end
+    end
+    % Combinatoria optimizada
+    fun {Comb N K}
+        if K > N / 2.0 then {Comb2 N N-K} else {Comb2 N K} end
+    end
+    % Imprimimos algo de ejemplo
+    {System.show {Comb 5.0 2.0}}
+    {Application.exit 0}
+end
+
+% vim: set et sw=4 sts=4 filetype=oz :
diff --git a/1.10.oz b/1.10.oz
new file mode 100644 (file)
index 0000000..6e774d2
--- /dev/null
+++ b/1.10.oz
@@ -0,0 +1,35 @@
+/****************************************************************************
+Ejercicio: 1.10
+Alumno: Leandro Lucarella
+Fecha: dom abr 10 14:56:42 ART 2005
+****************************************************************************/
+
+functor
+import
+    Application
+    System
+define
+    C = {NewCell 0}
+    thread I in
+        I = @C
+        % Sin agregar el Delay, nunca obtengo como resultado 1, esto se debe a
+        % que son muy pocas instrucciones y la probabilidad de que el timeslice
+        % que le asigan el Sistema Operativo a cada thread se corte justo en
+        % entre estas 2 instrucciones es muy muy pequeño. Poner un Delay dentro
+        % de un lock, sólo haría que el procesador 'duerma' dentro de un sólo
+        % thread, ya que el otro no se ejecutaría tampoco porque está esperando
+        % que el lock se libere.
+        {Delay 1}
+        C := I+1
+    end
+    thread I in
+        I = @C
+        %{Delay 1}
+        C := I+1
+    end
+    {Delay 50}
+    {System.show @C}
+    {Application.exit 0}
+end
+
+% vim: set et sw=4 sts=4 filetype=oz :
diff --git a/1.5.oz b/1.5.oz
new file mode 100644 (file)
index 0000000..448bbe5
--- /dev/null
+++ b/1.5.oz
@@ -0,0 +1,26 @@
+/****************************************************************************
+Ejercicio: 1.5
+Alumno: Leandro Lucarella
+Fecha: dom mar 27 02:14:55 ART 2005
+****************************************************************************/
+
+functor
+import
+    Application
+    System
+define
+    % Calcula lista lista infinita de números
+    fun lazy {Ints N}
+        N|{Ints N+1}
+    end
+    % Suma una lista de números
+    fun {SumList L}
+        case L of X|L1 then X+{SumList L1}
+        else 0 end
+    end
+    % NO es una buena idea sumar una lista infinita de números...
+    %{System.show {SumList {Ints 0}}}
+    {Application.exit 0}
+end
+
+% vim: set et sw=4 sts=4 filetype=oz :
diff --git a/1.6.oz b/1.6.oz
new file mode 100644 (file)
index 0000000..2af0886
--- /dev/null
+++ b/1.6.oz
@@ -0,0 +1,54 @@
+/****************************************************************************
+Ejercicio: 1.6
+Alumno: Leandro Lucarella
+Fecha: dom mar 27 02:20:08 ART 2005
+****************************************************************************/
+
+functor
+import
+    Application
+    System
+define
+    % Concatena un 0 al final de la lista
+    fun {ShiftLeft L}
+        case L of H|T then
+            H|{ShiftLeft T}
+        else [0] end
+    end
+    % Inserta un 0 al inicio de la lista
+    fun {ShiftRight L} 0|L end
+    % Aplica una operación entre 2 elementos de dos listas
+    fun {OpList Op L1 L2}
+        case L1 of H1|T1 then
+            case L2 of H2|T2 then
+                {Op H1 H2}|{OpList Op T1 T2}
+            end
+        else nil end
+    end
+    % Calcula variaciones del Triánculo de Pascal
+    fun {GenericPascal Op N}
+        if N == 1 then [1]
+        else L in
+            L = {GenericPascal Op N-1}
+            {OpList Op {ShiftLeft L} {ShiftRight L}}
+        end
+    end
+    % Suma
+    fun {Sum X Y} X+Y end
+    % Resta
+    fun {Sub X Y} X-Y end
+    % Multiplica
+    fun {Mul X Y} X*Y end
+    % Multiplica sumando 1
+    fun {Mul1 X Y} (X+1)*(Y+1) end
+    % Aplicamos con distintas operaciones
+    {System.show {GenericPascal Sum 5}} % Da los resultados esperados
+    {System.show {GenericPascal Sub 5}} % Da los resultados esperados
+    % Da cero porque multiplica por los 0 de las puntas
+    {System.show {GenericPascal Mul 5}}
+    % Da un resultado un poco extraño (aunque coerente con Mul1)
+    {System.show {GenericPascal Mul1 5}}
+    {Application.exit 0}
+end
+
+% vim: set et sw=4 sts=4 filetype=oz :
diff --git a/1.7.oz b/1.7.oz
new file mode 100644 (file)
index 0000000..7bdb143
--- /dev/null
+++ b/1.7.oz
@@ -0,0 +1,31 @@
+/****************************************************************************
+Ejercicio: 1.7
+Alumno: Leandro Lucarella
+Fecha: dom mar 27 02:43:53 ART 2005
+****************************************************************************/
+
+functor
+import
+    Application
+    System
+define
+    local X in
+        X = 23
+        local X in
+            X = 44
+        end
+        % Muestra 23 (valor original) porque el contexto del X anterior fue
+        % destruído y ahora X se vuelve a asociar con el valor 23.
+        {System.show X}
+    end
+    local X in
+        X = {NewCell 23}
+        X := 44
+        % Muestra 44 (valor cambiado) porque X siempre apunta a una celda de
+        % memoria y al modificarse, los cambios persisten.
+        {System.show @X}
+    end
+    {Application.exit 0}
+end
+
+% vim: set et sw=4 sts=4 filetype=oz :
diff --git a/1.8.oz b/1.8.oz
new file mode 100644 (file)
index 0000000..1adf091
--- /dev/null
+++ b/1.8.oz
@@ -0,0 +1,31 @@
+/****************************************************************************
+Ejercicio: 1.8
+Alumno: Leandro Lucarella
+Fecha: jue mar 31 11:25:34 ART 2005
+****************************************************************************/
+
+functor
+import
+    Application
+    System
+define
+    local C in
+        C={NewCell 0}
+        % Lo que estaba mal es la creación de la 'celda' dentro de la función
+        % porque se crea cada vez que se llama a la función, perdiendo el valor
+        % previo.
+        fun {Ac N}
+            C := @C+N
+            @C
+        end
+        local X Y Z in
+            X = {Ac 5}
+            Y = {Ac 15}
+            Z = {Ac 10}
+            {System.show Z}
+        end
+    end
+    {Application.exit 0}
+end
+
+% vim: set et sw=4 sts=4 filetype=oz :
diff --git a/1.9.oz b/1.9.oz
new file mode 100644 (file)
index 0000000..9d80eeb
--- /dev/null
+++ b/1.9.oz
@@ -0,0 +1,79 @@
+/****************************************************************************
+Ejercicio: 1.9b
+Alumno: Leandro Lucarella
+Fecha: lun abr  4 01:16:56 ART 2005
+****************************************************************************/
+
+functor
+import
+    Application
+    System
+define
+% Obtenido de internet porque no me funcionaba el {NewStore}
+% (http://www.info.ucl.ac.be/people/PVR/ds/booksuppl.oz)
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% The memory store as used in the exercises
+fun {NewStore}
+   D={NewDictionary}
+   C={NewCell 0}
+   proc {Put K X}
+      if {Not {Dictionary.member D K}} then
+         C:=@C+1
+      end
+      D.K:=X
+   end
+   fun {Get K} D.K end
+   fun {Size} @C end
+in
+   storeobject(put:Put get:Get size:Size)
+end
+proc {Put S K X} {S.put K X} end
+fun {Get S K} {S.get K} end
+fun {Size S} {S.size} end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+    % Concatena un 0 al final de la lista
+    fun {ShiftLeft L}
+        case L of H|T then
+            H|{ShiftLeft T}
+        else [0] end
+    end
+    % Inserta un 0 al inicio de la lista
+    fun {ShiftRight L} 0|L end
+    % Aplica una operación entre 2 elementos de dos listas
+    fun {OpList Op L1 L2}
+        case L1 of H1|T1 then
+            case L2 of H2|T2 then
+                {Op H1 H2}|{OpList Op T1 T2}
+            end
+        else nil end
+    end
+    % Calcula variaciones del Triánculo de Pascal
+    fun {GenericPascal Op N}
+        if N == 1 then [1]
+        else L in
+            L = {GenericPascal Op N-1}
+            {OpList Op {ShiftLeft L} {ShiftRight L}}
+        end
+    end
+    % Suma
+    fun {Sum X Y} X+Y end
+    % Celda para almacenar cantidad de veces que se llama al FastPascal
+    S = {NewStore}
+    % Funcion con "memoria"
+    fun {FasterPascal N}
+        if N > {Size S} then
+            if N > 1 then % Si tenemos que calcular anteriores
+                % Tengo que hacer un local porque si no lo asigno como una
+                % variable al resultado de la función, lo toma como el retorno
+                % de la actual y da error de aridad.
+                local DUMMY in DUMMY = {FasterPascal N-1} end
+            end
+            {Put S N {GenericPascal Sum N}}
+        end
+        {Get S N}
+    end
+    {System.show {FasterPascal 10}}
+    {Application.exit 0}
+end
+
+% vim: set et sw=4 sts=4 filetype=oz :