Clase Tec. Lerdo: 2015

viernes, 2 de octubre de 2015

Una Pila en C#

Lejos de usar el objeto predefinido <STACK> de C#, aquí presento la codificación de clase de una Pila en base al algoritmos del libro de Estructura de Datos de Cairo.




 class Pila{

//------------atributos de la pila
public String PILA;
public int TOPE;
public bool BANDERA;
public int MAX;
//--------------------------------

     public Pila(){

 }

public void Pila(int max){
this.MAX = max;
this.TOPE = 0;
this.BANDERA = false;
}//fin constructor

public void Pila_vacia( ){
if(this.TOPE == 0)
this.BANDERA = true;
else
this.BANDERA = false;
}//fin pila vacia

private void Pila_Llena( ){
if(this.TOPE == this.MAX)
this.BANDERA = true;
else
this.BANDERA = false;
} //fin de pila llena

public void Pone(char dato){
this.Pila_Llena();
if(this.BANDERA)
Console.WriteLine("Desbordamiento de Pila-Pila llena!");
else{
this.PILA[this.TOPE] = dato;
this.TOPE++;//5
}
}//fin de Pone

public void Quita(int dato){
this.Pila_vacia();
if(this.BANDERA)
Console.Writeline("Subdesbordamiento-Pila Vacía");
else{
dato = this.PILA[TOPE];
this.TOPE--;
}
}//fin de quita

 }//fin de la clase

Carrera 6K Tec Lerdo 2015

Producto Cruz de dos matrices de 2 X 2 en C#

Ejercicio interesante de programación de matrices en C#, es el producto cruz. En este ejemplo se considera, de manera directa solo el producto de dos matrices de 2 X 2 definidas dentro del código. El objetivo de este ejercicio es desarrollar la habilidad de programación de matrices en el lenguaje.



