Ingeniería económica con C#

Como hemos visto en anteriores posts crear aplicaciones con C# es muy sencillo. En está ocasión crearemos un programa que calcule el valor futuro y rédito de una cantidad a una tasa y periodos definidos.

Necesitaremos:

• Crear una clase llamada Economica.cs
• Una clase principal (Program.cs)

¿Cómo obtenemos los cálculos de valor futuro y rédito?

valor_futuro = valor_presente * pow(1+tasa/100, periodo);
redito = (valor_futuro - valor_presente) / valor_presente;

La clase Economica.cs tendrá tres atributos:

• presente (valor presente)
• tasa (tasa de inversión)
• periodo (periodo de inversión)

Además tendrá dos métodos para calcular valor futuro y rédito
Economica.cs

using System;

namespace clases
{
 public class Economica
 {
  private double presente;
  private double tasa;
  private int periodo;

  public Economica()
  {
   Console.WriteLine("Objeto Economica creado e inicializado");
  }

  public Economica(double presente, double tasa, int periodo)
  {
   this.Presente = presente;
   this.Tasa = tasa;
   this.Periodo= periodo;
  }

  public double Presente
  { 
   get; set;
  }

  public double Tasa
  {
   get; set;
  }

  public int Periodo
  {
   get;set;
  }

  public double Futuro()
  {
   return this.Presente * Math.Pow(1+this.Tasa/100,this.Periodo);
  }

  public double Redito()
  {
   return (this.Futuro()-this.Presente)/this.Presente;
  }  

  public override string ToString(){
   return string.Format("Economica( presente = {0} , tasa = {1} , periodo = {2})", this.presente,this.tasa, this.periodo);
  }

 }
}

Dentro de esta clase principal se creará una lista de tipo Economica:

//Necesitamos para emplear List
using System.Collections.Generic;

//...

List<Economica> listaEconomica = new List<Economica>();
          

Agregaremos objetos tipo Economica:

listaEconomica.Add(new Economica(2400,5,12));
listaEconomica.Add(new Economica(2800,6,8));
listaEconomica.Add(new Economica(2100,5,10));
listaEconomica.Add(new Economica(1930,10,7));
listaEconomica.Add(new Economica(3400,2,12));

Para recorrer la lista (y mostrar los resultados) emplearemos el método ForEach:

listaEconomica.ForEach(eco => 
            {
                Console.WriteLine("Presente = {0}, Tasa = {1} , Periodo = {2}",eco.Presente, eco.Tasa, eco.Periodo);
                Console.WriteLine("Futuro = {0} , Tasa = {1}",eco.Futuro(),eco.Redito());
                Console.WriteLine("------------------------------------------");
            });

Program.cs

using System;
using System.Collections.Generic;
using clases;

namespace proyecto
{
    class Program
    {

     static void Main(string[] args)
     {
         List<Economica> listaEconomica = new List<Economica>();
            listaEconomica.Add(new Economica(2400,5,12));
            listaEconomica.Add(new Economica(2800,6,8));
            listaEconomica.Add(new Economica(2100,5,10));
            listaEconomica.Add(new Economica(1930,10,7));
            listaEconomica.Add(new Economica(3400,2,12));
            listaEconomica.ForEach(eco => 
            {
                Console.WriteLine("Presente = {0}, Tasa = {1} , Periodo = {2}",eco.Presente, eco.Tasa, eco.Periodo);
                Console.WriteLine("Futuro = {0} , Tasa = {1}",eco.Futuro(),eco.Redito());
                Console.WriteLine("------------------------------------------");
            });
     }

    }
}

Podemos ejecutarlo desde terminal:

dotnet run

Links: 
https://codemonkeyjunior.blogspot.com/2014/09/programando-en-c-no-3.html

Arreglos, listas, funciones y clases en Kotlin

En casi cualquier lenguaje de programación debemos trabajar con estructuras de datos como listas, arreglos, mapas, etc. Kotlin no se queda atrás y nos permite definir estas estructuras con algunas peculiaridades.
Si queremos definir un array (no olvidar que debemos poner de qué tipo) :

var arreglo: Array<Double> = arrayOf<Double>(10.7,20.55,31.90,49.99,53.33,66.666,70.70);

Si queremos definir una lista, por ejemplo de un tipo específico (un tipo Clase) podríamos definir primero la clase:

data class Circulo(val radio:Double)

¿Sólo eso? Sí, sólo eso. Kotlin nos ahorra mucho trabajo.

Ahora definamos una lista de tipo Circulo:

