Servicios Integrales en Computación

Métodos Numéricos con JAVA

admin — Thu, 03 May 2007 21:36:26 +0000

Introducción

EL Java es el lenguaje para el Internet, y entre sus características esta que es un lenguaje de programación orientada a objetos; nuestro propósito es desarrollar en este lenguaje métodos numéricos que permiten las aplicaciones de ingeniería de tal forma que se puedan hacer programas que se bajen por Internet en cualquier parte del mundo.

En esta primera entrega analizaremos la estructura de objetos inicial para poder operar con funciones y polinomios, como primeros métodos veremos como integrar y derivar polinomios y por medio de esto se hallará una de sus raíces. Para las funciones no lineales desarrollaremos el método de la bisección para encontrar una raíz

Clases: Se definio entonces una clase padre de nombre MetodoNumerico, pensemos cual podria ser datos generales para cualquier método numérico, esto es tolerancia y el número máximo de iteraciones, deberia ser estaticas pues no se podria considerar que la toleracia sea un dato para cada instancia de la clase, sino más bien se pertenece a la clase, es por esta razon que se la definio static.

public class MetodoNumerico {
/* número de digitos calculados de la raiz */
public static double tolerancia=5E-7;
/* Máximo número de iteraciones */
public static int maxIteraciones=30;

public MetodoNumerico() {
} public MetodoNumerico(double tol, int maxIter)
{
MetodoNumerico.tolerancia=tol;
MetodoNumerico.maxIteraciones=maxIter;
}
}

Un constructor que me permita modificar los valores de tolerancia y el número máximo de iteraciones, el cual por herencia puede ser usado en las subclases de ella.

Polinomios

Un polinomio se halla definido como:

los métodos que se desarrollaron fueron la derivación, la integración y el método de Newton para hallar una raíz.

Estos conceptos dan lugar en terminos de Java a la creación de una subclase de MetodoNumerico de nombre Polinomio, las cuales a su vez se relacionan directamente con métodos de resolución analitica (Derivacion e Integración) y numérica (Método de Newton).

public class Polinomio extends MetodoNumerico {
/*————————————————–
grado y coeficiente son atributos de cada uno de los Polinomios
especificos a crear (Instancias),gradoMax es el maximo valor de grado que puede poseer un Polinomio
————————————————–*/
/* máximo grado del polinomio es MaxGrado -1 */
private static int gradoMax=20;
/* número de digitos calculados de la raiz */
// private final static double tolerancia=5E-7;
/* Máximo número de iteraciones */
// private final static int maxIteraciones=30;

private int grado; public double[] coeficientes=new double[Polinomio.gradoMax];
/* Constructor de Polinomio */
public Polinomio() {
super();
// super.tolerancia=5E-3;
/* Máximo número de iteraciones */
//super.maxIteraciones=30;
}
/*Constructor de Polinomio con dos argumentos
el grado del polinomio y los coeficientes.
*/ public Polinomio(int grado,double[] coeficientes) {
this();
this.grado=grado;
this.coeficientes=coeficientes;
}
/* Constructor de Polinomio con dos argumentos
el grado del polinomio y los coeficientes.
*/
public Polinomio(int grado,double[] coeficientes,double tol, int maxIter) {
// this();
super(tol,maxIter);
this.grado=grado;
this.coeficientes=coeficientes;
}

El código aquí mostrado nos permite realizar los siguientes analisis, creamos una variable static, de nombre gradoMax, que es el máximo grado de los polinomios, existen ademas dos atributos, uno de ellos de nombre grado que será double y que al crear las instancias cada polinomio que se cree tendra su propio grado, por tanto este será un atributo que pertenecera a cada instancia de Polinomio que se cree, bajo el mismo analisis podemos decir que tenemos el vector de tipo double de nombre coeficientes,

public double[] coeficientes=new double[Polinomio.gradoMax];

en este vector se almacenara la solución del problema

Cada polinomio definido sera una instancia de la clase Polinomio, y este tendra su vector de coeficientes en su correspondiente atributo coeficientes.

double a[] = {6 , 11, 6, 1};

Polinomio p1=new Polinomio(3,a);

Para el ejemplo grado 3 y los coeficientes que se encuentran en el vector a.

Hemos entonces creado el polinomio

Derivación e Integración

Vamos a recurrir a la propiedad de los polinomios mediante la cual se puede encontrar su derivada mediante la expresión

Y cuando se integra un polinomio obtendremos el siguiente polinomio:

Donde C es una constante de integración.

/* Este metodo me permite calcular los valores de los coeficientes de la derivada del polinomio
*/

public double[] coeficientesDerivada()
{ double derivadas[]=new double[Polinomio.gradoMax];
for (int i=1; i<=this.grado; i++)
{ derivadas[i-1]=(i)*this.coeficientes[i];
}
return derivadas;
}

/* Este método nos permite obtener el polinomio correspondiente al valor de la derivada del polinomio dato
*/

public Polinomio derivada()
{ double derivadas[]=new double[Polinomio.gradoMax];
for (int i=1; i<=this.grado; i++)
{ derivadas[i-1]=(i)*this.coeficientes[i];
}
return new Polinomio(this.grado,derivadas);
}

/* Este método nos permite calcular los valores de los coeficientes de la integral del polinomio con costante de integracion igual a 0

*/
public double[] coeficientesIntegral()
{ double integral[]=new double[Polinomio.gradoMax];
for (int i=1; i<=this.grado; i++)
{ integral[i+1]=this.coeficientes[i]/(i+1);
}
integral[0]=0;
return integral;
}

/* Este método permite calcular los valores de los coeficientes de la integtral del polinomio con costante de integracion igual dado por la llamada al metodo

*/
public double[] coeficientesIntegral(double psi)
{ double integral[]=new double[Polinomio.gradoMax];
for (int i=1; i<=this.grado; i++)
{ integral[i+1]=this.coeficientes[i]/(i+1);
}
integral[0]=psi;
return integral;
}

/* Este metodo permite obtener el polinomio correspondiente al valor de la integral del polinomio dato con costante de integracion igual a 0

*/
public Polinomio integralPolinonio()
{ double integral[]=new double[Polinomio.gradoMax];
for (int i=1; i<=this.grado; i++)
{ integral[i+1]=this.coeficientes[i]/(i+1);
}
integral[0]=0;
return new Polinomio(this.grado,integral);
}

/* Este metodo permite obtener el polinomio correspondiente al valor de la integral del polinomio dato con costante de integracion igual dado por la llamada al metodo

*/
public Polinomio integralPolinonio(double psi)
{ double integral[]=new double[Polinomio.gradoMax];
for (int i=1; i<=this.grado; i++)
{ integral[i+1]=this.coeficientes[i]/(i+1);
}
integral[0]=psi;
return new Polinomio(this.grado,integral);
}
}