public void Main()
{

int[,] A = new int[2,2]{{1,2},{3,4}};
int[,] B = new int[2,2]{{3,2},{1,2}};
int[,] C = new int[2,2];

      for(int i = 0; i < 2; i++)
{

          for(int j = 0; j < 2; j++)
    {

if(i == 0 && j == 0){
C[i,j] = A[i,j]*B[i,j]+A[i,j+1]*B[i+1,j];
C[i,j+1] = A[i,j]*B[i,j+1]+A[i,j+1]*B[i+1,j+1];
break;
}else{
C[i,j] = A[i,j]*B[i-1,j]+A[i,j+1]*B[i,j];
C[i,j+1] = A[i,j]*B[i-1,j+1]+A[i,j+1]*B[i,j+1];

                      break;
  }

}
}

Console.Write(C[0,0]);
Console.Write(C[0,1]);
Console.WriteLine(C[1,0]);
Console.Write(C[1,1]);

Les recomiendo un compilador online en caso de no tener instalado el IDE de C#: http://volatileread.com/UtilityLibrary/SnippetCompiler

jueves, 17 de septiembre de 2015

Congreso Sofware Libre 2015

Asistan!

viernes, 4 de septiembre de 2015

Beep musical en C#.

Para hacer, de vez en cuando la programación un poco más divertida en nuestros ejercicios de consola, podemos poner pequeñas melodías con el comando beep.

Aquí un pequeño ejemplo con un ciclo for en donde el método sobrecargado beep tiene como parámetros la frecuencia a reproducir y la duración en mili-segundos.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace sonido_prueba
{
class Program
{
static void Main(string[] args)
{
for (int f = 37; f <= 3276; f+=200)
{
Console.Beep(f, 100);
Console.WriteLine("Reproduciendo la frecuencia {0} 1000 ms.....",f);
}
}
}
}

Nota: el proyecto es en consola.

#RT @rezzaca

martes, 1 de septiembre de 2015

Matrices de objetos.

Programar el siguiente ejemplo y realiza uno propio:

namespace CDCollection
{
    // Define a CD type.
    class CD
    {
        private string album;
        private string artist;
        private int rating;

        public string Album
        {
            get {return album;}
            set {album = value;} 
        }
        public string Artist
        {
            get {return artist;}
            set {artist = value;}
        }
        public int Rating
        { 
            get {return rating;} 
            set {rating = value;} 
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            // Create the array to store the CDs.
            CD[] cdLibrary = new CD[20];

            // Populate the CD library with CD objects.
            for (int i=0; i<20; i++)
            {
                cdLibrary[i] = new CD();
            }

            // Assign details to the first album.
            cdLibrary[0].Album = "See";
            cdLibrary[0].Artist = "The Sharp Band";
            cdLibrary[0].Rating = 10;
        }
    }
}

Fuente: https://msdn.microsoft.com/es-es/library/9ct4ey7x(v=vs.90).aspx

miércoles, 26 de agosto de 2015

Material Unidad 2. Recursividad. Estructura de Datos.

https://drive.google.com/file/d/0B-hQiDaqUNLwLTZuN1FlbU1zSlU/view?usp=sharing

martes, 18 de agosto de 2015

Links de artículos de IA.

http://www.xataka.com/robotica-e-ia/antes-de-hablar-de-inteligencia-artificial-que-es-la-inteligencia

https://vonneumannmachine.wordpress.com/

lunes, 17 de agosto de 2015

Temario de la unidad 1. Fundamentos de la IA.

1.- Fundamentos.

1.1 El propósito de la IA y su evolución histórica.
1.2 Las habilidades cognoscitivas según la psicología. Teorías de la inteligencia (conductismo, Gardner, .
1.3 El proceso de razonamiento según la lógica (Axiomas, Teoremas, demostración).
1.4 El modelo de adquisición del conocimiento según la filosofía.
1.5 El modelo cognoscitivo.
1.6 El modelo del agente inteligente.
1.7 El papel de la heurística.

miércoles, 12 de agosto de 2015

Estructura de Datos. Material Unidad 1.

https://drive.google.com/file/d/0B-hQiDaqUNLwZTlhZTUzY2ItZmE5OC00NDY0LWEyOGQtM2U4NzE5OThkMTRk/view?usp=sharing

Encuadre de Estructura de Datos 2015.

Pueden bajar el encuadre de Estructura de Datos!

https://drive.google.com/file/d/0B-hQiDaqUNLwbHRpMkktRVc3bG8/view?usp=sharing

martes, 11 de agosto de 2015

Encuadre de Inteligencia Artificial 2015

Pueden leer el encuadre!

https://drive.google.com/file/d/0B-hQiDaqUNLwMGJiMlNSWGhtTTg/view?usp=sharing

martes, 17 de marzo de 2015

Práctica de funciones y trayectorias.

#include "stdafx.h"
#include <glut.h>
#include <math.h>

void Inicializa();
void Dibuja();

void main()
{
glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
glutInitWindowSize(800,800);
glutInitWindowPosition(0,0);
glutCreateWindow("Funciones");
Inicializa();
glutDisplayFunc(Dibuja);
glutMainLoop();
}

void Inicializa()
{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(-6,6,-6,6);
glClearColor(0,0,0,0);
}

void Dibuja()
{
float x,y,z,c,xx,yy;

glClear(GL_COLOR_BUFFER_BIT);

// Cuadricula
glColor3f(1,1,1);
glLineWidth(5);
glBegin(GL_LINES);
for(x=-6;x<=6;x+=4)
{
glVertex2i(x,6);
glVertex2i(x,-6);
glVertex2i(-6,x);
glVertex2i(6,x);
}
glEnd();

// 1
glLineWidth(3);
glPointSize(3);
glColor3f(.2,.1,.8);
glBegin(GL_LINE_STRIP);
for(x=-5.9;x<=-2.1;x+=.01)
{
y=pow(sin(5*x-3),3)+cos(x)+4.2;
glVertex2f(x,y);
}
glEnd();

// 2
glColor3f(1,0,0);
glBegin(GL_LINE_STRIP);
for(z=0;z<=31;z+=.1)
{
x=z*cos(z)/15;
y=z*sin(z)/15+4.1;
glVertex2f(x,y);
}
glEnd();

// 3
glColor3f(1,0,1);
glBegin(GL_POINTS);
for(x=2.1;x<=5.9;x+=.007)
{
y=3*sin(10*(x-4))/(10*(x-4))+2.8;
glVertex2f(x,y);
}
glEnd();

// 4
glColor3f(1,.5,.5);
for(c=.45;c<1.81;c+=.45)
{
glBegin(GL_LINE_LOOP);
for(z=0;z<=6.28;z+=.01)
{
x=c*cos(z)-4;
y=c*sin(z);
glVertex2f(x,y);
}
glEnd();
}

// 5
glColor3f(1,1,0);
glBegin(GL_LINES);
for(x=-1.8;x<=0.1;x+=.45)
{
glVertex2f(x,1.8);
glVertex2f(x+1.8,-1.8);
glVertex2f(-x,1.8);
glVertex2f(-x-1.8,-1.8);
}
glEnd();

// 6
glColor3f(.5,.5,.5);
for(c=.25;c<=1.75;c+=.25)
{
glBegin(GL_LINE_LOOP);
for(z=0;z<=6.28;z+=.01)
{
x=cos(z)+3+c;
y=-.5*sin(z)-1+c;
glVertex2f(x,y);
}
glEnd();
}

// 7
glColor3f(.1,.1,1);
glBegin(GL_POINTS);
for(x=-5.9;x<=-2.1;x+=.01)
{
y=cos(exp(x+4)*sqrt(x*x+4))-4;
glVertex2f(x,y);
}
glEnd();

// 8
glColor3f(.1,.5,.5);
glBegin(GL_LINE_STRIP);
for(z=0;z<=6.28;z+=.01)
{
x=cos(z);
y=sin(z)-4;
glVertex2f(x,y);
if(z==0)
{
for(c=-3.14;c<=3.14;c+=.01)
{
xx=.4*cos(c)+x*1.4;
yy=.4*sin(c)+y;
glVertex2f(xx,yy);
}
}
if(z>1.57&&z<1.58)
{
for(c=-1.57;c<=4.71;c+=.01)
{
xx=.4*cos(c)+x*1.4;
yy=.4*sin(c)+y+.4;
glVertex2f(xx,yy);
}
}
if(z>3.14&&z<3.15)
{
for(c=0;c<=6.28;c+=.01)
{
xx=.4*cos(c)+x*1.4;
yy=.4*sin(c)+y;
glVertex2f(xx,yy);
}
}
if(z>4.71&&z<4.72)
{
for(c=1.56;c<=7.84;c+=.01)
{
xx=.4*cos(c)+x*1.4;
yy=.4*sin(c)+y-.4;
glVertex2f(xx,yy);
}
}
}
glEnd();

// 9
glColor3f(0,1,0);
glBegin(GL_LINE_STRIP);
for(x=0;x<2.9;x+=.01)
{
y=exp(x-1.5)*sin(500*x)/2-2;
glVertex2f(y+6,x-5.8);
}
glEnd();
glutSwapBuffers();
}

Clase Tec. Lerdo