Utilizamos cookies propias y de terceros. Al navegar entendemos que aceptas el uso de cookies. +Info.
Política de cookies
Proyecto AjpdSoft

· Inicio
· Buscar
· Contactar
· Cookies
· Descargas
· Foros
· Historia
· Nosotros
· Proponer
· Temas
· Top 10
· Trucos
· Tutoriales
· Usuario
· Wiki

Nick


Contraseña


Nuevo usuario


English

Programacion: Metodología para resolver problemas de ingeniería con Delphi, interpolación
Delphi


Os explicamos cómo realizar una aplicación con el lenguaje de programación Borland (ahora Codegear) Delphi que calcula la interpolación: construcción de nuevos puntos partiendo del conocimiento de un conjunto discreto de puntos. Os explicamos la metodología para resolver problemas de ingeniería con Delphi, válido para otros lenguajes de programación. En el ejemplo calculamos la interpolación lineal y polinómica.



 

Metodología para resolver problemas de ingeniería con Delphi

La resolución de problemas es una parte clave de los cursos de ingeniería y de las de ciencias de la computación. Es importante tener una estrategia consistente para resolver los problemas que se nos puedan plantear.

Es conveniente que esa estrategia sea lo bastante general como para funcionar en todos los campos de la ingeniería y no tener que aprender una metodología para los problemas de química, otra distinta para los de electricidad, una nueva para los de mecánica, etc.

La metodología propuesta funciona para cualquier problema tipo de ingeniería y puede adaptarse para problemas de otras áreas de conocimiento, siempre dando por hecho que vamos a usar un ordenador para resolver el citado problema. El programa informático que se use para programar la solución es independiente del método que nos conduce a él, pudiéndose realizar con cualquiera de las herramientas informáticas que para este fin se nos ofrecen. Concretamente nosotros recomendamos Delphi por su potencia y versatilidad.

 

Planteamiento del problema

El primer paso que hemos de dar consiste en plantear claramente el problema, siendo muy importante preparar un enunciado claro y conciso del problema.

Pongamos un ejemplo práctico: tenemos una bomba que trasvasa agua entre dos depósitos. Esta bomba está accionada por un variador de velocidad que hará que la bomba suministre un caudal u otro en función de la frecuencia. Hemos tomado para varias frecuencias varios datos del caudal suministrado. Lo que queremos es obtener una función (basada en esos datos) que nos diga el caudal que nos dará la bomba para cualquier frecuencia que suministremos con el variador. Esto es lo que tradicionalmente se conoce como interpolar puntos de una gráfica. Así pues el enunciado de nuestro problema sería: "Obtener cualquier punto de una función desconocida, conocidos algunos de ellos de forma empírica"

 

Describir la información de entrada y de salida

El segundo paso consistirá en describir cuidadosamente los datos que tenemos e identificar los valores hacia los que queremos llegar. Esto es lo que comúmente se conoce como entradas y salidas de nuestro problema, que serán las que luego utilizaremos en nuestro desarrollo de software.

Siguiendo con nuestro ejemplo: las entradas serán los puntos conocidos completos, coordenadas "x" e "y" obtenidas empíricamente, así como las coordenadas "x" de los puntos que queremos conocer. Las salida será las coordenadas "y", correspondientes a los valores que nuestra función desconocida tomará para esos valores de ordenada.

 

Resolver el problema a mano para un conjunto de datos sencillo

El tercer parso cosiste en resolver el problema de una manera manual, o con una calculadora, para un conjunto de datos sencillo. Se trata de un paso muy importante y no debe de dejar de hacerse ni tan siquiera en los problemas más simples. En este paso se detalla la solución del problema. Si no estamos preparados para obtener de una manera manual la solución de un caso sencillo, no debemos seguir adelante y deberemos releer el problema o tal vez consultar más documentación de referencia.

En el ejemplo propuesto resolveremos "a mano" el problema para un conjunto de puntos sencillos con los conocidos métodos de interpolación lineal y por el método de interpolación polinómica.

 

Crear una solución de interpolación con el lenguaje de programación Delphi

Una vez que sabemos que tenemos métodos de resolución que funcionan y sabemos bien cómo funcionan, pasamos a la siguiente fase que es la de poner esos métodos en el ordenador para que éste nos ayude en casos más complejos. Este proceso se conoce como la elaboración de un algoritmo, el cual se define como la creación de un bosquejo paso a paso de la solución al problema. Esta es la fase en las que se nos exige tener los conocimientos de programación propiamente dichos, en Delphi en nuestro caso.

La creación del algoritmo la realizaremos usando los comandos de programación de Delphi. Unas veces será sencillo este algoritmo y bastará la utilización de unos pocos de ellos, como el caso de nuestro ejemplo de interpolación como se puede ver en el código fuente del programa realizado, pero habrá casos más complejos en que se necesitará dividir el problema principal en otros más pequeños y se necesitará el uso de muchos y complejos comandos de programación.

 

