using System;

public class Base { public void MetodoNormal () {

Console.WriteLine (”Soy Base.MetodoNormal ()”);} public virtual void MetodoVirtual () { Console.WriteLine (”Soy Base.MetodoVirtual ()”);}

}

public class Heredada : Base {

new public void MetodoNormal () {

Console.WriteLine (”Soy Heredada.MetodoNormal ()”);

}

public override void MetodoVirtual () {

Console.WriteLine (”Soy Heredada.MetodoVirtual ()”);

}

static void Main () {

Heredada claseHeredada = new Heredada ();

Base claseBase = claseHeredada;

claseBase.MetodoNormal ();

claseHeredada.MetodoNormal ();

claseBase.MetodoVirtual ();

claseHeredada.MetodoVirtual (); 

}

}

Si lo ejecutamos obtenemos lo siguiente:

Soy Base.MetodoNormal ()

Soy Heredada.MetodoNormal ()

Soy Heredada.MetodoVirtual ()

Soy Heredada.MetodoVirtual ()

Nótese como algo extraño sucede en la tercera línea. Mientras que en el código fuente la llamada se hace a la clase Base, el resultado es el de la clase heredada, cosa que no ocurre con el “método normal”. La culpa de este comportamiento la tiene la combinación de las palabras clave virtual y override, que declaran y redefinen respectivamente a los métodos virtuales. En este caso el método escogido no se corres­ponde con el que observa en el momen­to de la compilación, sino en el momento de la ejecución. Debemos fijarnos en que la definición de la instancia de la clase base se hace en términos de la clase heredada al comienzo del método principal. Vemos entonces como override hace un papel análogo a new, solo que se ocupa de métodos virtuales, que pueden variar la funcionalidad incluso de las clases bases.  Si la declaración de las instancias las cambia­mos por las siguientes:

Base claseBase = new Base ();

Heredada claseHeredada = new Heredada ();

Todo funcionará sin diferencias. Los métodos virtuales se comportarán como los demás. Lo divertido sucede cuando volvemos a considerar más de dos clases. ¿Qué ocurrirá en el siguiente ejemplo? using System;class A {public virtual void Metodo () {

Console.WriteLine (”Yo soy A.Metodo ()”);

}

}

class B : A {

public override void Metodo () {

Console.WriteLine (”Yo soy B.Metodo ()”);

}

}

class C : B {

new public virtual void Metodo () {

Console.WriteLine (”Yo soy C.Metodo ()”);

}

}

class D : C {

public override void Metodo () {

Console.WriteLine (”Yo soy D.Metodo ()”);

}

static void Main () {

D d = new D ();

A a = d;

B b = d;

C c = d;

a.Metodo ();

b.Metodo ();

c.Metodo ();

d.Metodo ();

} 

}

Hemos usado todas las combinaciones posibles. Primero declaramos un método vir­tual, luego lo redefinimos con override. En C se usa new y se vuelve a emplear virtual, y en D se cierra el ciclo y se utiliza de nuevo overri­de. A continuación creamos una instancia de la clase más baja en el nivel de herencia, y el resto de las instancias las hacemos depender de ella. Como siempre, termina­mos llamando a todos los métodos. ¿Qué ocurrirá? Si hemos seguido el razonamiento hasta aquí, encontraremos rápidamente la respuesta: las clases que contengan méto­dos virtuales perderán su funcionalidad y las demás no. El problema está en a.Metodo() ya que tenemos dos opciones, o bien se queda con el método de B o bien salta hasta D que es la instancia activa. El resultado final es el siguiente, esto es, la clase que se ocupa de la implementación es la más cercana en el árbol de herencias:

Yo soy B.Metodo ( )

Yo soy B.Metodo ( )

Yo soy D.Metodo ( )

Yo soy D.Metodo ( )

using System;

public class Base {

public static void MetodoBase () {

Console.WriteLine (”Yo soy Base.MetodoBase ()”);

}

}

public class Heredada : Base {

public static void Main () {

MetodoBase ();

}

new public static void MetodoBase () {

Console.WriteLine (”Yo soy Heredada.MetodoBase ()”);

}

}

Tenemos dos clases, donde una hereda de la otra. La segunda además redefine el método MetodoBase() gracias al modifica­dor new. Al ejecutar el programa, se vería lo siguiente:

Yo soy Heredada .MetodoBase ( )

lo que verifica que la redefinición ha sido un éxito. Si eliminamos el parámetro new el pro­grama seguiría compilando, pero obtendría­mos una advertencia:

New. cs ( 18 ) warning CS0108 :The keyword new is required on‘ Heredada . MetodoBas e ‘ because it hides inherited member‘ Base .MetodoBase ‘ Compilation succeeded - 1 warning(s) s ) 