val listaCirculo: List<Circulo> =listOf(Circulo(34.55), Circulo(7.8),Circulo(12.00));

 ¿Cómo los recorremos?

//for en arreglo
     for(arr:Double in arreglo){
       println("Hola ${arr}");
     }
println();
     //for en lista Circulo
     for(circulo:Circulo in listaCirculo){
       println(circulo);
       println("Radio = ${circulo.radio}")
     }

¿Y qué pasa con las funciones?
Aquí unos ejemplos:

//Una función sin parámetros de entrada y salida
fun nombreFuncion(){
  println("Hola, desde Kotlin!!!");

}

nombreFuncion();

//Una función con parámetros de entrada:
fun getValor(numero:Int): Int{
  return numero*2;
}

var valor = getValor(2);
println("Valor: ${valor}");

//Una función de tipo Boolean
fun String.esMayorACinco():Boolean{
    return this.length > 5;
}
 println("CINCO".esMayorACinco());//false

Post anterior: http://codemonkeyjunior.blogspot.com/2019/01/conociendo-kotlin.html


Links:
https://hackernoon.com/top-5-kotlin-programming-courses-for-java-and-android-programmers-49e842b8af1a

Conociendo Java 8

Dicen que con los cambios vienen cosas mejores.  Esperemos que sea así. Java 8 nos trae nuevas características. Una de ellas son: las Lambdas. ¿Qué son las lambdas? ¿Para qué nos sirven?.  Las lambdas son un tipo de función. Es una función "anónima", es decir, que no está vinculada un nombre.

En lenguajes como Python tenemos algo como esto:

switch=[
    lambda n: 'Hola',
    lambda n: 'Que tengas un buen dia' if n == 1 else 'Tal vez no tengas un buen dia',
    lambda n: 'Hoy es un buen dia para empezar' if n == 2 else 'Tal vez otro dia puedas empezar',
]

opcion=raw_input('Introduce un numero ente 1 y 2:')
print switch[0](opcion)
print switch[1](opcion)

En Java 8 tenemos "las expresiones Lambda". Que se puede definir como un "nuevo estilo" o manera de programar usando Lambdas.

En el sitio oficial de Oracle tenemos esta explicación:
"They provide a clear and concise way to represent one method interface using an expression. Lambda expressions also improve the Collection libraries making it easier to iterate through, filter, and extract data from a Collection. In addition, new concurrency features improve performance in multicore environments."

Podemos escribir algo como esto:

Clase instancia = () -> hacerAlgo();

La función puede o no contener parámetros. Además no es necesario definir qué tipo de dato es (String, int, double, boolean, char).

Clase instancia = (String a) -> hacerAlgo(a);  

Ejercicio. Crearemos una interface "Servicio" que contenga un método llamado opera, elcual recibe dos parámetros a y b. Una clase principal con un método llamado "operacion"que recibirá tres parámetros,las variables a,b y una instancia de tipo Servicio. La operación a realizar es la suma.

import static java.lang.System.out;

public class Control{
    public static void main(String[] args) {
        Servicio s=(a,b) -> a-b;
         out.println("35 - 26 = " + new Control().operacion(35, 26, s));
    }

    private int operacion(int a,int b, Servicio servicio){
        return servicio.opera(a,b);
    }
}

interface Servicio{
    int opera(int a,int b);
}

El resultado será 35 - 26 = 9.


Links
http://viralpatel.net/blogs/lambda-expressions-java-tutorial/
http://stackoverflow.com/questions/16501/what-is-a-lambda-function

Programando en C# : Interfaces y clases abstractas

Para los programadores que vienen de Java puede parecerles raras algunas cosas del lenguaje C#. Recordemos que C# es un lenguaje "heredero" de Java ysigue la misma filosofía, pero con ciertas variantes y una evolución propia. C# nació como lenguaje competidor y ciertos aspectos permanecen igual.


Ejemplo. Calcular el área y el perímetro de tres figuras geométricas: Circulo, Rectángulo, y Triángulo.

Crearemos una clase abstracta (la cual no podrá ser instanciada) que nos servirá como Padre de las demás clases que la extienden.

• Clase abstracta:  Figura
• Clases hijas: Triangulo, Rectangulo, y Circulo

Además una interface, una clase también abstracta que nos permitirá definir métodos comunes entre las tres clases creadas.

//tenemos la clase abstracta (y Padre)
abstract class Figura{ ... }

//la interface
interface Funciones { ... }

