alimentacion 0.1.0

data/lib/alimentacion.rb

@@ -0,0 +1,11 @@
+require "alimentacion/version"
+require "alimentacion/alimentos"
+require "alimentacion/lista"
+require "alimentacion/platos"
+require "alimentacion/plato_dsl"
+require "alimentacion/menu_dsl"
+
+module Alimentacion
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/lib/alimentacion/alimentos.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+# Esta clase contiene información sobre alimentos, tales como las proteínas, lípidos, hidratos,etc.
+# Se calcula el valor energético de cada alimento, así como su impacto ambiental en hombres y mujeres.
+#
+# Author::      David Hernández Suárez (mailto:david@alimentos)
+# Copyright::   Cretive Commons
+# License::     Distributes under the same terms as Ruby
+
+class Alimentos
+	attr_accessor :nombre,:proteinas,:hidratos,:lipidos,:gei,:terreno
+	include Comparable
+
+	# Se utiliza el módulo Comparable, comparando los alimentos en base a sus proteínas.
+        def <=>(anOther)
+		self. proteinas <=> anOther.proteinas
+        end
+
+	# Se asignan el nombre del alimento, sus proteínas, hidratos, lípidos, gases y uso del terreno.
+	def initialize(nombre,proteinas,hidratos,lipidos,gei,terreno)
+		@nombre,@proteinas,@hidratos,@lipidos,@gei,@terreno = nombre,proteinas,hidratos,lipidos,gei,terreno
+	end
+	
+	# Se obtiene el alimento formateado.
+	def to_s
+		"(#{@nombre},#{@proteinas},#{@hidratos},#{@lipidos},#{@gei},#{@terreno})"
+	end
+
+	# Se calcula el valor energético (calórico) del alimento.
+	def valor_energetico
+                energia = 4 * (@proteinas + @hidratos) + (@lipidos * 9)
+                energia.round(2)
+        end
+
+	# Función auxiliar para calcular los gases anuales.
+	def auxiliar(gramos)
+                x = ( @gei * gramos ) / 1000
+        end
+
+	# Función auxiliar para calcular el uso del terreno anual.
+        def auxiliar2(gramos)
+                x = ( @terreno * gramos ) / 1000
+        end
+
+	# Se calcula el impacto ambiental de un alimento en un hombre.
+        def impacto_hombre(gramos)
+                alimento1 = Alimentos.new("Carne vaca",21.1,0.0,3.1,50.0,164.0)
+                alimento2 = Alimentos.new("Salmon",19.9,0.0,13.6,6.0,3.7)
+                alimento3 = Alimentos.new("Huevos",13.0,1.1,11.0,4.2,5.7)
+                a = alimento1.auxiliar(gramos) + alimento2.auxiliar(gramos) + alimento3.auxiliar(gramos)
+                b = alimento1.auxiliar2(gramos) + alimento2.auxiliar2(gramos) + alimento3.auxiliar2(gramos)
+		vector = [a.round(2),b.round(2)]
+        end
+
+	# Se calcula el impacto ambiental de un alimento en una mujer.
+	def impacto_mujer(gramos1,gramos2,gramos3,gramos4,gramos5)
+                alimento1 = Alimentos.new("Tofu",10,2.37,6,2.0,2.2)
+                alimento2 = Alimentos.new("Nuez",50,10.5,27,0.3,7.9)
+                alimento3 = Alimentos.new("Camarones",10,0.85,0.34,18.0,2.0)
+                alimento4 = Alimentos.new("Chocolate",5,44.34,28.30,2.3,3.4)
+                alimento5 = Alimentos.new("Leche",6,8.72,5.82,3.2,8.9)
+                a = alimento1.auxiliar(gramos1) + alimento2.auxiliar(gramos2) + alimento3.auxiliar(gramos3) + alimento4.auxiliar(gramos4) + alimento5.auxiliar(gramos5)
+                b = alimento1.auxiliar2(gramos1) + alimento2.auxiliar2(gramos2) + alimento3.auxiliar2(gramos3) + alimento4.auxiliar2(gramos4) + alimento5.auxiliar2(gramos5)
+                vector = [a.round(2),b.round(2)]
+        end
+end

data/lib/alimentacion/lista.rb