/* evaluaPolinomio es el metodo que evalua el polinomio para un valor de x dado, notese que se debera aplicar este metodo en la instancia debido a que es un método miembro de la clase Polinomio

*/
public double evaluaPolinomio(double x){
double b;
int n = this.grado;
b = this.coeficientes[this.grado];
for (int i= –n; i>=0; i–)
{
b = b * x + this.coeficientes[i];
}
return b;
}

/* evaluaPolinomioS Este metodo es static por tanto se pertenece a la clase, y la instancia u objeto debe ingresar como argumento del método.

*/
public static double evaluaPolinomioS(Polinomio p1,double x){
double b;
int n = p1.grado;
b = p1.coeficientes[p1.grado];
for (int i= –n; i>=0; i–)
{
b = b * x + p1.coeficientes[i];
}
return b;
}
public double evaluaDerivadaPolinomio (double x)
{
double b;
int n = this.grado;
b = this.grado * this.coeficientes[this.grado];
for (int i= –n; i>=1; i–)
{
b = b * x + i * this.coeficientes[i];
}
return b;
}

Este es un método analitica de solución el cual tiene su ejemplificacion en el método de nombre coeficientesDerivada y coeficientesIntegral, que se puede observar en el diagrama de clases arriba descritos.

Método de newton para la obtención de una raíz

Sea un polinomio P(X) y dado un valor X₀ en las cercanías de una raíz nosotros podemos usar la recta tangente para poder encontrar un valor más cercano por medio de:

Repetimos el procedimiento hasta que entre dos valores consecutivos se hayan encontrado cierta cantidad K de dígitos iguales usando para ello

entonces la raíz será el valor de X_n

En la clase Polinomio podemos ver ademas el método newtonPolinomio, que emplea el método arriba descrito.

public double newtonPolinomio (double xEntrada)
{ int i;
double x, xAnt,fx, fDx;
i = 0;
x = xEntrada;
fx=this.evaluaPolinomio(x);
while (i
{ i++;
fDx = this.evaluaDerivadaPolinomio(x);
xAnt = x;
x = x - fx / fDx;
fx = this.evaluaPolinomio(x);
if (Math.abs((x - xAnt) / xAnt) < Polinomio.tolerancia)
i = Polinomio.maxIteraciones;
}
return x;
}public String newtonPolinomioString (double xEntrada)
{ int i;
double x, xAnt,fx, fDx;
String xString=”Trabajando”;
i = 0;
x = xEntrada;
fx=this.evaluaPolinomio(x);
while (xString == “Trabajando”)
{
if (Math.abs(x) < Polinomio.casiCero)
xString = “Fallo x = 0″;
else
{ i++;
fDx = this.evaluaDerivadaPolinomio(x);
if(Math.abs(fDx) < Polinomio.casiCero)
xString = “Fallo Derivada = 0″;
else
{
xAnt = x;
x = x - fx / fDx;
fx = this.evaluaPolinomio(x);
if(Math.abs((x - xAnt) / xAnt) < Polinomio.tolerancia)
xString = “”+x;
else
{if(i == Polinomio.maxIteraciones)
xString = “Fallo máximas iteraciones”;
}
}
}
}
return xString;
}
}

Funciones No Lineales

La clase correspondiente nos encontramos desarrollandola aun, pero hemos decidido adelantarles nuestro trabajo inicial.

Método de la bisección.

El método de la bisección se halla basado en la propiedad de que el valor de la función cambia de signo en los alrededores de una raíz.

Necesitaremos un intervalo [a,b] donde dicha función cambie de signo ( f(a)*f(b)<0) pues allí casi con seguridades encontrara una raíz. Se encuentra a continuación el centro del intervalo ( X = ( a + b ) / 2 ) y se verifica que f ( a ) * f ( x ) < 0 si esto ocurre se le asigna b = x caso contrario a = x reduciendo el ancho del intervalo a la mitad, este proceso continua reduciéndolo hasta que este sea menor que un cierto valor de tolerancia. Cuando se alcanza dicha condición la raíz se encontrara en el centro del intervalo ( raíz ( a + b ) / 2 )..

class Funcion extends MetodoNumerico {

/*
Constructor que permite llamar al super constructor MetodoNumerico
*/
public Funcion()
{
}
public Funcion(double tol, int maxIter)
{ super(tol,maxIter);
}

/*
el metodo biseccion que encuentra ceros de la funcion a traves del metodo de la biseccion
*/

public double biseccion (double xo, double xf)
{
double x,fx,xant=0;
int i=0;
double fo=f(xo);
do {
x = (xo + xf)/2;
fx = f(x);
i++;
if (fo*fx<=0)
{
xf = x;
}
else {
xo = x;
fo = fx;
}
if (Math.abs((x-xant)/x)
{
i=MetodoNumerico.maxIteraciones;
}
else {
xant = x;
}
}
while (i>=MetodoNumerico.maxIteraciones);
return (xo + xf)/2;
}
}

Pregunta:

Donde se podría definir el método f(), por cierto falta aqui.

Conexión JAVA JDBC – ODBC

pablo — Thu, 12 Apr 2007 16:18:48 +0000

Ejemplo práctico de una conexión a una Base de Datos desde Java usando JDBC-ODBC. Te mostramos dos Ejemplos, uno para Consultar Datos y el otro para Insertar.

Ejemplo 1: Consulta a la Base de Datos

1. Vamos a crear una Clase llamada “JdbcEjem1” la cual tendría la siguientes estructura:

public class JdbcEjem1 {
    public JdbcEjem1() {    }

    public static void main(String[] args) {
   }
}
2.      Debemos importar la siguiete librería:

import java.sql.*;
3. Dentro del método main vamos a declarer las sigiuentes variables:

            Connection con;
            Statement sentencia;
4.      Seguidamente vamos a cargar el Driver usando las siguientes sentencias:

            try{
                        Class.forName(”sun.jdbc.odbc.JdbcOdbcDriver”);
            }
            catch(Exception e)
          {
              System.out.println(”No se ha cargado Driver JDBC-ODBC”);
          }
5.      Para realizar la conexión a la Base de datos se lo realiza de la siguiente manera:

con = DriverManager.getConnection(”jdbc:odbc:odbcEjem”, “”, “”);
notemos que el método getConnection() recibe tres argumentos, el primero es el que indica el URL de conexión que para nuestro caso es jdbc:odbc y seguido de ello escribimos el nombre del Origen de Datos que hemos creado para nuestro ejemplo “odbcEjem”, que es la base de datos a la cual nos vamos a conectar.

Los otros dos argumentos son el nombre de Usuario y Pasword respectivamente, en caso de que existieran, caso contrario irían vacíos como en este ejemplo.

6. Para ejecutar una sentencia se debe instanciar la variable de tipo Statement de la siguiente manera:

                        sentencia = con.createStatement();

7.      Una vez instanciada la variable, podemos ejecutar una consulta, así:

String sql=”select * from alumno;”;
ResultSet result=sentencia.executeQuery(sql);
8. Y para mostrar los datos que devuelve la ejecución de la consulta utilizamos lo siguiente:

while(result.next()) {
System.out.print (”\n”+ result.getString(1) + “ ” +result.getString(2)+ “ ” +result.getString(3));
}
lo que hace es ejecutar un bucle mientras exista un resultado que mostrar, para mostrar la columna 1 del resultado producido al ejecutar la consulta se hace uso de: result.getString(1) y así mismo con el resto de columnas., como se puede observar en las líneas de código anterior.

9. Se cierra la conexión a la Base de Datos usando: con.close();

10. El código finalmente quedaría de la siguiente manera:

import java.sql.*;
public class JdbcEjem1 {

    public JdbcEjem1() {    }
    public static void main(String[] args) {
       Connection con;
       Statement sentencia;
       try{
           //cargar el Driver
            Class.forName(”sun.jdbc.odbc.JdbcOdbcDriver”);
          }

catch(Exception e)

{

System.out.println(”No se ha cargado Driver JDBC-ODBC”);

}

try{

//establecer la conexion

con = DriverManager.getConnection(”jdbc:odbc:OdbcEjem”, “”, “”);

//para ejecutar una sentencia de consulta:

        sentencia = con.createStatement();
        String sql=”select * from alumno;”;
        ResultSet result=sentencia.executeQuery(sql);
        //para mostrar el resultado de la consulta

            while(result.next()) {
                System.out.print (”\n”+ result.getString(1) + “ ” +result.getString(2)+ “ ” +result.getString(3));
            }
        //para cerrar la conexion

con.close();

}

catch(Exception e)

{

System.out.println(”conexion no establecida”);

}
}
}

Ejemplo 2: Insertar Datos

1. Se deben seguir los pasos del 1 al 6 solamente que a esta clase la llamaremos JdbcEjem2

2. Para insertar los datos habría que hacer uso de la siguiente sentencia:

String sql=”insert into alumno(cedula,nombre,edad,nivel) values(1704,’Laura’,23,’cuarto’);”;

sentencia.executeUpdate(sql);
notar que a diferencia del ejemplo 1 en esta ocación se hace uso del método: executeUpdate() ya que este es el método usado para eliminar, actualizar e insertar datos.

3. El código finalmente quedaría de la siguiente manera:

import java.sql.*;
public class JdbcEjem2 {

    public JdbcEjem2() {
    }
    public static void main(String[] args) {
       Connection con;
       Statement sentencia;
       try{
            Class.forName(”sun.jdbc.odbc.JdbcOdbcDriver”);
       }

catch(Exception e)

{

System.out.println(”No se ha cargado Driver JDBC-ODBC”);

       }
       try{
        con = DriverManager.getConnection(”jdbc:odbc:OdbcEjem”, “”, “”);
        sentencia = con.createStatement();
        String sql=”insert into alumno(cedula,nombre,edad,nivel) values(1704,’Laura’,23,’cuarto’);”;
        sentencia.executeUpdate(sql);
        con.close();
       }

catch(Exception e)

{

System.out.println(”conexion no establecida”);

}

Calculadora Estadística

admin — Mon, 02 Apr 2007 16:57:38 +0000

Es una sencilla Calculadora Estadística que te permite tabular tus datos numéricos e indicarte la Mediana, la Moda y el Promedio.

NOTA: Tu puedes copiar y pegar tus datos desde una fila o columna de Excel.

Está desarrollada en Java, si tienes problemas puedes descargarte gratis desde www.java.com las actualizaciones necesarias, o escribirnos a: estadistika@sincows.com

Puedes ver el ejemplo funcionando en: www.sincows.com/estadistika/index.php

El código fuente lo puedes descargar gratis desde:

www.sincows.com/estadistika/downloads/calc_java.zip

Este programa está desarrollado en Java y se utilizo la herramienta NetBeans 3.3 y jdk4.0 para diseñar el formulario.

La clase que contiene los métodos para calcular la Moda, Mediana y Promedio se llama “Calculos”

La clase del formulario se llama “Calculadora”

El cálculo de la Moda:

Para el cálculo de la Moda se utilizo una clase llamada “DatosSeparados”, esta tiene el siguiente código:

/*Esta clase utiliza los datos que tenemos en el vector que ya esta ordenado y nos permite encontrar la MODA. */
class DatosSeparado
{
     static DatosSeparado ultimo;
     static DatosSeparado mayor;
     static DatosSeparado control;
     String carac;
     int contar=0;

     DatosSeparado(String cc)
     {
          this.carac=cc;
          if (ultimo == null)
               mayor = this;
          else
          {
               control = ultimo;
               if (control.carac.equalsIgnoreCase(cc))
               {
                    control.contar++;
                    this.contar = control.contar;

                    if (mayor.contar < this.contar )
                    {
                         mayor=this;
                    }
              }
         }
          ultimo = this;
     }

}

Dentro de la clase “Calculos” se creo la función “moda” para calcular la moda mientras se recorre los elementos del Vector, creando nuevas instancias de la clase “DatosSeparados”.

public class Calculos {

      /*
      Función moda
      Recibe un vector ordenado ascendentemente y el tamaño de ese vector

A través de un Bucle recorremos el vector dentro del bucle se llama al constructor de la clase que nos permite encontrar la MODA

      public void moda(String lisval[],int tam)
      {
            for (int i=0; i {
                  new DatosSeparado(lisval[i]);
            }
      }
}

Webservice php con cliente Excel

admin — Mon, 02 Apr 2007 16:10:29 +0000

Es es un pequeño ejemplo donde se crea un webservice el PHP y el cliente en Excel que hace uso de los servicios del WebService.

Puedes descargarte este documento: WebSErvice PHP con cliente Excel

NOTA IMPORTANTE: Este ejemplo fue probado usando Xamp 4.4.1 y haciendo Switch a la versión PHP 4, para ello hay que ir a la carpeta donde se instaló el XAMPP (E:Archivos de programaxampp) y ejecutar el archivo llamado “php-switch.bat” que es el que permite cambiar de Versión.

1. Como estamos usando XAMP buscamos la carpeta donde esté instalado (E:Archivos de programaxampp) y dentro de htpdocs creamos una carpeta que contendrá nuestro ejemplo, a esta la llamaremos ejemplo001.

Dentro de nuestra carpeta ejemplo001 copiamos el archivo llamado “nusoap.php” …………

Puedes descargarte este documento: WebSErvice PHP con cliente Excel

Programar Doble Click Visio .NET

admin — Wed, 07 Mar 2007 18:25:32 +0000

Solución a problema de doble clic sobre un shape de Microsoft Visio

Documento sincows

EL PROBLEMA
Microsoft Visio da la libertad de que los usuarios directos (no programadores) de Visio le asignen una funcionalidad personalizada al doble clic sobre un shape (Ej.: se puede asignar un macro personalizado). Pero esta libertad que se da al usuario crea una limitante al programador .NET (Add-in) a la hora de asignar un evento o al llamar a un formulario.

LA SOLUCION

En la celda del EventDblClick se debe asignar un valor. Se muestra a continuación que se ha asignado 6

Trabajar con el evento CellChanged de los eventos que se crean en .NET

Public WithEvents vsoShape As Microsoft.Office.Interop.Visio.Shape

Este evento permite detectar el cambio realizado sobre alguna celda del shape, por lo que validamos que el cambio se haya realizado sobre la celda de nombre “EventDblClick” para de esta manera llamar a nuestro código personalizado, para conseguir que siempre que se de un doble clic sobre el shape exista un cambio de valor en la celda y por la tanto se desencadene el evento CellChanged, se debe realizar un incremento en el valor de la Cell.Formula del EventDblClick y una validación para que este no sobrepase el valor de 255.

Private Sub vsoShape_CellChanged(ByVal Cell As Microsoft.Office.Interop.Visio.Cell) Handles vsoShape.CellChanged
If Cell.Name = “EventDblClick” Then
      ‘AQUÍ CÓDIGO PERSONALIZADO
      If Cell.Formula >= 255 Then
              Cell.Formula = 6
     Else
              Cell.Formula = Val(Cell.Formula) + 1
      End If
End If
End Sub

Servicios Integrales en Computación

Métodos Numéricos con JAVA

Introducción

Polinomios

Derivación e Integración

Método de newton para la obtención de una raíz

Funciones No Lineales

Método de la bisección.

Conexión JAVA JDBC – ODBC

Ejemplo 1: Consulta a la Base de Datos

Ejemplo 2: Insertar Datos

Calculadora Estadística

Webservice php con cliente Excel

Programar Doble Click Visio .NET