El compilador nos ayuda a no ocultar métodos sin querer. Igualmente, si la clase Base no tuviera ninguna definición para MetodoBase(), el compilador también nos advertiría de que no estamos redefiniendo nada.  Todo esto se puede complicar un poco más. Supongamos que tenemos una clase B que hereda de A, y una clase C que here­da de B. Pues bien, es posible redefinir un método de A en B, sin que C note el cambio, teniendo lo siguiente: 

using System;

public class A {

public static void MetodoBase () {

Console.WriteLine (“Yo soy A.MetodoBase ()”); }

}

public class B : A {new prívate static void MetodoBase () {

Console.WriteLine (”Yo soy B.MetodoBase ()”);

public class C : B {

static void Main () {

MetodoBase ();}}

}

}

El método C imprimiría por pantalla “Yo soy A.MetodoBase ()” gracias a que en B hemos marcado la redefinición como priva­da, lo que la restringe a dicha clase. Si cam­biamos prívate por public, o hacemos la lla­mada dentro de B conseguiremos “Yo soy B.MetodoBase ()”. Tenemos una doble herencia anidada de clases en la que la ocul­tación de métodos es solamente parcial.

Continúa en Métodos Virtuales

using System;

class Parametros {

static void Main () {

int[] parametros = {l, 2, 3, 4, 5};

CuentaArgumentos (parametros);

CuentaArgumentos (1, 2, 3);

CuentaArgumentos ();

} 

static void CuentaArgumentos (params int[] parametros) {

Console.Write (”He recibido {O} argumentos:”, parametros.Length);

for (int i = O; i < parametros.Length; i++)

Console.Write (” {0}”, parametros[i]);

Console.WriteLine (); 

}

}

En el programa hemos definido un método llamado CuentaArgumentos al que le hemos añadido params en su definición. Esto nos permite invocarlo de tres maneras distintas en el método principal. Da igual si lo llamamos con un array como argumento, una lista de números o sencillamente nada. El método será capaz de controlar adecua­damente cada situación:He recibido 5 argumentos: 1 2 3 4 5 He recibido 3 argumentos: 1 2 3

He recibido O argumentos:

Cabe preguntarse qué pasaría si eliminá­ramos params de la definición, puesto que formalmente seguiría siendo correcta. El resultado es el esperado, tal como se muestra a continuación:

Params.cs (8) error CS1501: No overload for method ‘CuentaArgumentos’ takes ‘3′ arguments

Params.cs(8) error CS8006: Could not find any applicable functíon for this argument list

Params.cs(9) error CS1501: No overload for method ‘CuentaArgumentos’ takes ‘O’ arguments

Params.cs(9) error CS8006: Could not find any applicable function for this argument list

Compilation failed: 4 error(s), 0 warnings

Esto significa que puede que la definición del método sea válida, pero sus invocacio­nes no lo son.

Supongamos que necesitamos una función que divida en dos una palabra y devuelva los dos trozos resultantes. Pues bien, entonces haríamos lo que muestra en el siguiente código:

using System;

class Parametros {

static void Main () {

string izquierda, derecha;

string cadena = “Me van a cortar por la mitad”;

Console.WriteLine (”Cadena original = ‘{0}’”, cadena);

Divide (cadena, out izquierda, out derecha);

Console.WriteLine (”Primera parte = ‘{0}’”, izquierda);

Console.WriteLine (”Segunda parte = ‘{0}’”, derecha);

}

static void Divide (string cadena, out string izquierda, out string derecha) { izquierda = cadena.Substring (O, cadena.Length / 2);derecha = cadena.Substring (cadena.Length / 2);

}

}

Al ejecutarlo, daría el siguiente resultado por pantalla:  Cadena original = ‘Me van a cortar por la mitad’Primera parte = ‘Me van a corta’

Segunda parte = ‘r por la mitad’

El programa hace uso del método Substring, miembro de System.String que nos permite extraer fácilmente subconjun­tos de cadenas de texto. Como vemos, pese a que las cadenas izquierda y derecha no estaban inicializadas, el compilador no ha puesto ningún problema a que fuera el método Divide O el que realizará dicha asig­nación.

Si en lugar de out, hubiéramos emplea­do ref, habríamos obtenido el siguiente error de compilación: 

Divide.cs(10) error CS0165: Use of unassigned local variable ‘izquierda’ Divide .cs (13) error CS0165: Use of unassigned local variable ‘derecha’ Compilation f ailed: 2 error (s ) , O warnings

using System;class Parametros {

static void Main () {

int a = 2;

int b = 3;

int c = Suma (a, b);

Console.WriteLine (”{0} + {1} = {2}”, a, b, c);

}

static int Suma (int a, int b) {

return a + b; 

}

}

