Tuesday, November 28, 2017

Java Swing Ejercicio (Renta Fija 2)

Java Swing Ejercicio (Renta Fija 2)

Capitalización Continua

En el ejercicio Java Swing (Renta Fija 1) se identificaron varias expresiones para encontrar el valor futuro de una cantidad monetaria. La capitalización continua surge como concepto, cuando se piensa en lo siguiente: ¿Qué valor futuro se obtiene si la capitalización de los intereses es cada segundo - continua -.?

Para dar respuesta a ésta pregunta, la expresión del Valor Futuro Capitalización No Anual

$$ \begin{gather} FV &= PV * (1 + \frac{i}{m})^{n*m} \text{ ........(1)}\\ \end{gather}$$

donde

FV = Valor futuro.
PV = Valor presente.
i = Interés Anual.
n = Número de periodos.
m = Número de pagos en el año.

Reemplazando $$m = \infty$$

surge el concepto de límite. Reescribiendo (1) utilizando el concepto de limite se tiene:

$$ \begin{gather} FV &= \lim_{m \to \infty} PV * (1 + \frac{i}{m})^{n*m} \text{ ........(2)}\\ \end{gather}$$ La solución del limite se expone a continuación: $$ \begin{align} FV &= \lim_{m \to \infty} PV * (1 + \frac{i}{m})^{n*m} \\ Ln [FV] &= Ln [PV] + n * \lim_{m \to \infty} m * LN[(1 + \frac{i}{m})] \\ Ln [FV] &= Ln [PV] + n * \lim_{m \to \infty} \frac{LN[(1 + \frac{i}{m})]}{\frac{1}{m}}\\ \text{(Aplico L´Hopital en el límite)} \\ Ln [FV] &= Ln [PV] + n * \lim_{m \to \infty} \frac{\frac{\frac{-i}{m}}{(1 + \frac{i}{m})}}{\frac{-1}{m}} \\ Ln [FV] &= Ln [PV] + n * i * \lim_{m \to \infty} \frac{1}{(1 + \frac{1}{m})} \\ Ln [FV] &= Ln [PV] + n * i \\ e^{Ln [FV]} &= e^{Ln [PV] + n * i} \\ e^{Ln [FV]} &= e^{Ln [PV]} * e^{n * i} \\ FV &= PV * e^{n * i} \text{ ........(3)} \\ \end{align}$$

Las expresiones (1) y (3) están relacionadas para un valor de m grande.

Ejercicio en Java

Sea \( \theta = \) Error de aproximación tal que

$$ \theta = PV * e^{n * i} - PV * (1 + \frac{i}{m})^{n*m}$$ Para que valor de m se obtiene un error de aproximación igual 0.00001;

Solución

Para una correcta compilación es necesario anexar los códigos en un paquete de nombre: deltaerror.

Delta Class

/* Delta: Measure aproximation error as the difference between 
;continuous compounding; and discrete compounding.
 */

package deltaerror;
import java.util.*;

public class Delta {
    private double m, n, interes;
    private List mValues = new ArrayList<>();
    private List deltaValues = new ArrayList<>();
    
    public Delta(double m, double n, double interes){
        this.m = m;
        this.n = n;
        this.interes = interes;
    }
    public void getMDelta(double errorDeAproximacion){
        double error = 10;
        while(error > errorDeAproximacion){
            // Add values to ListArrays nvalues
            mValues.add(m);
            this.m++;
            
            error = Math.exp(this.n * this.interes)-Math.pow((1+(this.interes/this.m)),this.n*this.m);
            // Add values to ListArrays deltaValues
            deltaValues.add(error);
        }
    }
    
    public List getMValues(){return mValues;} // X value
    public List getDeltaValues(){return deltaValues;} // Y value
}


DeltaPlot Class (main)

package deltaerror;

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.chart.LineChart;
import javafx.scene.chart.NumberAxis;
import javafx.scene.chart.XYChart;
import javafx.scene.control.*;
import javafx.scene.layout.HBox;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

/** Steps to implement the Form with Swing Fx
 * 1) Define variables and Controls
 * 2) Initialize Variables and Controls
 * 3) Create a LayOut (HBox) that holds: eltaLabel, deltaText and Plot Button
 * 4) Create a Layout (VBox) that holds: HBox, and XYChart
 * 5) Set the Scene
 * 6) Set the Stage
 * 7) Implements Class Delta that calculate approximation error (Delta.java)
 * 8) Add action to Plot Button.
*/



public class DeltaPlot extends Application {
    
    // Step 1:Start
    // ********* Variables & Controls ************
    private final NumberAxis xAxis, yAxis;  // XY axis
    private final TextField deltaText;
    private final Label deltaLabel;
    private final Button plotButton;
    private final LineChart lineChart;
    private final XYChart.Series series;
    
    private double deltaValue;
    // Step 1: End
    
    {
        // Step 2: Start
        
        //Initialize Axis
        xAxis = new NumberAxis();
        yAxis = new NumberAxis();
        xAxis.setLabel("m Values");
        
        //Initialize XY_Chart
        lineChart = new LineChart<>(xAxis,yAxis);
        lineChart.setTitle("Aproximation Error");
        
        //XY_Chart serie
         series = new XYChart.Series();
        
        //Initialize controls
        deltaLabel = new Label("Delta: ");
        plotButton = new Button("Plot");
        deltaText = new TextField("0.0001");
        deltaText.setMaxWidth(90);
        deltaText.setMinWidth(90);
        
        // Step 2: End
        
    }
    
    @Override public void start(Stage stage) {
        // Step 3: Start
        // Set Layout to hold: deltaLabel, deltaText and plotButton
        HBox hbox = new HBox(5);
        hbox.getChildren().addAll(deltaLabel, deltaText,plotButton);
        // Step 3: End
        
        // Step 4: Start
        // Set Layout to hold: hbox and lineChart
        VBox pane = new VBox();
        pane.getChildren().addAll(hbox,lineChart);
        // Step 4: End
               
        // Step 5: Start
        // Set the Scene
        Scene scene  = new Scene(pane,800,450);
        // Step 5: End
       
        // Step 6: Start
        // Set the Stage
        stage.setScene(scene);
        stage.show();
        // Step 6: End
        
        // Step 8: Start
        // PlotButton
        plotButton.setOnAction(e->{
            lineChart.getData().clear();
            deltaValue = Double.parseDouble(deltaText.getText());
            
            lineChart.getData().add(getSeries(series,"Continuous Compoundint Vs Discret Compounding ($1 / 1 Year)", deltaValue));
        });
        //Step 8: End
            
    }
    /**
     * @param args the command line arguments
     */

    public static void main(String[] args) {
        launch(args);
    }
    
    // Helper function that retrieves the aproximation error (delta error)
    private XYChart.Series getSeries(XYChart.Series x, String title, double error){
        // Set the XYChart
        XYChart.Series mySerie = new XYChart.Series<>();
        mySerie.setName(title);
        
        // Set the object to retrieve the data
        Delta myDelta = new Delta(1,1,0.05);
        myDelta.getMDelta(error);
        
        // Set the data series and add them
        for(int i = 0; i < myDelta.getMValues().size(); i++){
            mySerie.getData().add(new XYChart.Data(myDelta.getMValues().get(i),myDelta.getDeltaValues().get(i)));
        }
        // Return serie
        return mySerie;
    }
    
}
Read more »

Monday, November 13, 2017

Java Swing Ejercicio (Renta Fija 1)

Java Swing Ejercicio (Renta Fija 1)

Valor Futuro

En Renta Fija (Finanzas) se pueden distinguir 4 casos relacionados con el valor futuro de una inversión:

  1. Valor Futuro Capitalización Anual
  2. Se tiene una inversión de nominal $1.000 que paga el 5% anual durante 3 años e interesa saber cuanto se obtiene al final del tercer año. Los flujos del siguiente producto financiero son:

    Periodo Calculo Flujo
    0 1.000
    1 (1.000 * 1.05) 1.050
    2 (1050 * 1.05) 1102.5
    3 (1102.5 * 1.05) 1157.625

    Tomando el flujo final y deshaciendo operaciones, se observa:

    $$\begin{eqnarray} 1102.5 * 1.05 &=& 1157.625 \\ (1050 * 1.05) * 1.05 &=& 1157.625 \\ ((1000 * 1.05) * 1.05) * 1.05 &=& 1157.625 \\ 1000 * (1.05)^{3} &=& 1157.625\\ \end{eqnarray}$$

    por lo tanto, se infiere que la expresión general para calcular el valor futuro capitalización anual es:

    $$ \begin{eqnarray} FV = PV * (1 + I)^{N} \end{eqnarray}$$

    donde

    PV = Valor presente.
    I = Interés Anual.
    N = Número de periodos.

    La anterior expresión también puede emplearse para periodos de tiempo fraccionado como: 1.5 años, 0.8 años, etc; siempre y cuando el interés sea de capitalización anual.

  3. Valor Futuro Capitalización No Anual
  4. En esté apartado, se consideran inversiones que pagan intereses más de una vez por año. La formula anterior sigue aplicando con las siguientes modificaciones

    $$ \begin{eqnarray} FV = PV * (1 + i)^{n} \end{eqnarray}$$

    donde

    PV = Valor presente.
    i = Interés Anual dividido por m (número de pagos en el año).
    n = Número de periodos (N) * m (número de pagos en el año).

    Ejemplo: Un gestor de patrimonio identifica una activo de valor 2.000.0000 que paga un interés del 5% anual durante 3 años. Los intereses se pagan cada semestre. ¿ Cúal es el valor de la inversión al final del periodo ?
    La solución de este ejercicio es:

    $$\begin{eqnarray} i &=& \frac{0.05}{2} \\ n &=& 2 * 2 \end{eqnarray}$$

    con estos valores se obtiene

    $$\begin{eqnarray} FV &=& 2.000.000 * (1.025)^{4} \\ &=& 2.207.626 \\ \end{eqnarray}$$
  5. Valor Futuro de una Anualidad
  6. En esté apartado se consideran los activos financieros que hacen pagos anuales ó estructuras de flujos con pagos igualmente espaciados (anuales). Para encontrar el valor futuro de estos activos (todos los flujos), se debe aplicar la formula del apartado 1 para cada uno de ellos.

    Un ejemplo sería: Un gestor de un Fondo de Pensiones espera recibir 1.000.000 anual durante los próximos 3 años. Si el gestor puede invertir dichos flujos al 4%, ¿Cuanto espera recibir transcurrido los 3 años.?

    Los flujos serían los siguientes:

    Periodo Observación Calculo Flujo
    0 No hay Flujo 0
    1 Capitalizo 2 años $$1.000.000 * (1.04)^{2}$$ 1.081.600
    2 Capitalizo 1 año $$1.000.000 * (1.04)$$ 1.040.000
    3 Recibo último flujo 1.000.000

    La suma de todos los flujos equivale a la solución buscada

    .

    La formula matemática que expone la solución a este problema se deriva a continuación:

    $$ \begin{eqnarray} FV &=& PV*(1+I)^2 + PV*(1+I) + PV \mbox{......(1)} \\ FV*(1+I) &=& PV*(1+I)^3 + PV*(1+I)^2+ PV*(1+I) \mbox{....(2)} \\ \\ \mbox{Restando 1 de 2 se obtiene} \\ \\ FV * (1 + I -1) &=& PV * [(1+I)^{3} - 1] \\ FV &=& \frac{PV * [(1+I)^{3} - 1]}{I} \end{eqnarray}$$
  7. Valor Futuro de una Anualidad con varios pagos al año
  8. El valor futuro se calcula similar al valor futuro del apartado 3. Los cambios necesarios para un correcto calculo son:

    $$ \begin{eqnarray} i &=& \frac{I}{m} \mbox{.......donde m (número de pagos en el año)} \\ n &=& N * m \\ FV &=& \frac{PV * [(1+i)^{n} - 1]}{i} \\ \end{eqnarray}$$

    Ejercicio en Java

    Implemente la siguiente forma en Java para calcular cada uno de los valores futuros según sea el caso.

    Considere las siguientes clases y relaciones entre ellas:

    1. Clase abstracta ValorFuturo con las variables:double valorPresente, double periodos, double interestRate, constructor y el método abstracto: getValorFuturo().
    2. Clase AnualidadOrdinaria() extiende ValorFuturo.
    3. Clase CapitalizaciónAnual() extiende ValorFuturo.
    4. Clase CapitalizaciónNoAnual() extiende ValorFuturo.
    5. Al digitar un valor en la celda Interes Anual y presionar enter debe salir el resultado correspondiente.
    6. Gestión de Excepciones en caso de datos de entrada incorrectos (NumberFormatException).