@@ -0,0 +1,136 @@
+# encoding: utf-8
+# Esta clase implementa una lista doblemente enlazada.
+# Se desarrollan los métodos para insertar y extraer nodos por la cabeza y por la cola, e imprimir la lista completa.
+# Se utiliza una estructura para representar los nodos, con los valores value, next y prev.
+#
+# Author::      David Hernández Suárez (mailto:david@alimentos)
+# Copyright::   Cretive Commons
+# License::     Distributes under the same terms as Ruby
+
+Nodo = Struct.new(:value, :next, :prev)
+class Lista
+	include Enumerable
+
+	# Se utiliza el módulo Enumerable, para enumerar cualquier lista enlazada.
+        def each
+                aux = @head
+                while !aux.nil?
+                        yield aux[:value]
+                        aux = aux[:next]
+                end
+        end
+
+	attr_accessor :head,:tail
+
+	# Se asignan la cabecera de la lista y la cola de la lista. Inicialmente apuntan a nil.
+        def initialize(head,tail)
+                @head = nil
+                @tail = nil
+        end
+
+	# Se inserta un nodo por la cabeza de la lista
+	def insert_head(value)
+                if @head.nil?
+                        @head = Nodo.new(value, nil, nil)
+                        @tail = @head
+                else
+                        @head[:prev] = Nodo.new(value, @head, nil)
+                        @head = @head[:prev]
+                end
+        end
+
+	# Se inserta un nodo por la cola de la lista
+	def insert_tail(value)
+                if @head.nil?
+                        @head = Nodo.new(value, nil, nil)
+                        @tail = @head
+                else
+                        @tail[:next] = Nodo.new(value, nil, @tail)
+                        @tail = @tail[:next]
+                end
+        end
+
+	# Se extrae el nodo situado en la cabeza de la lista
+	def extract_head()
+                if @head.nil?
+                        raise RuntimeError, "La lista está vacía"
+                else
+                        if @head == @tail
+                                @head, @tail = nil
+                        else
+                                @head = @head[:next]
+                                @head[:prev] = nil
+                        end
+
+                end
+        end
+
+	# Se extrae el nodo situado en la cola de la lista
+	def extract_tail()
+                if @head.nil?
+                        raise RuntimeError, "La lista está vacía"
+                else
+                        if @head == @tail
+                                @head, @tail = nil
+                        else
+                                @tail = @tail[:prev]
+                                @tail[:next] = nil
+                        end
+                end
+        end
+
+	# Se insertan por la cola un conjunto de nodos
+	def insert(nodos)
+            for i in (0.. nodos.size-1)
+                insert_tail(nodos[i])
+            end
+        end
+
+	# Se visualiza la lista
+	def imprimir
+                aux = @head
+                lista = []
+                while (!aux.nil?)
+                        lista << aux[:value].to_s
+                        aux = aux[:next]
+                end
+        return lista
+
+        end
+
+	# Calcula el total de gases anuales que tiene la lista de alimentos
+	def dieta_gases_anuales(gramos)
+                aux = @head
+                suma_gases = 0
+                i = 0
+                while (!aux.nil?)
+                        suma_gases += aux[:value].auxiliar(gramos[i])
+                        aux = aux[:next]
+                        i = i+1
+                end
+                return suma_gases.round(2)
+
+        end
+
+	# Calcula el total de gases diarios que tiene la lista de alimentos
+	def dieta_gases_diarios(gramos)
+                gases_diarios = dieta_gases_anuales(gramos)/365
+                return gases_diarios.round(3)
+        end
+
+	# Calcula el total de uso del terreno que tiene la lista de alimentos
+	def dieta_terreno(gramos)
+
+                aux = @head
+                suma_terreno = 0
+                i = 0
+                while (!aux.nil?)
+                        suma_terreno += aux[:value].auxiliar2(gramos[i])
+                        aux = aux[:next]
+                        i = i+1
+                end
+                return suma_terreno.round(2)
+
+        end
+
+end

data/lib/alimentacion/menu_dsl.rb

@@ -0,0 +1,36 @@
+class Menu_DSL
+attr_reader :nombre_menu, :lista_platos, :precio_menu
+
+	def initialize (nombre_menu, &block)
+		#@nombre_menu = nombre_menu
+		@lista_platos = []
+		@precio_menu = 0
+
+		if block_given?
+                        if block.arity == 1
+                                yield self
+                        else
+                                instance_eval(&block)
+                        end
+                end
+	end
+
+	def descripcion(n)
+		@nombre_menu = n
+	end
+
+	def componente(descripcion, precio = {})
+		componente = "\n - " + descripcion
+		componente << " || Precio: #{precio[:Precio]} € " if precio[:Precio]
+		@precio_menu += precio[:Precio]
+		@lista_platos << componente
+	end
+
+	def to_s
+		output = @nombre_menu
+		output << "\n#{'=' * @nombre_menu.size}\n\n"
+                output << "Platos: \n #{@lista_platos.join(' ')}\n\n"
+		output << "Precio total: #{@precio_menu} €"
+	end
+
+end