Se escriben el nombre de las variables a la hora de invocar el método, y cuando se define, la precedemos por su tipo. Así, al ejecutar el códi­go obtenemos: 

2 + 3 = 5

Por valor

Por referencia

Parámetros exteriores

Parámetros múltiples

using System;

class Parametros {

static void Main () {

int a = 2;

int b = 3;

Console.WriteLine (”a = {O}, b = {1}”, a, b);

Intercambia (a, b);

Console.WriteLine (”a = {O}, b = {1}”, a, b);

}

static void Intercambia (int a, int b) {

int temp = a;

a = b;

b = temp;

}  }Sin embargo, nos veremos contrariados al comprobar que el programa no ejecuta ninguna acción:

a = 2, b = 3

a = 2, b = 3

Lo que ha pasado es que las operacio­nes que hemos realizado con las variables dentro del método Intercambia o no han tenido efecto. Pese a que nosotros hemos asignado nuevos valores que intercambiaban los antiguos, todo ha seguido como al principio. Lo que ocurre es que el método no altera el valor de las variables originales, ya que trabaja sobre una copia de éstas. Precisamente esto es lo que se solucio­na con la llamada por referencia de paráme­tros. Si cambiamos la defini­ción del método por:static void Intercambia (ref int a, ref int b) {

…

}

y si, por consiguiente, lo invocamos inclu­yendo las palabras clave ref.

Intercambia (ref a, ref b);

el resultado ahora sí es el deseado:

a = 2, b = 3

 a = 3, b = 2

Al introducir ref como prefijo de invoca­ción dé los parámetros, evitamos el efecto que comentábamos al principio. Por lo tanto, lo que hagamos sobre las variables en el método, afecta a las variables originales.

Modelos de tipo biológico.

Modelo dirigido a aplicación.

Las Redes Neuronales según su topología

Perceptrón

Hopfield

Kohonen

El aprendizaje, según Redes Neuronales Artificiales, se lleva a cabo de la siguiente manera:“Supongamos que tenemos patrones de entrada n-dimensionales.

1. Aleatorizar los pesos de las conexiones. Normalizar los pesos de las conexiones incidentes de cada   unidad de salida sobre la unidad: dividir cada conexión por la raíz cuadrada de la suma de los cuadrados de las conexiones de cada unidad. Normalizar igualmente los datos de entrada.
2. Aplicar un patrón de entrada.
3. Calcular alguna medida de similitud/disimilitud (producto interno, distancia euclídea o de Mahalanobis, etc.) entre las entradas y los pesos de las conexiones.
4. La unidad de salida con los pesos más parecidos al patrón de entrada es declarada ganadora. El vector de pesos de la unidad ganadora, se convierte en el centro de un grupo de vectores cercanos a él.
5. Modificar los pesos de los vectores de pesos Wj “cercanos” a Wc (distancia menor a D). De esta manera conseguimos que los vectores de pesos de la unidad ganadora y de su “vecindario” se parezcan cada vez más al patrón de entrada que hace ganar a esa unidad.
6. Repetir los pasos 1 a 4 con todos los patrones de entrada”.

Luego de que se lleva a cabo este aprendizaje, se puede usar esta red para clasificar los patrones de entradas en espacios n-dimensional. Una clase de patrones controlará una neurona específica, la cual representará el centro de la esfera n-dimensional, esta será la mas activa frente a los patrones mas parecidos a su vector de pesos.

Estas dan soluciones dinámicas, las cuales en ocasiones no son muy recomendables, sin embargo, Hopfield busca la manera de entregar con una memoria de este tipo que sea capaz de entregar soluciones estables. Permite que el estado de cada neurona sea actualizado un número indefinido de veces, sin importar el resto de las neuronas de la red.

Consiste en un conjunto de N elementos de proceso interconectadas, los operadores de entrada son también salida y los valores de activación son binarios, los cuales determinarán el estado del sistema. Se dice que cuando este valor de activación es constante es estable.

El aprendizaje de las redes de Hopfield se hace en base a la regla de Cooper-Hebb, que depende la conexión de los patrones que se desean aprender. Según Redes Neuronales Artificiales, el entrenamiento se realiza de la siguiente manera:

1. “Elegir un número de neuronas que cumpla el criterio del 15%.
2. Codificar los ítems que queremos memorizar de forma que los patrones para representarlos se parezcan lo menos posible entre sí, para aproximarnos a la condición de pseudo-ortogonalidad.

Calcular los pesos de las conexiones según la regla de Cooper-Hebb”.

En la siguiente figura, tomada de Redes Neuronales Artificiales, se presenta el “modelo de Red de Hopfield de 3 unidades”: