/**
*
* @author Juan Manuel Carballo
*/
public class Main
{
private final static double toleranciaError = 0.01;
private final static int numeroEcuaciones = 3;
/**
* @param args the command line arguments
*/
public static void main(String [] args)
{
double[][] matrizEcuaciones = {{70, 1, 0}, {60, -1, 1}, {40, 0, -1}};
double[] matrizResultados = {636, 518, 307};
double[] solucionTemporal = new double[numeroEcuaciones];
for (int i = 0; i < numeroEcuaciones; i++) {
solucionTemporal[i] = Math.abs(matrizEcuaciones[i][1]);
for (int j = 1; j solucionTemporal[i]) {
solucionTemporal[i] = Math.abs(matrizEcuaciones[i][j]);
}
}
}
//llama a la funcion eliminar()
int error = eliminar(matrizEcuaciones, solucionTemporal, matrizResultados);
if(error != -1){
substitucion(matrizEcuaciones, matrizResultados);
}
}
private static int eliminar(double[][] matrizEcuaciones, double[] solucionTemporal, double[] matrizResultados)
{
for (int k = 0; k < numeroEcuaciones - 1; k++) {
//llama a la funcion pivoteo()
pivoteo(matrizEcuaciones, matrizResultados, solucionTemporal, k);
//Verifica la tolerancia del error
// if(Math.abs(matrizEcuaciones[k][k]) / solucionTemporal[k] < toleranciaError){
// return -1;
// }
for (int i = k + 1; i < numeroEcuaciones; i++) {
double factor = matrizEcuaciones[i][k] / matrizEcuaciones[k][k];
for (int j = k; j < numeroEcuaciones; j++) {
matrizEcuaciones[i][j] -= factor * matrizEcuaciones[k][j];
}
matrizResultados[i] -= factor * matrizResultados[k];
imprimir(matrizEcuaciones, matrizResultados);
}
//Verifica la tolerancia del error
// if(Math.abs(matrizEcuaciones[k][k]) / solucionTemporal[k] < toleranciaError){
// return -1;
// }else{
// return 0;
// }
}
return 0;
}
private static void pivoteo(double[][] matrizEcuaciones, double[] matrizResultados, double[] solucionTemporal, int K)
{
int p = K;
double big = Math.abs(matrizEcuaciones[K][K] / solucionTemporal[K]);
double dummy;
for(int ii = K + 1; ii big){
big = dummy;
p = ii;
}
}
if(p != K){
for(int jj = 0; jj = 0; i--){
double suma = matrizResultados[i];
for(int j = i + 1; j = 0; i--){
System.out.println("Resultado X" + (i+1) + ": " + matriz[i]);
}
}
private static void imprimir(double[][] matrizEcuaciones, double[] matrizResultados)
{
System.out.println();
System.out.println("Matriz Nueva");
for (int i = 0; i < numeroEcuaciones; i++) {
for (int j = 0; j < numeroEcuaciones; j++) {
System.out.print(matrizEcuaciones[i][j] + "\t");
}
System.out.print("||\t" + matrizResultados[i]);
System.out.println();
}
}
}