Probar la solución (programa o aplicación) con diversos datos

Una vez se tiene el algoritmo realizado y programado pasaremos a validarlo, es decir, a probar que la solución que nos da el programa coincide con la que nosotros hemos calculado a mano y, si es posible, coincide también para otros casos singulares conocidos.

En nuestro programa de ejemplo lo podríamos comprobar para los cálculos "manuales" previos a la creación del programa y para otros puntos que podamos tener tomados de los datos de la experiencia empírica de la variación del caudal en función de la frecuencia.

Nota: como hemos visto se puede hacer un programa genérico de interpolación para cualquier tipo de datos o dedicarlo exclusivamente al cálculo del caudal en función de la frecuencia. Ya será cuestión del programador, y del caso específico al que se enfrente, el decidir si puede desarrollar un programa genérico o algo muy específico para el problema al que tiene que enfrentarse. Igualmente reseñar que se puede utilizar posteriormente el código de los algoritmos de solución de unos problemas para otros más complejos que puedan estar relacionados.

 

El código fuente completo de la aplicación AjpdSoft Cálculo Interpolación

La aplicación AjpdSoft Cálculo Interpolación en funcionamiento:

AjpdSoft Cálculo Interpolación

A continuación os mostramos el código fuente de la aplicación AjpdSoft Cálculo Interpolación, cuya descarga gratuita (freeware) 100% open source, con código fuente disponible en:

AjpdSoft Cálculo Interpolación

unit hallar_puntos2;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ExtCtrls, ExtDlgs;

type
  Tinterpolar = class(TForm)
    e_x1: TEdit;
    E_y1: TEdit;
    E_x2: TEdit;
    E_y2: TEdit;
    L_punto1: TLabel;
    L_punto2: TLabel;
    P_solucion: TPanel;
    B_comenzar: TButton;
    B_calcular: TButton;
    B_salir: TButton;
    L_x: TLabel;
    E_x: TEdit;
    b_nuevaX: TButton;
    L_punto3: TLabel;
    E_x3: TEdit;
    E_y3: TEdit;
    M_datos: TMemo;
    RB_interpPolinomica: TRadioButton;
    RB_interpLineal: TRadioButton;
    L_puntosEncontrados: TLabel;
    B_terminar: TButton;
    SaveDialog1: TSaveDialog;
    B_comen: TButton;
    B_salvarDatos: TButton;
    B_almacenar: TButton;
    procedure B_salirClick(Sender: TObject);
    procedure B_comenzarClick(Sender: TObject);
    procedure B_calcularClick(Sender: TObject);
    procedure b_nuevaXClick(Sender: TObject);
    procedure B_terminarClick(Sender: TObject);
    procedure B_salvarDatosClick(Sender: TObject);
    procedure B_almacenarClick(Sender: TObject);
    
  private

    { Private declarations }
  public
    { Public declarations }
  end;

var
  interpolar: Tinterpolar;

implementation

{$R *.dfm}

procedure Tinterpolar.B_salirClick(Sender: TObject);
begin
  close;
end;

procedure Tinterpolar.B_comenzarClick(Sender: TObject);
begin
  E_x1.clear;
  E_y1.clear;
  E_x2.clear;
  E_y2.clear;
  E_x.clear;
  E_x3.Clear;
  E_y3.clear;
  E_x1.Enabled := true;
  E_y1.Enabled := true;
  E_x2.Enabled := true;
  E_y2.Enabled := true;
  E_x3.Enabled := true;
  E_y3.Enabled := true;
  E_x.Enabled := true;
  E_x1.Setfocus;
  P_solucion.Caption := 'SOLUCIÓN';
  B_comenzar.enabled := false;
  B_calcular.enabled := true;
  B_nuevaX.enabled := false;
  B_salvarDatos.enabled := false;
  RB_interpLineal.enabled := false;
  RB_interpPolinomica.enabled := false;
  M_datos.clear;

end;


{ El boton calcular aplica Método de interpolación polinómico de las Diferencias
Divididas de Newton o el método de interpolación lineal según se elija}


procedure Tinterpolar.B_calcularClick(Sender: TObject);
var
  x,x1,x2,x3,y,y1,y2,y3,a,b,c : real;
  solucion : string;