//las clases hijas y que además implementan la interface Funciones
class Triangulo : Figura , Funciones{ ... }
class Circulo: Figura, Funciones{ ... }
class Rectangulo: Figura, Funciones{ ... }


Código completo:
using System;

public class Codemonkey{
    public static void Main(string[] args){
        Triangulo t;
        Rectangulo r;
        Circulo c;
        try{
            t=new Triangulo();
            c=new Circulo();
            r=new Rectangulo();

            t.setLados(new int[]{3,3,3});
            t.Bases=26;
            t.Altura=23;

            c.Radio=2.4;
            c.Diametro=4.9;

            r.Bases=6;
            r.Altura=4;

            Console.WriteLine("Triangulo\nPerimetro: {0}  , Area: {1}",t.getPerimetro(),t.getArea());
            Console.WriteLine("Circulo\nPerimetro: {0}  , Area: {1}",c.getPerimetro(),c.getArea());
            Console.WriteLine("Rectangulo\nPerimetro: {0}  , Area: {1}",r.getPerimetro(),r.getArea());

        }catch(Exception ex){
            Console.Error.WriteLine("Error {0}",ex.Message);
            Environment.Exit(0);
        }finally{
            t=null;r=null;c=null;
        }
    }
}

abstract class Figura{
    private int[] lados;
    private int altura;
    private int bases;

    public void setLados(int[] lados){
        this.lados=lados;
    }

    public int[] getLados(){
        return lados;
    }

    public int Bases{get;set;}
    public int Altura{get;set;}
}

interface Funciones{
    int getArea();
    int getPerimetro();
}

class Triangulo : Figura , Funciones{

    public  int getPerimetro(){
        return (int)this.getLados()[0] * 3;
    }

    public int getArea(){
        return (this.Bases*this.Altura) / 2;
    }

}

class Rectangulo : Figura, Funciones{

    public  int getPerimetro(){
        return 2*(this.Bases*this.Altura) + (2* this.Bases);
    }

    public  int getArea(){
        return this.Bases*this.Altura;
    }

}

class Circulo : Figura, Funciones{
    private double radio;
    private double diametro;


    public double Radio{get;set;}
    public double Diametro{get;set;}


    public  int getPerimetro(){
        return (int)(3.14159*this.Diametro);
    }

    public  int getArea(){
        return (int)(3.14159*(this.Radio*2));
    }
   
}

Compilar: gmcs Codemonkey.cs
Ejecutar: mono Codemonkey.exe

LiveScript: Creando una clase

Recordemos que Javascript es un lenguaje interpretado, permite la programación funcional y la orientada a objetos. Muchas veces, debido a su nombre,es confundido por Java.  Es un lenguaje de script para aplicaciones web.

El estándar Javascript
Algunos consideran que el estándar de Javascript ha fracasado y por esa razón ha proliferado una gama de nuevos lenguajes de programación como  TypeScript, CoffeeScript,LiveScript, etc. Puede ser verdad, estos nuevos lenguajes ofrecen escribir código más sencillo de leer y mantener que escribir líneas y líneas de código que muchas veces no todos entendemos.

En esta ocasión veremos un ejemplo de como crear una clase usando LiveScript y compararemos el código resultante en Javascript.

Tenemos el código LiveScript:

clase.ls
#creando clase en LiveScript
class Codemonkey
     numero= 0
     real= 0.0
     cadena= ''

#instanciando la clase
code = new Codemonkey
code.numero= 45
code.real= 9.009
code.cadena= 'Creando una clase'

Compilamos:
lsc -c clase.ls

Nos generará un código en Javascript:
Codemonkey.js
// Generated by LiveScript 1.3.1
(function(){
  var Codemonkey, code;
  Codemonkey = (function(){
    Codemonkey.displayName = 'Codemonkey';
    var numero, cadena, real, prototype = Codemonkey.prototype, constructor = Codemonkey;
    numero = 0;
    cadena = '';
    real = 0.0;
    function Codemonkey(){}
    return Codemonkey;
  }());
  code = new Codemonkey;
  code.numero(45);
  code.real(9.009);
  code.cadena('Creando una clase');
}).call(this);

Podemos observar que el código resultante es más complejo que el escrito en LiveScript. Aunque eso solo es una ventaja.

Julia en ejemplos no. 3: Creando "clases"

Retomando los ejemplos de código en Julia en esta ocasión conoceremos como crear estructuras Type. Semejantes  a las clases de lenguajes como C, Python y Java.

 ¿Cómo creo una "clase"?
Con la siguiente sintaxis:

type Nombre_Tipo
  ...
  ...