Solución

El video solución se encuentra en Youtube .

Read more »

Friday, November 10, 2017

Java Swing Ejercicio 3

Java Swing Ejercicio 3

Objetivo

Evaluar conceptos relacionados con desarrollo de clases, uso de la palabra clave final , Wrraper class, JTable y gestión de excepciones. Identificar como definir el orden de foco mezclando JButtons y JText .

Ejercicio

Implementar la siguiente forma en Java

  1. Identifique los tipos (char, int, ..) a emplear mas acordes con el contexto.
  2. El Botón Add al ser presionado, insertará los datos en las respectivas columnas de la tabla.
  3. El Botón Cancel termina y cierra la aplicación.

Solución

El orden de foco se refiere al orden de selección de los JText y JButtons cuando se presiona el tabulador una vez seleccionada el JTextNombre. El orden de selección de los JText y JButtons sería:

  1. Habilitar JTextNombre para escritura cuando se ejecuta la aplicación (focusCycleRoot).
  2. Habilitar JTextApellido al presionar tabulador en el teclado.
  3. Habilitar JTextEdad al presionar tabulador en el teclado.
  4. Habilitar JButtonAdd al presionar tabulador en el teclado.
  5. Habilitar JButtonCancel al presionar tabulador en el teclado.
  6. Habilitar JTextNombre y comenzar el ciclo de nuevo.

La implementación se encuentra en YouTube .

Read more »

Friday, November 3, 2017

Java Swing Ejercicio 2

Java Swing Ejercicio 2

Objetivo

Se busca evaluar conceptos relacionados con Wrraper class, Boxing y Unboxing. El estudiante debe distinguir y saber cuando implementar los métodos: toString(), valueOf(...) y parse...() en cada uno de los Wrraper class, además de una correcta gestión de posibles excepciones (errores).

Ejercicio

Implemente la siguiente forma en Java

  1. La forma, resume la información requerida para la matricula de un producto en un Software de gestión de inventario.
  2. Identifique los tipos (char, int, ..) a emplear mas acordes con el contexto.
  3. El rango de los campos son: Precio: (0,1000]; Cantidad: [0,20].

Solución

Ver solución en Youtube .

Read more »

Wednesday, November 1, 2017

Java Swing Ejercicio 1

Java Proyecto Swing I

Programa nivel básico

Diseñe y desarrolle la siguiente interfaz:

Considere lo siguiente:

  1. Al hacer click en el botón, el nombre completo debe imprimirse en el campo resultado (Nombre + Apellido).
  2. No hay validación de datos de entrada (por ahora).

Solución

La solución se encuentra en Youtube

Read more »
Earn free bitcoin