LENGUAJE C # C# (leído en inglés "C Sharp" y en español "C Almohadilla") es el nuevo lenguaje de propósito general diseñado por Microsoft para su plataforma .NET. Aunque es posible escribir código para la plataforma .NET en muchos otros lenguajes, C# es el único que ha sido diseñado específicamente para ser utilizado en ella, por lo que programarla usando C# es mucho más sencillo e intuitivo que hacerlo con cualquiera de los otros lenguajes
DESXCRIPCION DESXCRIPCION DE C # Es homogéneo. El tamaño de los tipos de datos básicos es fijo e independiente del compilador, sistema
•
operativo o máquina en la que se compile (no ocurre lo que en C++), lo que facilita l a portabilidad del código.
Es actual. C# incorpora en el propio lenguaje elementos que se han demostrado ser muy útiles para el
•
desarrollo de aplicaciones como el tipo básico decimal que representa valores decimales con 128 bits, lo que le hace adecuado para cálculos financieros y monetarios
Emplea un sistema de tipos unificado . Todos los tipos de datos (incluidos los definidos por el usuario)
•
siempre derivarán, aunque sea de manera implícita, de una clase base común llamada System.Object,
Proporciona seguridad con los tipos de datos. C# no admiten ni funciones ni variables globales sino que
•
todo el código y datos han de definirse dentro de definiciones de tipos de datos, lo que reduce problemas por conflictos de nombres y facilita la legibilidad del código.
Proporcion Propo rcionaa instr instruccio ucciones nes segur seguras as. En C# se han impuesto una serie de restricciones para usar las
•
instrucciones de control más comunes. Por ejemplo, toda condición está controlada por una expresión condicional, los casos de una instrucción condicional múltiple (switch) han de terminar con una instrucción break o goto, etc. •
Facilita la extensibilidad de los operadores . C# permite redefinir el significado de la mayoría de los operadores -incluidos los de conversión, tanto para conversiones implícitas como explícitas- cuando se aplican a diferentes tipos de objetos.
•
Permite Permi te incor incorpora porarr modif modificado icadores res infor informativ mativos os sobre un tipo o sus miemb miembros ros. C# ofrece, a través del concepto de atributos, la posibilidad de añadir, a los metadatos del módulo resultante de la compilación de cualquier fuente, información sobre un tipo o sus miembros a la generada por el compilador que luego podrá ser consultada en tiempo ejecución a través de la biblioteca de reflexión de .NET. Esto, que más bien es una característica propia de la plataforma .NET y no de C#, puede usarse como un mecanismo para definir nuevos modificadores.
Visual Studio 2005 Microsoft visual studio. Es un entorno de desarrollo integrado (ide, por sus siglas en inglés) para sistemas operativos windows. soporta varios lenguajes de programación tales como visual c++, visual c#, visual j#, asp.net y visual basic .net, aunque actualmente se han desarrollado las extensiones necesarias para muchos otros.
Visual studio permite a l os desarrolladores crear aplicaciones, programas, sitios y aplicaciones web, así como servicios web en cualquier entorno que soporte la plataforma .net (a partir de la versión versión net 2002). así se pueden crear aplicaciones que se intercomuniquen entre estaciones de trabajo, páginas web y dispositivos móviles.
Indicaciones: •
Reconoce mayúsculas y minúsculas
•
Cada instrucción u orden se finaliza con ;
•
Los bloques de ordenes se encierran entre llaves y no se escribe el ; después de la llave de cierre
•
Instrucciones: •
Console.WriteLine (“TEXTO”): escribe el texto en la consola en una sola línea.
•
Console.Write (“TEXTO”): hace lo mismo que la instrucción writeline aunque no escribe el terminador de línea.
•
Console.ReadLine ( ): lee desde consola (sirve para ingresar ingresar datos desde la consola).
•
Tipo.Parse (CONSOLE.READLINE (CONSOLE.READLINE ( )): convierte lo escrito en consola en el tipo de variable variable especificado.
•
Tipos de datos: •
DOUBLE : datos reales
•
INT : datos enteros
•
STRING: caracteres
•
BOOL: valores lógicos (true, false)
Declaración de variables: Iniciación de la variable Publicación
Operaciones: •
IF:
solo se activa cuando la condición es cierta
•
OB : si
se desea ejecutar mas de una instrucción se encierra en bloque delimitado por l laves
MÉTODO DE BISECCIÓN Es un método de intersección funcional basado en el Teorema del Valor Intermedio El método de la bisección o corte binario es un método de búsqueda incremental que divide el intervalo siempre en dos. Conocido debido a que halla la raíz de una manera segura. Consiste Consiste en buscar buscar un intervalo intervalo donde la función función a analizar analizar cambia de signo. Por lo tanto, tanto, la localización localización del cambio cambio de signo se logra con más exactitud al dividir el intervalo en una cantidad definida de subintervalo. Se rastrea cada uno de estos subintervalo para encontrar el cambio de signo. El proceso se repite y la aproximación a la raíz mejora cada vez más a medida que los subintervalo se dividen en espacios más pequeños.
Descripción Verificamos la existencia de la raíz en el intervalo de búsqueda
.Si f(a1) y f(b1) tienen signos opuestos entonces existe la raíz. Encontramos nuestra aproximación de esta manera P1=a1+b1 2 Desechamos el intervalo que no contiene a la raíz y definimos nuestro nuevo intervalo de búsqueda de la siguiente forma: -Si f(a) y f(b) tiene signos iguales el intervalo que contiene a la raíz es [p1,b1] : a2=p1 ; b2=b1 -En caso contrario: a2= a1 ; b2=p1
Variables Las variables con la que el programa trabajara son: • • •
a: Indica el primer parámetro de la ecuación. b : Indica el segundo parámetro de la ecuación. p: Indica el valor de la iteración.
•
n : Indica el número de iteraciones realizadas.
EJEMPLO 1 En la función x2+5x-3, calcular la raíz con una tolerancia de10-3, en el intervalo [2,5].
SOLUCION: using System; using System.Collections.Generic; using System.Text; namespace ConsoleApplication2 { class Program { static double f(double x) { double valor = x*x+5*x-3; return valor; } static void Main(string[] args) { //definir variable double a, b, tol, pi, error; int n0, i; // inicializar variables a = 2; b = 5; tol = 0.0001; i = 1; n0 = 100; while (i <= n0) { // hacer los calculos pi = (a + b) / 2; error = (b - a) / 2; if (f(pi) == 0 || error <= tol) { // publicar la raiz Console.WriteLine("la raiz es {0}", pi); break; } else if (f(a) * f(pi) > 0) // redefinir a a = pi; else // redefinir b b = pi; i = i + 1; } if (i > n0) Console.WriteLine("el metodo fracaso despues de {0} interaciones ", n0); } }
}
MÉTODO DE FALSA POSICIÓN O DE CUERDAS Este método, como en el método de la bisección, parte de dos puntos que rodean a la raíz f(x)=0, es decir, dos puntos a y b tales que f(a) ; f(b) < 0. La siguiente aproximación se calcula como la intersección con el eje x de la recta que une ambos puntos. En cálculo numérico, el método de regla falsa o falsa posición es un método iterativo de resolución numérica de ecuaciones no lineales. El método combina el método de bisección y el método de la secante.
Descripción Analizamos si hay un cambio de signo en el intervalo dado [a1,b1]en cuyo caso exista raíz. Consideramos la cuerda que une los puntos (a1,f(a1)),(b1,f(b1)) y calculo la aproximación con: P1=b1-f(b1)(b1-a1) f(b1)-f(a1) Se busca un nuevo intervalo, analizando el cambio de signo. Si f(a1) y f(p1) tienen el mismo signo entonces el nuevo intervalo es [p2,b1]:
a2=p1
b2=b1
Caso contrario el intervalo es [a1,p1] en este caso :a2=a1 ; b2=p1 Volvemos al paso 1 ahora nuevo con nuestro intervalo de búsqueda.
Variables Las variables con la que el programa trabajara son: • • •
a : Indica el primer parámetro de la ecuación. b : Indica el segundo parámetro de la ecuación. p : Indica el valor de la iteración.
•
n : Indica el número de iteraciones realizadas.
EJEMPLO 1: En la función x3+2x2-10, calcular la raíz con una tolerancia de 10-2, en el intervalo [1,2].
SOLUCIÓN using System; using System.Collections.Generic; using System.Text; namespace ConsoleApplication1 { class Program { static double f(double x) { double valor = x * x * x + 2 * x * x - 10; return valor; } static void Main(string[] args) { //definir variable double a, b, tol, pi, error, c; int n0, i; // inicializar variables a = 1; b = 2; c = 0; tol = 0.001; i = 1; n0 = 100; while (i <= n0) { // hacer los calculos pi = b - f(b) * (b - a) / (f(b) - f(a)); error = Math.Abs((pi - c) / pi); Console.WriteLine("i={0},p={1},error{2}", i, pi, error); if (f(pi) == 0 || error <= tol) { // publicar la raiz Console.WriteLine("la raiz es {0}", pi); break; } else if (f(a) * f(pi) > 0) { // redefinir a a = pi; c = pi; } else // redefinir b { b = pi; c = pi; } i = i + 1;
} if (i > n0) Console.WriteLine("el metodo fracaso despues de {0} interaciones ", n0);
MÉTODO DE NEWTON En análisis numérico, el método de Newton (conocido también como el método de Newton-Raphson o el método de Newton-Fourier). Es un algoritmo eficiente para encontrar aproximaciones de los ceros o raíces de una función real. También puede ser usado para encontrar el máximo o mínimo de una función, encontrando los ceros de su primera derivada. Supóngase f:[a,b]R función derivable definida en el intervalo real [a,b]. Empezamos con un valor inicial p0 y definimos para cada número natural n. pn = pn-1 –f(pn-1 ) f´( pn-1 ) Donde f´(x) denota la derivada de f.
Algoritmo 1.- Buscamos un intervalo donde hay cambio de signo. Tomamos una aproximación inicial p0( cercana a la raíz).
2.- consideramos la recta tangente a la curva (p0;f(p0)). 3.- Intersectamos la recta tangente con el eje x y la primera aproximación es p1. pn = pn-1 –f(pn-1 ) f´( pn-1 )
4.- La nueva aproximación es p1 y volvemos al paso 2. Variables. Las variables con la que el programa trabajara son: • • •
pn-1 : Indica el primer valor de la ecuación. pn: Indica el valor de la iteración. n : Indica el número de iteraciones realizadas.
EJEMPLO I En la función x3- 3x2+2x+3 , calcular la raíz con una tolerancia de 10-2.
Solución using System; using System.Collections.Generic; using System.Text; namespace ConsoleApplication1 { class Program { static double f(double x) { double valor = x*x*x - 3*x*x+2*x+3 ; return valor; } static double derivada(double x) { double valor = 3 * x * x - 4 * x; return valor; } static void Main(string[] args) { //definir variable double tol, p0, error, p; int n0, i; // inicializar variables p0 = 2.5; tol = 0.01; i = 1; n0 = 100; while (i <= n0) { // hacer los calculos p = p0 - f(p0) / derivada(p0); error = Math.Abs(p - p0); Console.WriteLine("i={0},p={1},error{2}", i, p, error); if (error <= tol) { // publicar la raiz Console.WriteLine("la raiz es {0}", p); break; } else { //redefinir la aproximacion p0 = p; i = i + 1; } } if (i > n0) Console.WriteLine("el metodo fracaso despues de {0} interaciones ", n0); Console.ReadLine();
} } }
MÉTODO DE LA SECANTE
Descripción Encontramos el intervalo de búsqueda Tomamos dos aproximaciones iníciales a la raíz P0 y P1.
Evaluamos la función en esas aproximaciones f(P0) y f(P1) luego trazamos la recta secante a la curva en los puntos (P0,f(P0)) y (P1,f(P1)).
Encontramos la nueva aproximación de la raíz intersectando la recta secante con el eje X.
Ahora las nuevas aproximaciones a considerar son P2 y P1 (dos consecutivas)
Regresamos al paso 2.
Variables Las variables con la que el programa trabajara son:
•
: Indica el primer valor de la ecuación.
•
•
: Indica el segundo valor de la ecuación. : Indica el valor de la iteración.
Ejemplo con ingreso de datos: using System; using System.Collections.Generic; using System.Text; namespace ConsoleApplication1 { class Program { static double f(double x) { double valor = Math.Cos(x)-x ; return valor; } static void Main(string[] args) { // variable double tol, p0, p1, error, p, q0, q1; int n0, i; // inicializar variables Console.WriteLine("1er numero"); p0 = double.Parse(Console.ReadLine()); Console.WriteLine("2do numero"); p1 = double.Parse(Console.ReadLine()); Console.WriteLine("ingrese tolerancia"); tol = double.Parse(Console.ReadLine()); q0 = f(p0); q1 = f(p1); i = 2; n0 = 100; while (i <= n0) { //calculos p = p1 - q1 * (p1 - p0) / (q1 - q0); error = Math.Abs(p - p0)/p; if (error <= tol) { // raiz Console.WriteLine("la raiz es {0}", p); break; } else { //redefinir la aproximacion i = i + 1; p0 = p1; q0 = q1; p1 = p; q1 = f(p); } } if (i > n0) Console.WriteLine("el metodo fracaso despues de {0} interaciones ", n0); Console.ReadLine();
} } }
MÉTODO DE PUNTO FIJO Es un método numérico usado para de la raíz de una función. Este método aunque no es el más sencillo, ni el más rápido, es útil ya que es la base de los demás métodos. El método del punto fijo se basa en que una raíz de la ecuación f(x)=0 será un punto fijo de la ecuación que o . Podemos construir una sucesión que tienda al punto fijo de la ecuación ecuación . Para ello consideramos la sucesión:
siempre
, o lo que es lo mismo a la solución de la
Básicamente se da un valor y este se evalúa en una función previamente calculada (llamada también función equivalente). Después en base al resultado obtenido se busca el error mediante
Si esto se cumple se encontró la raíz si no, se evalúa el nuevo valor en la función equivalente así hasta llegar al error.
Descripción Dada una función f(x) se localiza su equivalente. Después se asigna un valor inicial que es x0. Reemplazar todos los valores en la formula. Se asigna un valor de error
. Donde es el punto medio de la iteración actual y es el punto medio de la iteración anterior. Al cumplirse la condición, la raíz o solución es el último punto medio que se obtuvo.
Variables Las variables con la que el programa trabajara son: : Indica el primer valor de la ecuación. : Indica el valor de la iteración. : Indica el número de iteraciones realizadas.
EJEMPLO 1: using System; using System.Collections.Generic; using System.Text; namespace ConsoleApplication1 { class Program { static double g(double x) {//variable double valor = 10 / (x + 2); return valor; } static void Main(string[] args) { //definir variable double tol, p0, error, p; int n0, i; //ingresamos desde consola Console.WriteLine("p0"); p0 = double.Parse(Console.ReadLine()); Console.WriteLine("tolerancia"); tol = double.Parse(Console.ReadLine()); // inicializar variables i = 1; n0 = 100; //aplicamos la condicion mientras while (i <= n0) { // hacer los calculos p = g(p0); error = Math.Abs(p - p0); //condicion para la tolerancia Console.WriteLine("i={0},p={1},error{2}", i, p, error); if (error <= tol) { // publicar la raiz Console.WriteLine("la raiz es {0}", p); //cerramos la condicion break; } else { //redefinir la aproximacion p0 = p; i = i + 1; } } if (i > n0) Console.WriteLine("el metodo fracaso despues de {0} interaciones ", n0); Console.ReadLine(); } }
}
METODO DEL POLINOMIO INTERPOLANTE DE LAGRANGE
FUNCIONES DE INTERPOLACIÓN Hay una extensa familia de métodos que se basan en aproximar la función a integrar f(x) por otro función g(x) de la cual se conoce la integral exacta. La función que sustituye la original se encuentra de forma que en un cierto número de puntos tenga el mismo valor que la original.
FÓRMULAS DE NEWTON-COTES La interpolación con polinomios evaluada en puntos igualmente separados en
da lasfórmulas de Newton-Cotes, de
las que la regla del rectángulo, la del trapecio y la de Simpson son ejemplos. Si se escogen los nodos hasta k = n + 1 será la fórmula de Newton-Cotes cerrada y si se escogen k = n − 1 será la fórmula de Newton-Cotes abierta.
Regla Del Punto Medio Si en el método anterior la función pasa a través del punto
este método se llama la regla del punto medio:
Regla Del Rectángulo El método más simple de este tipo es hacer a la función interpoladora ser una función constante (un polinomio de orden cero) que pasa a través del punto (a,f(a)). Este método se llama la regla del rectángulo:
Regla De Simpson La función interpoladora puede ser un polinomio de grado 2 que pasa a través de los puntos método se llama regla de Simpson:
,
y
. Este
.
Regla Del Trapecio La función interpoladora puede ser una función afín (un polinomio de grado 1 o sea una recta) que pasa a través de los puntos
y
. Este método se llama regla del trapecio:
Reglas Compuestas Para cualquier regla interpoladora, se puede hacer una aproximación más precisa dividiendo elintervalo número
en algún
de subintervalos, hallando una aproximación para cada subintervalo, y finalmente sumando todos los
resultados. Las reglas que surgen de hacer esto se llaman reglas compuestas, y se caracterizan por perder un orden de precisión global frente a las correspondientes simples, si bien globalmente dan valores más precisos de la integral, a costa eso sí de incrementar significativamente el coste operativo del método. Por ejemplo, la regla del trapecio compuesta puede expresarse como:
Ejemplo 1 using System; using System.Collections.Generic; using System.Text; namespace ConsoleApplication13 { class Program { static void Main(string[] args) { int i, j, n, longitud, longitud1; double L; double[] x; double[] fx; double valor; double fvalor; Console.WriteLine("ingrese longitud"); longitud = int.Parse(Console.ReadLine()); x = new double[longitud]; for (i = 0; i < longitud; i++) { Console.WriteLine("ingrese el nodo{0}" , i); x[i] = double.Parse(Console.ReadLine()); } Console.ReadLine(); Console.WriteLine("ingrese longitud"); longitud1 = int.Parse(Console.ReadLine()); fx = new double[longitud1]; for (i = 0; i < longitud1; i++) { Console.WriteLine("ingrese valor en funcion", i); fx[i] = double.Parse(Console.ReadLine()); } Console.ReadLine(); Console.WriteLine("ingrese valor de x"); valor = double.Parse(Console.ReadLine()); fvalor = 0; i = 0; n = 3; while (i <= n - 1) { L = 1; j = 0; while (j <= n - 1) { if (i != j) { L = L * (valor - x[j]) / (x[i] - x[j]); } j = j + 1; } fvalor = fvalor + L * fx[i];
i = i + 1; } Console.WriteLine("El resultado es:{0}", fvalor); } }
METODO DE INTERPOLACION DE NEWTON Diferencias Divididas POLINOMIO DE INTERPOLACIÓN DE LAGRANGE Es una reformulación del polinomio de Newton, este polinomio de interpolación evita el cálculo de las diferencias divididas y vine dado por:
Usando triángulos semejantes, se tiene:
que se puede reordenar como :
La cual es una formula de interpolación lineal. La notación f 1(X) indica que se trata de un polinomio de interpolación de primer orden. Nótese que además de representar la pendiente de la linera que conecta los dos puntos, el termino
Es una aproximación de diferencias divididas finitas a la primera derivada. En general, entre más pequeño sea el intervalo entre dos puntos, más exacta será la aproximación
FORMA GENERAL: Este es el único polinomio de n-esimo orden que pasa exactamente por los n + 1 puntos. Si tenemos n=1 2 puntos
Descripción Enunciado Teórico: f1 (x) = x - x1 f (x0) + x - x0 f (x1)
x0 - x1 x1 - x0 l0 (x) = x - x1 l1 (x) = x - x0 x0 - x1 x1 - x0
EJEMPLO 1: using System; using System.Collections.Generic; using System.Text; namespace ConsoleApplication1 { class Program { static double g(double x) { int n=5,m,j; double[] x={0,0.2,0.4,0.6,0.8}; double[] fx={1,1.22140,1.49182,1.49182,1.82212,2.22554}; double[,]T; T=new double[] m =n-1; i=0; while(i<=m-1); { T(i,0)=(f(x(i+1))-f(x(i)))/((x(i+1))-(x(i))); i=i+1; } j=1; while(i<=m-1); { T(i,j)=(T(i,j-1)-T(i-j,j-1))/(x(i+1)-x(j-1)); i=i+1; } } j= j+1; Console.ReadLine(); } }
INTEGRACION NUMERICA: METODO DEL TRAPECIO Lo importante es recordar la formación de un trapecio como figura geométrica.
Eligiendo un espaciado, cualquiera, para nuestro caso:
se divide el intervalo [a, b] por medio de puntos igualmente espaciados
tenemos que, las ordenadas de dichos puntos son
En cada intervalo (x i , x i+1 ) se sustituye la función f(x) por la recta que une los puntos (x i , y i ) y (x i+1 , y i+1 ) tal como se aprecia en la figura. El el área total aproximada es la suma de las áreas de los n pequeños trapecios de anchura h
o bien, agrupando términos
EJEMPLO 1 using System; using System.Collections.Generic; using System.Text; namespace ConsoleApplication1 { class Program { static double f(double x) { double I = Math.Sin(x); return I; } static void Main(string[] args) { int i; double a, b, h, I, n; Console.WriteLine("ingrese 1 intervalo"); a = double.Parse(Console.ReadLine()); Console.WriteLine("ingrese 2 intervalo"); b = double.Parse(Console.ReadLine()); Console.WriteLine("ingrese n"); n = double.Parse(Console.ReadLine());
h = (b - a) / n; I = (f(a) + f(b)) / 2; for (i = 1; i <= n - 1; i++)
I = I + f(a + i * h); I = I * h;
Console.WriteLine("el valor de la funcion es:{0}", I); Console.ReadLine();
} } }
METODO DE SIMPSON SIMPLE Y COMPUESTO Cálculo de áreas: Uno de los problemas matemáticos más frecuentes es el cálculo del área que se forma al graficar una función. Por ejemplo, se necesita calcular el área A que aparece en la siguiente figura:
en donde la función f(x) y los valores a y b son conocidos. En este tipo de problemas se pueden obtener dos tipos de soluciones: •
Soluciones algebraicas: se obtiene una fórmula precisa y exacta para el área solicitada.
•
Soluciones numéricas: se calcula numéricamente una estimación del área.
EL MÉTODO DE SIMPSON. En este procedimiento, se toma el intervalo de anchura 2h, comprendido entre xi y xi+2, y se sustituye la función f(x)por la parábola que pasa por tres puntos (xi, yi), (xi+1, yi+1), y (xi+2, yi+2). El valor del área aproximada, sombreada en la figura, se calcula con un poco más de trabajo y el resultado es
El método de Simpson deberá ser mucho más exacto que el procedimiento del trapecio. El área aproximada en el intervalo [a, b] es
El primer paréntesis, contiene la suma de los extremos, el segundo, la suma de los términos de índice impar, y el tercero la suma de los términos de índice par. En el método de Simpson, el número de divisiones n debe de ser par. En el caso de que el usuario introduzca un número impar el programa lo convierte en el número par siguiente.
REGLA DE SIMPSON COMPUESTA
En el caso de que el intervalo [a,b] no sea lo suficientemente pequeño, el error al calcular la integral puede ser muy grande. Para ello, se recurre a la fórmula compuesta de Simpson. Dividiremos el intervalo [a,b] en n subintervalos iguales, de manera que xi = a + ih, donde h = (b −a) / n para i = 0,1,...,n. Sumando las integrales de todos los subintervalos, llegamos a que:
El máximo error viene dado por la expresión
Version simplificada:
Donde E son los extremos I son la funcion evaluada en los intervalos impares y P la funcion evaluada en los intervalos pares. Con n mayor que 2 y par. )
EJEMPLO 1: using System; using System.Collections.Generic; using System.Text; namespace ConsoleApplication1 { class Program { static double f(double x) { double I = Math.Sin(x); return I; } static void Main(string[] args) { int i; double a, b, h, n, xI0, xI1, xI2, x, xI; Console.WriteLine("ingrese 1 intervalo"); a = double.Parse(Console.ReadLine()); Console.WriteLine("ingrese 2 intervalo"); b = double.Parse(Console.ReadLine()); Console.WriteLine("ingrese n"); n = double.Parse(Console.ReadLine()); h = (b - a) / (2 * n); xI0 =(f(a) + f(b)); xI1 =0; xI2 =0; for (i = 1; i <= 2*n - 1; i++) { x = a + i * h; if (i % 2 == 0) xI2 = xI2 + f(x); else xI1 = xI1 + f(x); } xI = (h * (xI0 + 2*xI2 + 4*xI1) )/ 3; Console.WriteLine("el valor de la funcion es:{0}", xI); Console.ReadLine();
} } }
METODO DE ALGORITMOS MULTIDIMENSIONALES Un arreglo unidimensional es un tipo de datos estructurado que está formado de una colección finita y ordenada de datos del mismo tipo. Es la estructura natural para modelar listas de elementos iguales. El tipo de acceso a los arreglos unidimensionales es el acceso directo, es decir, podemos acceder a cualquier elemento del arreglo sin tener que consultar a elementos anteriores o posteriores, esto mediante el uso de un índice para cada elemento del arreglo que nos da su posición relativa. Para implementar arreglos unidimensionales se debe reservar espacio en memoria, y se debe proporcionar la dirección base del arreglo, la cota superior y la inferior.
MATRICES
Una matriz es una tabla ordenada de escalares aij de la forma
La matriz anterior se denota también por (aij), i =1, ..., m, j =1, ..., n, o simplemente por (aij). Los términos horizontales son las filas de la matriz y los verticales son sus columnas. Una matriz con m filas y n columnas se denomina matriz m por n, o matriz m ´ n. Las matrices se denotarán usualmente por letras mayúsculas, A, B, ..., y los elementos de las mismas por minúsculas, a, b, ... Ejemplo:
donde sus filas son (1, -3, 4) y (0, 5, -2) y sus
SUMA Y RESTA DE MATRICES Para poder sumar o restar matrices, éstas deben tener el mismo número de filas y de columnas. Es decir, si una matriz es de orden 3 ´ 2 y otra de 3 ´ 3, no se pueden sumar ni restar. Esto es así ya que, tanto para la suma como para la resta, se suman o se restan los términos que ocupan el mismo lugar en las matrices. Ejemplo:
Para sumar o restar más de dos matrices se procede igual. No necesariamente para poder sumar o restar matrices, éstas tienen que ser cuadradas. Ejemplo:
PRODUCTO DE MATRICES Para poder multiplicar dos matrices, la primera debe tener el mismo número de columnas que filas la segunda. La matriz resultante del producto quedará con el mismo número de filas de la primera y con el mismo número de columnas de la segunda. Es decir, si tenemos una matriz 2 ´ 3 y la multiplicamos por otra de orden 3 ´ 5, la matriz resultante será de orden 2 ´ 5. (2 ´ 3) ´ (3 ´ 5) = (2 ´ 5) Se puede observar que el producto de matrices no cumple la propiedad conmutativa, ya que en el ejemplo anterior, si multiplicamos la segunda por la primera, no podríamos efectuar la operación. 3 ´ 5 por 2 ´ 3, puesto que la primera matriz no tiene el mismo número de columnas que filas la segunda.
Supongamos que A = (ai j ) y B = (bi j ) son matrices tales que el número de columnas de A coincide con el número de filas de B; es decir, A es una matriz m ´ p y B una matriz p ´ n. Entonces el producto AB es la matriz m ´ n cuya entrada ij se obtiene multiplicando la fila i de A por la columna j de B. Esto es,
Ejemplo:
1.
2.
· Producto por un escalar El producto de un escalar k por la matriz A, escrito k·A o simplemente kA, es la matriz obtenida multiplicando cada entrada de A por k :
Ejemplo:
Entonces:
EJEMPLO 1 using System; using System.Collections.Generic; using System.Text; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { int i, longitud, nn; double[] numeros; double[] b; double[] suma; Console.WriteLine("ingrese la longitud del vector a" ); longitud = int.Parse(Console.ReadLine()); numeros = new double[longitud]; suma = new double[longitud]; for (i = 0; i < longitud; i++) { Console.WriteLine("ingrese la entrada{0}", i); numeros[i] = double.Parse(Console.ReadLine()); } for (i = 0; i < longitud; i++) Console.Write("{0} ", numeros[i]); Console.ReadLine(); Console.WriteLine("ingrese la longitud del vector b" ); nn = int.Parse(Console.ReadLine()); b = new double[nn]; for (i = 0; i < nn; i++) { Console.WriteLine("ingrese la entrada{0}", i); b[i] = double.Parse(Console.ReadLine()); } for (i = 0; i < nn; i++) Console.Write("{0} ", b[i]); Console.WriteLine(); Console.WriteLine("el vector suma es"); for (i = 0; i < nn; i++) { suma[i] = numeros[i] + b[i]; Console.Write("{0} ", suma[i]); } Console.ReadLine(); } } }
EJEMPLO 2 using System; using System.Collections.Generic; using System.Text; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { int i, longitud, nn; double[] numeros; double[] b; double[] suma; Console.WriteLine("ingrese la longitud del vector a" ); longitud = int.Parse(Console.ReadLine()); numeros = new double[longitud]; suma = new double[longitud]; for (i = 0; i < longitud; i++) { Console.WriteLine("ingrese la entrada{0}", i); numeros[i] = double.Parse(Console.ReadLine()); } for (i = 0; i < longitud; i++) Console.Write("{0} ", numeros[i]); Console.ReadLine(); Console.WriteLine("ingrese la longitud del vector b" ); nn = int.Parse(Console.ReadLine()); b = new double[nn]; for (i = 0; i < nn; i++) { Console.WriteLine("ingrese la entrada{0}", i); b[i] = double.Parse(Console.ReadLine()); } for (i = 0; i < nn; i++) Console.Write("{0} ", b[i]); Console.WriteLine(); Console.WriteLine("el vector suma es"); for (i = 0; i < nn; i++) { suma[i] = numeros[i] * b[i]; Console.Write("{0} ", suma[i]); } Console.ReadLine(); } } }
METODO DE LA MATRIZ: SUMA Y MULTIPLICACION EJEMPLO 1: SUMA using System; using System.Collections.Generic; using System.Text; namespace ConsoleApplication1 { class Program { static void Main(string[] args) { int i,j,n,m; double[,] matriz; double[,] matriz1; double[,] suma; Console.WriteLine("ingrese la dimension de la matriz" ); Console.WriteLine("ingrese el numero de filas"); n = int.Parse(Console.ReadLine()); Console.WriteLine("ingrese el numero de columna"); m = int.Parse(Console.ReadLine()); matriz = new double[n, m]; matriz1 = new double[n, m]; // // for (i = 0; i < n; i++) for (i = 0; i < n; i++) { Console.WriteLine("ingrese la fila {0}", i); for (j = 0; j < m; j++) { matriz[i, j] = double.Parse(Console.ReadLine()); } } for (i = 0; i < n; i++) { Console.WriteLine("ingrese la fila {0}", i); for (j = 0; j < m; j++) { matriz1[i, j] = double.Parse(Console.ReadLine()); } } suma = new double[n, m]; for (i = 0; i < n; i++) { for (j = 0; j < m; j++) { suma [i,j] = matriz[i, j] + matriz1[i, j]; Console.Write("{0} ",suma[i,j]); } Console.WriteLine(); } } }
EJEMPLO 2:PRODUCTO using System; using System.Collections.Generic; using System.Text;
namespace ConsoleApplication1 { class Program { static void Main(string[] args) { int i,j,n1,n2,m1,m2,producto; double[,] matriz; double[,] matriz1;
double[,] multiplicacion; Console.WriteLine("ingrese la primera matriz"); Console.WriteLine("ingrese la dimension de la primera matriz" ); Console.WriteLine("ingrese el numero de filas"); n1 = int.Parse(Console.ReadLine()); Console.WriteLine("ingrese el numero de columna"); m1 = int.Parse(Console.ReadLine()); Console.WriteLine("ingrese la segunda matriz"); Console.WriteLine("ingrese la dimension de la segunda matriz" ); Console.WriteLine("ingrese el numero de filas"); n2 = int.Parse(Console.ReadLine()); Console.WriteLine("ingrese el numero de columna"); m2 = int.Parse(Console.ReadLine()); if (m1!=n2) Console.WriteLine("nose puede multiplicar" ); while
matriz = new double[n1, m1]; matriz1 = new double[n2, m2]; producto = new double[n1, m2];
// // for (i = 0; i < n; i++) for (i = 0; i < n1; i++) {
Console.WriteLine("ingrese la fila {0}", i); for (j = 0; j < n2; j++) { matriz[i, j] = double.Parse(Console.ReadLine()); } }
for (i = 0; i < n1; i++) { Console.WriteLine("ingrese la fila {0}", i); for (j = 0; j < n2; j++) { matriz1[i, j] = double.Parse(Console.ReadLine());
} }
multiplicacion = new double[n1, m1]; for (i = 0; i < n1; i++) { for (j = 0; j < m1; j++) {
multiplicacion [i,j] = matriz[i, j] * matriz1[i, j]; Console.Write("{0} ",multiplicacion[i,j]);
} Console.WriteLine(); } } } }
EJEMPLO 3: MATRIZ DESDE CONSOLA class Program { static double g(double [,]) { nombre= new double [n,m]; //declaracion de la variableç double[,] nombre ={{1,1,3},{5,7,4}}; double[,] nombre= new double[2,3]{{1,2,3},{5,7,4}};
}
static void Main(string[] args) { double[,] matriz ={ { 1, 1, 3 }, { 5, 7, 4 } }; int i, j,n,m; // i filas j columnas
Console.WriteLine("n"); n = int.Parse(Console.ReadLine()); Console.WriteLine(); Console.WriteLine("m"); m = int.Parse(Console.ReadLine()); Console.WriteLine();
for (i = 0; i < 2; i++) { for (j = 0; j < 3; j++) { Console.Write("{0}", matriz[i, j]); Console.Write("{0}", matriz[n, m]); } Console.WriteLine(""); } Console.ReadLine(); } } }
METODO DE FACTORIZACION LU DE UNA MATRIZ En este método se descompone la matriz A en dos matrices L (low) y U (up). A = LU La factorización es útil para la resolución de sistemas de ecuaciones. Sea el sistema de ecuaciones representado por AX = C. Sustituyendo A por LU, nos queda LUX = C. Calculando el producto UX = Y, y sustituyendo en LUX = C nos queda LY = C. De aquí podemos calcular el valor de Y y entonces sustituyéndolo en UX = Y podemos calcular X. Toda matriz cuadrada, cuyos menores principales son todos no nulos, puede descomponerse en la forma A = LU.
METODO DE FACTORIZACIÓN DE CHOLESKY Una matriz A es simétrica si A t=A. Decimos que A es positiva definida si xtAx>0 para todo x
0. Se puede demostrar que
una matriz simétrica es positiva definida si y solo si todos sus valores propios son positivos. También se puede demostrar que existe una matriz triangular inferior L tal que A = L Lt lo cual se conoce como la factorización de Cholesky de A. De hecho las entradas de L=(lij) de pueden calcular mediante las fórmulas: 1. Para i=1,2,…,n
a. b. Para j=1,2,…,i-
a. Estas fórmulas se obtienen multiplicando las filas de L por las columnas de Lt e igualando a las entradas correspondientes de A. Un conteo operacional de estas fórmulas muestra que el total de operaciones es aproximadamente (1/6)n3, i.e., la mitad que en eliminación Gaussiana básico.