end

Ejemplo. Crear una "clase" en Julia introduciendo valores  y mostrarlas en pantalla.

Definiremos entonces:

• Una estructura Type con el nombre de "Objeto"
• Un método llamado "propiedades"
• Un método para mostrar las "propiedades"
• Una función externa que nos permita introducir datos

 #la "clase" Objeto
type Objeto
    propiedades::Function
 
#constructor
    function Objeto()
        this = new()
 #método para imprimir valores
        function ObtenerDatos(altura::Int64,ancho::Int64,grosor::Int64)
            println("Objeto{alto:",altura,"ancho:",ancho,"grosor:",grosor,"}")
        end

        this.propiedades = ObtenerDatos

        return this
    end
end

#función externa para introducir datos
function entrada(prompt::String="")
   print(prompt)
   chomp(readline())
end

#bloque principal del programa
begin
    objeto = Objeto()#instancia
    altura = int(entrada("Introduce altura:"))
    ancho = int(entrada("Introduce ancho:"))
    grosor = int(entrada("Introduce grosor:"))
    objeto.propiedades(altura,ancho,grosor)
end

Ejecución del código: julia Clase.jl

Links
http://chrisvoncsefalvay.com/2015/02/14/types-and-inheritance.html
https://thenewphalls.wordpress.com/2014/02/19/understanding-object-oriented-programming-in-julia-part-1/

Groovy ... en ejemplos no. 4

Herencia
Al definir clases esperamos que estas cumplan todos los  requisitos necesarios, ni más ni menos. Si creamos una clase llamada Imagen, esta debe tener atributos que la identifiquen: nombre, tamaño, y url.

class Imagen{
     String nombre
     String tamanyo
     String url
}

Ahora una clase llamada TestImage con método main.

class TestImage{
     static main(args){
      def imagen=new Imagen(nombre:"Groovy.jpg",tamanyo:"45kb",url:"http://misimagenes.com.mx")  
   }

  //también podría haber sido así
  def imagen=new Imagen()
   imagen.with{
nombre="Groovy.jpg" 
tamanyo="45kb" 
url="http://misimagenes.com.mx"
   }

}

Al parecer no existe problema alguno, esta clase cumple su objetivo. Ahora ¿qué pasaría si necesitaramos agregarle alguna 'funcionalidad' extra? para ello usaremos la herencia.

Vamos a crear:

• Una clase base (o padre) llamada Heroe
• Dos clases hijas llamadas Superman y Batman 
• Dos interfaces llamadas Superpoderes y Habilidades
• Una clase llamada TestHeroe

//clase base
class Heroe{}
//clase hija hereda de clase padre
class SuperHeroe extends Heroe{}
//hace uso de los métodos de la interface Superpoderes
class Superman extends SuperHeroe implements Superpoderes{
    @Override
    public void vuelo(){
        println "Superman vuela"
    }

    @Override
    public void velocidad(){
        println "Superman corre a gran velocidad"
    }

    @Override
    public void fuerza(){
        println "Superman posee gran fuerza"
    }
}

//hace uso de la interface Habilidades
class Batman extends SuperHeroe implements Habilidades{
    @Override
    public void karate(){
        println "Batman sabe karate"
    }
}

interface Superpoderes{
    public abstract void vuelo()
    public abstract void velocidad()
    public abstract void fuerza()
}

interface Habilidades{
    public abstract void karate()
}

class TestHeroe{
    static main(args) {
        Superman superman=new Superman()
        Batman batman=new Batman()

        superman.vuelo()
        superman.velocidad()
        superman.fuerza()

        batman.karate()
    }
}

Salida:
Superman vuela
Superman corre a gran velocidad
Superman posee gran fuerza
Batman sabe karate
 
Ejecutamos: groovy TestHeroe.groovy

Código:http://www.pasteall.org/53722/groovy

Scala ... ejemplos sencillos no. 5

Herencia y clase abstracta en Scala

Herencia: Es la propiedad que permite definir nuevas clases a partir de clases base ya existentes.

Las clases abstractas nos ayudan a representar objetos generales de un objeto,es decir, sus propiedades comunes. Como puede ser el nombre, el tamaño, el tipo, etc.

Las clases abstractas no pueden ser instanciadas. Solo las clases que extienden de ella.


En este ejemplo se define una clase base llamada Vehiculo y una clase hija llamada Moto. La clase Vehiculo tendra las siguientes características:

• marca
• tipo y
• color

A su vez la clase hija tendrá solo una característica: tamaño


[Sintaxis]
class ClaseHija extends ClaseBase{ ... }

Definimos la clase Vehiculo:
abstract class Vehiculo(val _marcax:String=null,val _tipox:String=null,val _colorx:String=null){

  private var _marca:String=_marcax
  private var _tipo:String=_tipox
  private var _color:String=_colorx
 
  //getter 
  def marca = _marca
  //setter 
  def marca_= (value:String):Unit = _marca = value
 
  def tipo=_tipo
  def tipo_=(value:String):Unit=_tipo=value
 
  def color=_color
  def color_=(value:String):Unit=_color=value
 
  def getInfo():String={"marca: "+_marca+" ,tipo: "+_tipo+" , color: "+_color}
 
}


Definimos la clase Moto:

class Moto(override val _marcax:String,override val _tipox:String,override val _colorx:String,val _tamanyox:String=null) extends Vehiculo(_marcax,_colorx,_tipox){

  private var _tamanyo:String=_tamanyox
 
  def tamanyo = _tamanyo
  def tamanyo_= (value:String):Unit = _tamanyo = value
 
  override def getInfo():String={super.getInfo+" ,tamaño: "+_tamanyo}
}

Como se puede ver esto es  similar a Java.  La clase base y la clase hija tendrán código en común. Por último creamos la instancia de la clase Moto:

object Codemonkey extends App{
  val moto=new Moto("Toyota","rojo","sencilla","pequeña")
  println(moto.getInfo)
}

Código: http://www.pasteall.org/47735/java

Programando en Perl no. 2

1. Uso de clases: En este ejemplo se va crear dos archivos: Alumno.pm (esta es la clase) y usoAlumno.pl. Se definen 7 atributos:

• nombre
• apellidos
• edad
• dirección
• ciudad
• teléfono y
• email

Se crea una función para mostrar los datos.

Alumno.pm

1. Creamos la clase Alumno:

package Alumno;
use strict; 

sub new{
 my $this=shift; 
     my $class = ref($this) || $this; 

     my $self={}; 
     $self ->{NOMBRE} =undef ; 
     $self ->{APELLIDOS} =undef ;
     $self ->{EDAD}   =0 ; 
     $self ->{DIRECCION}   =undef ; 
     $self ->{CIUDAD}   =undef ; 
     $self ->{TELEFONO}   =undef ; 
     $self ->{EMAIL}   =undef ;    

     bless $self, $class; 
     return ($self);
}

sub nombre{
       my $self=shift;
       $self->{NOMBRE}=shift if (@_);
       return $self->{NOMBRE};
  }

  sub apellidos{
       my $self=shift;
       $self->{APELLIDOS}=shift if (@_);
       return $self->{APELLIDOS};
  }

  sub edad{
       my $self=shift; 
       $self->{EDAD}=shift if (@_);
       return $self->{EDAD};
  }

  sub direccion{
       my $self=shift;
       $self->{DIRECCION}=shift if (@_);
       return $self->{DIRECCION};
  }

  sub telefono{
       my $self=shift; 
       $self->{TELEFONO}=shift if (@_);
       return $self->{TELEFONO};
  }

  sub email{
       my $self=shift; 
       $self->{EMAIL}=shift if (@_);
       return $self->{EMAIL};
  }

  sub ciudad{
       my $self=shift; 
       $self->{CIUDAD}=shift if (@_);
       return $self->{CIUDAD};
  }

  sub DESTROY {
        my $self=shift; 
        delete ($self->{NOMBRE});  
        delete ($self->{EDAD}); 
        delete ($self->{APELLIDOS});  
        delete ($self->{EMAIL});
        delete ($self->{DIRECCION});  
        delete ($self->{TELEFONO}); 
        delete ($self->{CIUDAD});
  }

1;

2. El archivo "usoAlumno.pl" que emplea la clase Alumno:

usoAlumno.pl

use Alumno;

$alumno=Alumno->new();
$alumno->nombre("horacio");
$alumno->apellidos("Sanchez");
$alumno->edad(31);
$alumno->direccion("aldama 34");
$alumno->ciudad("San Luis");
$alumno->email("alguien@gommail.com");
$alumno->telefono("722156444");

print "Hola: ".$alumno->nombre." ".$alumno->apellidos."  tienes: ".$alumno->edad."  de edad, vives en ".$alumno->direccion."  ".$alumno->ciudad." \n ";
print "tu email es: ".$alumno->email."  tu telefono es: ".$alumno->telefono."  \n";

Para ejecutar: perl usoAlumno.pl