begin
  B_almacenar.Enabled := true;
  B_terminar.Enabled := true;
  if (RB_interpPolinomica.Checked) then
    begin
      if (E_x.text = '')or (E_x1.text = '') or (E_x2.text = '') or (E_y1.text = '')
      or (E_y2.text = '')  or (E_x3.text = '') or (E_y3.text = '') then
        begin
          showmessage('Introduzca los datos necesarios');
          E_x1.SetFocus;
        end
    else
      begin
         x := strtofloat(E_x.text);
        x1 := strtofloat(E_x1.text);
        y1 := strtofloat(E_y1.Text); //equivale a f(x0) del método
        x2 := strtofloat(E_x2.Text);
        Y2 := strtofloat(E_y2.Text); // idem. f(x1)
        x3 := strtofloat(E_x3.Text);
        Y3 := strtofloat(E_y3.Text); // idem f(x2)
        a :=  (y2-y1)/(x2-x1);        // idem f(x0,x1)
        b := (y3-y2)/(X3-x2);       // idem f(x1,x2)
        c := (b-a)/(x3-x1);           // idem f(x0,x1,x2)
        If (x1 = x2) or (x2 = x3) or (x1 = x3) then
          begin
            showmessage('Los valores de X deber ser diferentes');
            E_x1.setfocus;
          end
        else
          begin
            Y := y1+a*(x-x1)+c*(x-x1)*(x-x2);
            str(y:6:2,solucion);
            P_solucion.Caption := 'Y='+solucion;
            E_x1.Enabled := false;
            E_y1.Enabled := false;
            E_x2.Enabled := false;
            E_y2.Enabled := false;
            E_x.Enabled := false;
            E_x3.Enabled := false;
            E_y3.Enabled := false;
            B_calcular.Enabled := false;
            B_nuevaX.enabled := true;
            B_almacenar.setfocus;
          end;
        end;
      end
  else
    begin
      if (E_x.text = '')or (E_x1.text = '') or (E_x2.text = '') or
      (E_y1.text = '') or (E_y2.text = '')  then
         begin
         showmessage('Introduzca los datos necesarios');
         E_x1.SetFocus;
         end
      else
        begin
          x := strtofloat(E_x.text);
          x1 := strtofloat(E_x1.text);
          y1 := strtofloat(E_y1.Text);
          x2 := strtofloat(E_x2.Text);
          Y2 := strtofloat(E_y2.Text);
          If (x1 = x2) then
            begin
              showmessage('Los valores de X1 y X2 deber ser diferentes');
              E_x2.setfocus;
            end
        else
          begin
            Y := y1+(x-x1)*((y2-y1)/(x2-x1));
            str(y:6:2,solucion);
            P_solucion.Caption := 'Y='+solucion;
            E_x1.Enabled := false;
            E_y1.Enabled := false;
            E_x2.Enabled := false;
            E_y2.Enabled := false;
            E_x.Enabled := false;
            B_calcular.Enabled := false;
            B_nuevaX.enabled := true;
            B_almacenar.setfocus;
          end;
        end;
    end;
end;

  
procedure Tinterpolar.b_nuevaXClick(Sender: TObject);
begin
  E_x.Enabled := true;
  E_x.Setfocus;
  B_calcular.Enabled := true;
  B_comenzar.Enabled := false;
  B_nuevaX.Enabled := false;
end;


procedure Tinterpolar.B_terminarClick(Sender: TObject);
begin
  B_calcular.Enabled := false;
  B_comenzar.Enabled := true;
  B_nuevaX.Enabled := false;
  RB_interpLineal.enabled := true;
  RB_interpPolinomica.enabled := true;
  B_almacenar.Enabled := false;
  B_terminar.Enabled := false;
end;

procedure Tinterpolar.B_salvarDatosClick(Sender: TObject);
begin
  savedialog1.title := 'Guardar interpolaciones realizadas';
  savedialog1.defaultExt := 'txt';
  Savedialog1.filter := 'Archivos de texto (*.txt)|*.txt|Todos los archivos|*.*';
  if saveDialog1.execute then
    begin
      M_datos.Lines.savetofile(savedialog1.filename);
      M_datos.clear;
      B_salvarDatos.Enabled :=false;
    end
  else
    showmessage('Los datos NO han sido salvados');
end;


procedure Tinterpolar.B_almacenarClick(Sender: TObject);
begin
if (E_x.Text <> '')  then
  begin
    if RB_interpLineal.checked then
      begin
        M_datos.Lines[0] := 'INT.LINEAL';
        M_datos.lines.add('X='+E_x.Text+'; '+p_solucion.Caption);
        B_almacenar.enabled := false;
        B_salvardatos.enabled := true;
        b_nuevaX.setfocus;
      end
    else
      begin
        M_datos.Lines[0] := 'INT.POLINÓMICA';
        M_datos.lines.add('X='+E_x.Text+'; '+p_solucion.Caption);
        B_almacenar.enabled := false;
        B_salvardatos.enabled := true;
        b_nuevaX.setfocus;
      end;
  end
else
  showmessage('No tiene datos para almacenar');
end;

end.

 

Artículos relacionados

 

 

Créditos

Artículo realizado íntegramente por Alino (Ingeniero Industrial) miembro del proyecto AjpdSoft.


Anuncios


Enviado el Miércoles, 11 noviembre a las 08:42:09 por ajpdsoft
Este sitio web NO CONTIENE malware, todos los programas con código fuente aquí. Autor: Alonso Javier Pérez Díaz Google+ Síguenos en Google+