data/lib/alimentacion/plato_dsl.rb

@@ -0,0 +1,45 @@
+class Plato_DSL
+
+	attr_reader :nombre_plato, :lista_alimentos
+        include Comparable
+        def <=>(anOther)
+                self.porcentaje_proteinas <=> anOther.porcentaje_proteinas
+        end
+
+        def initialize(nombre_plato, &block)
+                #@nombre_plato = nombre_plato
+                @lista_alimentos = []
+
+                if block_given?
+                        if block.arity == 1
+                                yield self
+                        else
+                                instance_eval(&block)
+                        end
+                end
+        end
+
+	def nombre (n)
+		@nombre_plato = n
+	end
+
+	def alimento(descripcion, gramos = {})
+		alimento = "\n - " + descripcion
+		alimento << "\n     Información nutricional:"
+		alimento << " || Cantidad: #{gramos[:Gramos]} gramos ||" if gramos[:Gramos]
+		alimento << " Proteínas: #{gramos[:Proteinas]} gramos ||" if gramos[:Proteinas]
+		alimento << " Hidratos: #{gramos[:Hidratos]} gramos ||" if gramos[:Hidratos]
+		alimento << " Lípidos: #{gramos[:Lipidos]} gramos" if gramos[:Lipidos]
+		alimento << "\n     Información ambiental:"
+		alimento << " Gases anuales: #{gramos[:Gases]} kilogramos ||" if gramos[:Gases]
+		alimento << " Uso del terreno: #{gramos[:Terreno]} metros cuadrados" if gramos[:Gases]
+		@lista_alimentos << alimento
+	end
+
+	def to_s
+		output = @nombre_plato
+		output << "\n#{'=' * @nombre_plato.size}\n\n"
+		output << "Alimentos: \n #{@lista_alimentos.join(' ')}\n\n"
+	end
+
+end

data/lib/alimentacion/platos.rb

@@ -0,0 +1,199 @@
+# encoding: utf-8
+# Esta clase contiene información acerca de los distintos alimentos que forman un plato.
+# Se calcula el porcentaje de proteínas, hidratos y lípidos que contiene cada conjunto de alimentos, así como su valor energético.
+#
+# Author::      David Hernández Suárez (mailto:alu0101048239@ull.edu.es)
+# Copyright::   Cretive Commons
+# License::     Distributes under the same terms as Ruby
+
+class Plato 
+	attr_reader :nombre_plato, :lista_alimentos, :lista_gramos
+	include Comparable
+
+	# Se utiliza el módulo Comparable, comparando los alimentos en base a su porcentaje de proteínas.
+        def <=>(anOther)
+                self.porcentaje_proteinas <=> anOther.porcentaje_proteinas
+        end
+
+	# Se asignan el nombre del plato, la lista de alimentos que lo compone y los gramos de cada alimento.
+        def initialize(nombre_plato, lista_alimentos, lista_gramos)
+                @nombre_plato = nombre_plato
+                @lista_alimentos = lista_alimentos
+                @lista_gramos = lista_gramos
+        end
+
+	# Se calcula el porcentaje de proteínas total del plato
+	def porcentaje_proteinas
+                aux = @lista_alimentos.head
+                aux2 = @lista_gramos.head
+                suma_proteinas = 0
+                suma_gramos = 0
+                while (!aux.nil?)
+                        suma_proteinas += ( (aux[:value].proteinas)*(aux2[:value]) )/100
+                        suma_gramos += aux2[:value]
+                        aux = aux[:next]
+                        aux2 = aux2[:next]
+                end
+
+                return ( (suma_proteinas/suma_gramos)*100 ).round(2)
+
+        end
+
+	# Se calcula el porcentaje de hidratos de carbono total del plato
+	 def porcentaje_hidratos
+                aux = @lista_alimentos.head
+                aux2 = @lista_gramos.head
+                suma_hidratos = 0
+                suma_gramos = 0
+                while (!aux.nil?)
+                        suma_hidratos += ( (aux[:value].hidratos)*(aux2[:value]) )/100
+                        suma_gramos += aux2[:value]
+                        aux = aux[:next]
+                        aux2 = aux2[:next]
+                end
+
+                return ( (suma_hidratos/suma_gramos)*100 ).round(2)
+
+        end
+
+	# Se calcula el porcentaje de lípidos total del plato
+	def porcentaje_lipidos
+                aux = @lista_alimentos.head
+                aux2 = @lista_gramos.head
+                suma_lipidos = 0
+                suma_gramos = 0
+                while (!aux.nil?)
+                        suma_lipidos += ( (aux[:value].lipidos)*(aux2[:value]) )/100
+                        suma_gramos += aux2[:value]
+                        aux = aux[:next]
+                        aux2 = aux2[:next]
+                end
+
+                return ( (suma_lipidos/suma_gramos)*100 ).round(2)
+
+        end
+
+	# Se calcula el valor calórico total del plato
+	def valor_calorico
+                aux = @lista_alimentos.head
+                aux2 = @lista_gramos.head
+                calorias = 0
+                while (!aux.nil?)
+                        aux[:value].proteinas = ( (aux[:value].proteinas) * (aux2[:value]) )/100
+                        aux[:value].hidratos = ( (aux[:value].hidratos) * (aux2[:value]) )/100
+                        aux[:value].lipidos = ( (aux[:value].lipidos) * (aux2[:value]) )/100
+                        calorias += aux[:value].valor_energetico
+                        aux = aux[:next]
+                        aux2 = aux2[:next]
+                end
+
+                return calorias.round(2)
+        end
+	
+	# Se obtiene el plato formateado
+	def to_s
+                aux = @lista_alimentos.head
+                aux2 = @lista_gramos.head
+                vector = []
+                vector << @nombre_plato
+                while (!aux.nil?)
+                        vector << aux[:value].to_s
+                        vector << aux2[:value]
+                        aux = aux[:next]
+                        aux2 = aux2[:next]
+                end
+
+                return vector
+
+        end
+
+end
+
+# encoding: utf-8
+# Esta clase, que hereda de la clase Plato, calculará las emisiones diarias y anuales de los gases de efecto invernadero, y el uso del terreno# en referencia a los alimentos que componen cada plato.
+#
+# Author::      David Hernández Suárez (mailto:alu0101048239@ull.edu.es)
+# Copyright::   Cretive Commons
+# License::     Distributes under the same terms as Ruby
+
+
+class Eficiencia_Energetica < Plato
+
+	attr_reader :nombre_plato, :lista_alimentos, :lista_gramos
+        include Comparable
+        
+	# Se utiliza el módulo Comparable, comparando los alimentos en base a su huella nutricional.
+	def <=>(anOther)
+               #self.uso_terreno <=> anOther.uso_terreno
+		self.huella_nutricional <=> anOther.huella_nutricional
+        end
+
+	# Se asignan el nombre del plato, la lista de alimentos que lo contienen y la lista de gramos de cada alimento.
+        def initialize(nombre_plato, lista_alimentos, lista_gramos)
+                super(nombre_plato, lista_alimentos, lista_gramos)
+        end
+
+	# Se calculan las emisiones anuales de gases de efecto invernadero que produce el plato
+        def emisiones_gases_anuales
+                aux = @lista_alimentos.head
+                aux2 = @lista_gramos.head
+                suma_gases_anuales = 0
+                while (!aux.nil?)
+                        suma_gases_anuales += aux[:value].auxiliar(aux2[:value])
+                        aux = aux[:next]
+                        aux2 = aux2[:next]
+                end
+
+                return suma_gases_anuales.round(2)
+        end
+
+	# Se calculan las emisiones diarias de gases de efecto invernadero que produce el plato
+	def emisiones_gases_diarios
+                suma = (emisiones_gases_anuales / 365)
+                return suma.round(3)
+        end
+
+	# Se calcula el uso del terreno anual que produce el plato
+	def uso_terreno
+                aux = @lista_alimentos.head
+                aux2 = @lista_gramos.head
+                suma_terreno = 0
+                while (!aux.nil?)
+                        suma_terreno += aux[:value].auxiliar2(aux2[:value])
+                        aux = aux[:next]
+                        aux2 = aux2[:next]
+                end
+
+                return suma_terreno.round(2)
+        end
+
+	# Se obtiene la información de gases y terreno formateada
+	def to_s
+                "( #{self.emisiones_gases_anuales}, #{self.emisiones_gases_diarios}, #{self.uso_terreno} )"
+
+        end
+
+	# Se calcula la huella nutricional del plato
+	def huella_nutricional
+                if (valor_calorico < 670)
+                        aux = 1
+                elsif (valor_calorico < 830)
+                        aux = 2
+                else
+                        aux = 3
+                end
+
+                if (emisiones_gases_anuales < 0.8)
+                        aux2 = 1
+                elsif (emisiones_gases_anuales < 1.2)
+                        aux2 = 2
+                else
+                        aux2 = 3
+                end
+
+                return ((aux+aux2)/2.0).round(2)
+        end
+
+
+
+end