public class Main
{
public static void main(String[] args)
{
Scanner teclado = new Scanner(System.in);
int [] x = {23, 44, 12, -19, 98, 102, 56, 36, 21, 33, 67};
Main hola = new Main();
//ordena la matriz de numeros
hola.ordenar(x);
//Imprime la matriz de numeros
hola.imprimir(x);
int busqueda = -19;
hola.busquedaBinaria(x, busqueda);
}
public void ordenar(int [] x)
{
for(int i = 0; i < x.length; i++){
int menor = this.inferior(x, i);
int temp = x[i];
x[i] = x[menor];
x[menor] = temp;
}
}
private int inferior(int [] x, int inf)
{
int menor = inf;
for(int i = inf; i < x.length; i++){
if(x[i] < x[menor]){
menor = i;
}
}
return menor;
}
public void busquedaBinaria(int [] x, int busqueda)
{
int indiceInferior = 0;
int indiceSuperior = x.length - 1;
int indiceMedio = 0;
while(indiceInferior <= indiceSuperior){
indiceMedio = (indiceInferior + indiceSuperior) / 2;
if(busqueda > x[indiceMedio]){
indiceInferior = indiceMedio + 1;
}else if(busqueda < x[indiceMedio]){
indiceSuperior = indiceMedio - 1; }else{ break; } } if(indiceInferior > indiceSuperior){
System.out.println(busqueda + " no encontrado");
}else{
System.out.println(busqueda + " encontrado");
}
}
public void imprimir(int [] x){
for (int i = 0; i < x.length; i++) {
System.out.println("Posicion " + i + ", Valor: " + x[i]);
}
}
}


Las sentencias de control permiten tomar decisiones y realizar un proceso repetidas veces. Toda sentencia entre <> indica que es opcional

Sentencia if.

If(condicion){

Sentencia1

}<else{

Sentencia2

}>

Donde condición es una expresión boolena y se ejecuta de la siguiente manera:

Si condición es verdadera se ejecuta Sentencia1

Si condición es false se ejecuta Sentencia2

Sentancia Switch

Esta permite ejecutar una de varias acciones, en función del valor de una expresión. Es una sentencia especial para decisiones múltiples.

Switch(expresion){

Case expresión-constante-1:

Sentencias;

Break;

<Case expresión-constante-2:>

<Sentencias;>

<Break;>

<Case expresión-constante-2:>

<Sentencias;>

<Break;>

}

Donde expresión es una expresión de tipo entero, enumerado, o string y expresión-constante es del mismo tipo que expresión. La sentencia switch evalúa la expresión entre paréntesis y  compara su valor con las constantes de cada case, si resulta verdadera la comparación ejecuta las sentencias hasta llegar al break.

Sentencia While

La sentencia while ejecuta una sentencia cero o mas veces en función de la condición boolena.por ejemplo:

while(condicion){

sentencias

}

Se ejecuta de la siguiente manera:

1. Se evalúa la condición y se obtiene un resultado verdadero o falso
2. Si el resultado es falso sale de bucle y no se ejecutan las sentencias
3. Si es verdadero continua su ejecución dentro del bucle y se repite desde el punto 1

Sentencia do…while

La sentencia do…while ejecuta una sentencia y después comprueba su expresión booleana. Por ejemplo

do{

sentencias

}while(condición);

Se ejecuta de la siguiente manera:

1. Se ejecuta el bloque
2. Se evalua la expresión y se obtiene un resultado verdadero o falso
3. Si el resultado es falso pasa el control a la siguiente sentencia del programa
4. Si es verdadero el proceso se repite desde el punto 1

Sentencia for

La sentencia for permite ejecutar una sentencia simple o compuesta, repetidamente un número de veces conocido. Sintaxis:

for(<v1= e1<, v2 = e2>>; <condición>;<progresión-condicion>){

sentencias

}

• v1, v2…, representan variables de control que serán iniciadas con los valores de las expresiones e1, e2,…,
• condición es una expresión boleana que si se omite, se supone verdadera
• progresión condición es una o mas expresiones separadas por comas cuyos valores evolucionan en el sentido de que se cumpla la condición para finalizar la ejecución de la sentencia for

La ejecución de la sentencia for sucede de la siguiente forma:

1. se inicializan las variables v1, v2
2. se evalua la condición:
   1. si el resultado es verdadero, se ejecuta el bloque de sentencias, se evalúa la expresión que da lugar a la progresión de la condición y se vuelve al punto 2
   2. si el resultado es falso, la ejecución de la sentencia for se da por finalizada y se pasa el control a la siguiente sentencia del programa

Sentencia foreach

Esta sentencia repite un grupo de sentencias para cada elemento de una matriz o de una colección. Por ejemplo:

namespace CursoCSharp004
{
class Program
{
static void Main(string[] args)
{
int[] datos = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
foreach (int item in datos) {
Console.WriteLine(item);
}
Console.ReadKey();
}
}

}

Algunas consideraciones a tomar en cuenta en el ejemplo declaramos item como int, por que cada iteracion del ciclo que hagamos el compilador hace una asignacion a item, y ejecuta las sentencias del for sabiendo que item es una variable con la que podemos contar especificamente por cada elemento del ciclo.

Sentencias try…catch

Cuando durante la ejecucion de un programa se produce un error que impide su continuacion C# lanza una excepción  que hace que se visualice un mensaje acerca de lo ocurrido y se detenga la ejecucion. Cuando esto ocurra, si no deseamos que la ejecucion del programa se detenga, habra que utilizar try para poner en alerta al programa acerca del código que puede lanzar una excepcion y utilizar catch para capturar y manejar cada excepción que se lance. Por ejemplo, si ejecutamos el siguiente codigo nos lanzara una excepción del tipo System.DivideByZeroException

namespace CursoCSharp004
{
class Program
{
static void Main(string[] args)
{
int dato = 0, dato2 = 0, dato3 = 0;
System.Console.WriteLine("la aplicacion se inicia");
dato++;
dato3 = dato / dato2;
System.Console.WriteLine("el valor de la división es:" + dato3);
}
}
}

Ahora modifiquemos la aplicación con la intención de capturar la excepcion lanzada:

namespace CursoCSharp004
{
class Program
{
static void Main(string[] args)
{
int dato = 0, dato2 = 0, dato3 = 0;
System.Console.WriteLine("la aplicacion se inicia");
try {
dato++;
dato3 = dato / dato2;
dato2++;
} catch (System.DivideByZeroException e) {
System.Console.WriteLine("Error: " + e.Message);
}
System.Console.WriteLine("dato: " + dato + " dato 2: " + dato2 + " dato 3: " + dato3);
System.Console.ReadKey();
}
}
}

Ahora si la sentencia donde nos marcaba el error, lanzara una excepción del tipo DivideByZeroException, que sera capturada por la sentencia catch. La ejecucion del programa se reanudara a partir de la primera sentencia perteneciente al bloque catch y continuara hasta el final del programa.

Cuando un procedimento lanza una excepcion el sistema es responsable de encontrar a alguien que le atrape con e objetivo de manipularla. El conjunto de esos alguien es el conjunto de métodos especificados en la pila de llamadas hasta que ocurrio el error.

Si al no encontrar en la pila de llamadas un bloque try…catch que captura ese error, el programa terminaria abruptamente.

y aqui esta la descarga por mediafire –>Descarga

El siguiente pedazo de código es un ejemplo típico de cómo se utilizan las colecciones en java

List objetos = new ArrayList();
objetos.add(new String("hola"));
objetos.add(new String("mundo"));
for(int i = 0; i < objetos.size(); i++)
{
String temp = (String) objetos.get (i);
System.out.println (temp);
}

Si al código anterior hubiéramos metido una línea extra como la siguiente:

objetos.add (new Integer(12));

Hubiera dado un error en tiempo de ejecución en concreto una excepción de tipo java.lang.ClassCastException.

Pero bueno veamos la sintaxis de cómo se declara un tipo genérico en java:

List <String> conjuntoCadenas = new ArrayList <String>();

De esta manera estaremos le estaremos diciendo al compilador que estaremos creando una lista que almacena puros String en caso de que tratemos de almacenar otro tipo de objeto no dará un error en tiempo de compilación.

Los genéricos ayudaron a crear una comprobación de tipo en listas y mapas en tiempo de compilación, anteriormente esto no era posible y en grandes proyectos el programador tenía que estar recordando que es lo que había metido en cada list o map haciendo difícil el encontrar los errores de programación.

Otra cosa que podemos hacer en con los tipos parametrizados o genéricos es crear nuestras propias clases. Por ejemplo:

Supongamos que tenemos la siguiente clase

public class Box
{
private Object object;
public void add(Object object)
{
this.object = object;
}
public object get()
{
return this.object;
}
}

De nuevo tenemos el mismo problema, si a la hora de obtener un objeto se requeriría un casting y y si tenemos un casting de distintos tipos no arrojaría un error en tiempo de ejecución. Pero si tenemos una clase como la siguiente:

public class Box<T>
{
private T t;
public void add(T t)
{
this.t = t;
}
public T get()
{
return t;
}
}

Veremos que hemos reemplazado los object por un tipo parametrizado. Esto lo podemos pensar que cuando instanciemos la clase:

Box <String> boxes = new Box<String> ();

Todos los tipos parametrizados se reemplazaran por la Clase que está entre los corchetes angulares.

Convenciones

Por convención los tipos parametrizados son letras solitarias mayúsculas, sin esta convención sería difícil leer el código y decir la diferencia entre una variable parametrizada y una clase ordinaria o un nombre de una interface.

E – Elemento (Usado extensivamente en las colecciones en java)

K – Key

N – Number

T – Type

V – Value

S, U, V etc. – 2nd, 3rd, 4th types

Tipos Genéricos en métodos

Veamos el siguiente código

public class Box<T>
{
private T t;
public void add(T t) {
this.t = t;
}
public T get()
{
return t;
}
public <U> void inspeccion (U u)
{
System.out.println("T: " + t.getClass().getName());
System.out.println("U: " + u.getClass().getName());
}
public static void main(String[] args) {
Box<Integer> integerBox = new Box<Integer>();
integerBox.add(new Integer(10));
integerBox.inspeccion("una cadena de texto");
}
}

Como vemos hemos añadido un método genérico llamado inspeccion que define un tipo parametrizado llamado U, por defecto este método acepta un objeto de cualquier tipo y lo imprime en pantalla.

Pero habrá algunas ocasiones en que queramos limitar los tipos parametrizados, por ejemplo una tendremos un método que acepte solamente instancias de Number o sus subclases.

Para declarar un tipo genérico limitado usamos la palabra extends seguida de la clase sobre la que queremos limitar. Por ejemplo:

public <U extends Number> void inspect(U u)
{
System.out.println("T: " + t.getClass().getName());
System.out.println("U: " + u.getClass().getName());
}
public static void main(String[] args)
{
Box<Integer> integerBox = new Box<Integer>();
integerBox.add(new Integer(10));
integerBox.inspect("some text"); //Marcara error en tiempo de compilación
}

Para especificar interfaces adicionales se debe usar el carácter &. Por ejemplo:

<U extends Number & MyInterface>

Bueno espero que les haya gustado, eso es todo por el momento. Gracias



Literales

Una literal en C# puede ser: un entero, un real, un valor booleano, un carácter, una cadena de caracteres, una fecha y hora, y u null.

El enguaje C# permite especificar un literal entero en base 10 y 16.

256
0×100

Un literal real esta formado por una parte entera, seguido por un punto decimal, y una parte fraccionaria. También se permite a notación científica en cuyo caso se añade al valor una e o E, seguida por un exponente positivo o negativo.

-34.45
156e-8

Una constante real tiene siempre tipo doublé, a no ser que se añada a la misma una f o F, en cuyo caso será de tipo float, o m o M, en cuyo caso es de tipo decimal

Los literales de un solo carácter son de tipo char. Este tipo de literales está formado por un único carácter encerrado en comillas simples. Una secuencia de escape es considerada como un único carácter

‘ ’         espacio en blanco
‘f’         letra minúscula f
‘\n’      retorno de carro mas avance de línea
‘\u0007’         pitido

Una literal de cadena de caracteres es una secuencia de caracteres encerrados entre comillas dobles. Las cadenas de caracteres en C# son objetos de tipo string(Clase System.String), Esto es, cada vez que en un programa se utilice una literal de caracteres, C# crea de forma automática un objeto String con el valor de la literal

Los literales fecha y hora son de tipo DateTime. Este tipo de literales esta formado por por una fecha(mes dia, año separados por / o -) y una hora(horas minutos y segundos, separados por dos puntos mas AM o PM si el formato es en 12 horas). Por ejemplo:

DateTime fechaHora = new DateTime(2010, 02, 19, 17, 30, 15);
System.Console.WriteLine(fechaHora);

Identificadores

Los identificadores son nombres dados a tipos, literales, variables, clases, interfaces, métodos, espacios de nombre y sentencias de un programa. La sintaxis para formar un identificador es la siguiente:

Tipo nombreIdentificador;

Tipo nombreIdentificador = literal;

Tipo nombreIdentificador = literal, (nombreSegundoIdentificador = literal…);

Donde los paréntesis son elementos opcionales.

Palabra clave

Las palabras clave son identificadores predefinidos que tienen un significado especial para el compilador C#. por lo tanto, un identificador definido por el usuario no pude tener el mismo nombre que una palabra clave.

Declaración de constantes

Una constante no puede cambiar su valor en tiempo de ejecución y se hace de la siguiente forma:

Const tipo identificador = constante;

Variables

Una variable representa un espacio de memoria para almacenar un valor de un tipo determinado.

El ámbito de la variable puede ser de tipo local(a nivel de método), de tipo clase(a nivel de una clase, atributo de una clase)

Operadores

Los operadores son símbolos que indican como son manipulados los datos. Se pueden clasificar en los siguientes grupos: aritméticos, relacionales, lógicos, unitarios, a nivel de bit, de asignación y operador condicional.

Aritméticos: +(suma), -(resta) *(multiplicación), /(división), %(modulo).

Relación: <(menor que), >(mayor que), <=(menor o igual que), >=(mayor o igual que), !=(distinto de), ==(igual que).

Lógicos: &&(AND), ||(OR), !(NOT), ^(XOR).

Nivel de Bits: &(AND), |(OR), ^(XOR), <<(Desplazamiento Izquierda), >>(Desplazamiento Derecha).

Asignación: ++(incremento), –(decremento), =(asignación simple), *= (multiplicación mas asignación), /=(división mas asignación), %=(modulo mas asignación), +=(suma mas asignación), -=(resta mas asignación).

Operador condicional

El operador condicional, también llamado operador ternario, se utiliza en expresiones condicionales que tienen la siguiente forma:

Operando1 ? operando2 : operando3

la expresión operando1 debe ser una expresión booleana, si la evaluación del operando1 es true, el resultado de la operación condicional es operando2, de caso contrario el resultado de la operación condicional es operando3. Por ejemplo:

double a = 10.2, b = 20.5;
double mayor = (a > b) ? a : b;

Comentarios

Cuando una línea de programa o parte de ella, va procedida de // C# interpreta esa línea como un comentario y no ejecuta acción alguna sobre ella. También, una o mas líneas encerradas por los caracteres /* y */ se considerara un comentario. Por ejemplo:
/*Este es un
*comentario de 2 líneas
*/
suma = 0; //Se inicializa a variable suma a con el valor cero

Tipos

Los tipos en C# se clasifican en: tipos valor y tipos referencia, una variable de tipo valor almacena directamente un valor (datos en general), mientras que una variable de tipo referencia, lo que permite almacenar es una referencia a un objeto(posición de memoria donde está el objeto). Por ejemplo:
int nombreVariable = 13; //Almacena un entero con valor de 13
string cadena = “Hola”; /*cadena permite almacenar una referencia a un objeto de tipo string*/
La siguiente tabla resume los siguientes tipos intrínsecos de C#

Todos los tipos primitivos expuestos tienen una Estructura de datos asociada, por ejemplo, el tipo double es un alias de System.Double, char es un alias del tipo System.Char, por lo tanto un dato de un primitivo es un objeto

Tipos Enumerados

Los tipos enumerados son tipos definidos pr el usuario. Para crearlos se utiliza la palabra enum. Por Ejemplo:
class Test
{
enum dia
{
lunes,
martes,
miercoles,
jueves,
viernes,
sábado,
domingo
};
}
Los valores que se forman en un tipo enumerado se corresponden con las constantes enteras 0, 1, 2, etc. Segun esto, en el ejemplo anterior lunes se corresponde con 0, martes con 1, etc. Análogamente al tipo dias, puede definir cualquier otro tipo enumerado de datos. Esto, en algunas ocaciones, puede ayudar a escribir un código más legible

Comprobación de tipos

Cuando C# tiene que evaluar una expresión en la que intervienen operandos de diferentes tipos, primero convierte, solo para realizar las operaciones solicitadas, los valores de los operandos al tipo del operador cuya precisión sea más alta. Cuando se trate de una asignación, convierte el valor de la derecha al tipo de la variable de la izquierda siempre que no haya perdida de información; en otro caso, C# exige que la conversión se realice explícitamente.

Al principio iré empezando desde lo más básico, tratare no extenderme demasiado para los que tienen un nivel medio, pero tampoco quiero dejar de lado lo básico para los que apenas están empezando a programar.

Quisiera decir también a todo aquel que quiera seguir el curso puede utilizar Visual C# Express Edition que lo puede conseguir desde este enlace

Mi Primer Programa

Una vez instalado el Visual Studio, lo abrimos y le damos click a Archivo–>Nuevo–>Proyecto y nos desplegara una ventana como la que sigue

Como veremos en la Imagen he remarcado dos opciones, la primera es una aplicación de Windows Form, para crear programas con ventanas y la segunda opción es una aplicación de consola, para crear una aplicación clásica al estilo MS-DOS. Para esta parte del curso utilizaremos la típica aplicación de consola.

Una vez creado el proyecto tendremos algo por el estilo así:

Ahora Si estaremos listos para crear nuestra primera aplicación agrega las siguientes líneas como se muestra:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CursoCSharp001
{
class Program
{
static void Main(string[] args)
{
//Despliega en pantalla el texto Hola Mundo
System.Console.WriteLine("Hola Mundo");
//Lee un caracter desde el teclado
System.Console.ReadKey();
}
}
}

Y el resultado es el siguiente:

Bueno eso es todo por hoy gracias por leerme, hasta la proxima

y el enlace hacia la descarga
http://www.mediafire.com/?myjm3yyljjy

Para usar la clase StringTokenizer se debe añadir la siguiente sentencia import:

import java.util.*;

O también la siguiente sentencia

import java.util.StringTokenizer;

Los constructores

Cuando creamos un objeto de la clase StringTokenizer, se le pasa como parámetro una cadena String, para dividir la cadena en subStrings con el delimitador por defecto que es un carácter en blanco: por ejemplo:

String cadena = “una cadena de algunas palabras”;
StringTokenizer token = new StringTokenizer(cadena);

O podemos utilizar alguno de sus constructores sobrecargados para dividir un string por medio de otro carácter. Por ejemplo:

String cadena = “una:cadena:de:algunas:palabras:de:largo”;

StringTokenizer token = new StringTokenizer(cadena, “:”);

Obtención de los Tokens

La clase StringTokenizer implementa el interface Enumeration, por tanto define las funciones nextElement y hasMoreElements. Pero para el programador es más sencillo recordar nextToken y hasMoreTokens. Por ejemplo:

String cadena = “Esta es una cadena de unas cuantas palabras”;
StringTokenizer token = new StringTokenizer(cadena);
do{
System.out.println(token.nextToken());
}while(token.hasMoreTokens());