Open Dylan

Dylan es un lenguaje funcional de objetos creado originalmente por Apple para Newton.

Dylan es un descendiente directo de Scheme y CLOS (sin la sintaxis Lisp) con un modelo de programación diseñado para admitir la generación eficiente de código de máquina, incluido un control detallado sobre comportamientos dinámicos y estáticos.

Empecemos con el clásico Hola, mundo.

format-out("Hola %s\n", "mundo en Dylan!!")

Para instalarlo eberás descargarlo del siguiente link:

https://github.com/dylan-lang/opendylan/releases/tag/v2023.1.0

(Open) Dylan tiene un REPL similar a lenguajes como Haskell, Clojure, etc.

?45 + 32;
=> 77
?45 - 32;
=> 13
?33 / 33;
=> 1

Si no deseas instalarlo, puede probarlo en el siguiente link:

https://play.opendylan.org/

El sitio provee algunos ejemplos, como el uso de ciclos for, clases, cálculo del Fibonacci, entre otros más.

for loop

for (i from 1,
     c in "abcdef",
     until: c = 'e')
  format-out("%d: %s\n", i, c);
end;

Cálculo del Fibonacci:

define method fib ()
  let a = 0;
  let b = 1;
  method ()
    let r = a + b;
    a := b;
    b := r;
    a
  end
end;

let f = fib();
for (i from 1 to 20) format-out("%= ", f()) end

Clases

// Classes are the primary way to build data structures in Dylan.
// Slots are accessed via normal function calls.

define class <account> (<object>)
  constant slot account-id :: <integer>,
    required-init-keyword: id:;
  constant slot account-name :: <string>,
    required-init-keyword: name:;
  slot account-balance :: <integer> = 0;
end;

let a = make(<account>, id: 1, name: "Zippy");
account-balance(a) := 500;
format-out("%s (#%d) balance = %d",
           account-name(a), account-id(a), account-balance(a));

Macros

define macro inc!
    { inc!(?var:name) } => { inc!(?var, 1) }
    { inc!(?var:name, ?val:expression) } => { ?var := ?var + ?val }
end;

let x = 0;
inc!(x);
inc!(x, 10);
format-out("x = %d\n", x);

Más sobre este lenguaje en próximas entregas.

Enlaces:

https://opendylan.org/
https://play.opendylan.org/

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