martes, 24 de noviembre de 2009

segundo examen en consola

segundo examen en consola

namespace practica_extra
{
class Program
{
static void Main(string[] args)
{
int limite, peso, suma = 0;
Console.WriteLine("introduce limite de pesca");
limite = int.Parse(Console.ReadLine());
do
{
Console.WriteLine("introduce peso individual de pescado:");
peso = int.Parse(Console.ReadLine());
suma = suma + peso;
if (suma > limite)
Console.WriteLine(" ha exedido el limite");
Console.WriteLine("total={0}", suma);
}
while (suma < limite peso != 0);
Console.ReadKey();


}
}




tercer examen

tercer examen en consola



class Program
{
static void Main(string[] args)
{ int numero;
do
{
Console.WriteLine("introduce un valor entero 1-10 y 0 para salir");
numero = int.Parse(Console.ReadLine());
switch (numero)
{



case 0: Console.WriteLine("salida del programa");
break;
case 1: Console.WriteLine("su equivalente en numero romano es I");
break;
case 2: Console.WriteLine(" su equibvalente en numero romano es II");
break;
case 3: Console.WriteLine(" su equibvalente en numero romano es III");
break;
case 4: Console.WriteLine(" su equibvalente en numero romano es IV");
break;
case 5: Console.WriteLine(" su equibvalente en numero romano es V");
break;
case 6: Console.WriteLine(" su equibvalente en numero romano es VI");
break;
case 7: Console.WriteLine(" su equibvalente en numero romano es VII");
break;
case 8: Console.WriteLine(" su equibvalente en numero romano es VIII");
break;
case 9: Console.WriteLine(" su equibvalente en numero romano es IX");
break;
case 10: Console.WriteLine(" su equibvalente en numero romano es X");
break;
default: Console.WriteLine("no introdujo numero correcto");
break;
}
}
while (numero != 0);
Console.ReadKey();

martes, 17 de noviembre de 2009

PRACTICA EXTRA

PRIMER EXAMEN


namespace examen_1__Console
{
class Program
{
static void Main(string[] args)
{
int valor, sum, n, t;
double prom;
n = 0;
sum = 0;
t = 0;
Console.WriteLine("Nota\t\t\tSi Introduces 9999 te dara el Promedio");
do
{
Console.Write("\nintroduce un valor: ");
valor = int.Parse(Console.ReadLine());
sum = sum + valor;
n = n + 1;
}
while (valor != 9999);
sum = sum - 9999;
n = n - 1;
prom = sum / n;
Console.WriteLine("\n\n\t\tEL PROMEDIO ES: {0} ", prom);
Console.ReadLine();






examen 1 en windows



namespace examen_1__Windows
{
public partial class Form1 : Form
{
int valor, sum, n;
double prom;
public Form1()
{
InitializeComponent();
sum = n = valor = 0;
listBox1.Items.Add("\tvalores numericos");
}
private void button1_Click(object sender, EventArgs e)
{
valor = int.Parse(textBox1.Text);
if (valor != 9999)
{
listBox1.Items.Add("\t\t" + valor.ToString());
sum = sum + valor;
n = n + 1;
textBox1.Clear();
textBox1.Focus();
}
else
{
n = n - 1;
prom = sum / n;
listBox1.Items.Add("EL PROMEDIO ES: " + prom.ToString());
textBox1.Enabled = false;
button1.Enabled = false;
}
}
private void button3_Click(object sender, EventArgs e)
{
Close();
}
}
}





sábado, 24 de octubre de 2009

PRACTICA 6 PROBLEMA 4

namespace practica_6._4_console
{
class Program
{
static void Main(string[] args)
{
double x, y;
Console.WriteLine("\t\tfuncion matematica");
Console.WriteLine("\nvalor de x t\t\tvalor de y");
for (x = 1; x <= 5; x = x + 0.1)
{
y = 1.0 + x + Math.Pow(x, 2) / 2.0 + Math.Pow(x, 3) / 6.0 + Math.Pow(x, 4)/24.0;
Console.WriteLine("{0} \t\t\t{1} ", x, y);
}
Console.ReadLine();


PRACTICA EN WINDOWS


namespace PRACTICA_6._4_WINDOWS
{
public partial class Form1 : Form
{
double x, y;
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
double x, y;
listBox1.Items.Add("VALOR DE X \tVALOR DE Y");
for (x = 1; x <= 5; x = x + 0.1)
{
y = 1 + x + Math.Pow(x, 2) / 2.0 + Math.Pow(x, 3) / 6.0 + Math.Pow(x, 4) / 24.0;
listBox1.Items.Add(x.ToString() + "\t\t" + y.ToString());
}
}
private void button3_Click(object sender, EventArgs e)
{
listBox1.Items.Clear();
}
private void button2_Click(object sender, EventArgs e)
{
Close();
}
}

practica 6 problema 3




namespace practica_6._3_cosnsole
{
class Program
{
static void Main(string[] args)
{
double x, y;
Console.WriteLine("\t\tfuncion matematica");
Console.WriteLine("\nvalor de x \t\tvalor de y");
for (x = 1; x <= 10; x = x + 0.2) { y = 3 * Math.Pow(x, 5) + 2 * Math.Pow(x, 3) + x; Console.WriteLine("{0} \t\t\t{1} ", x, y); } Console.ReadLine();




practica en windows


public partial class Form1 : Form
{
double x, y;
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
double x, y;
listBox1.Items.Add("VALOR DE X \t\tVALOR DE Y");
for (x = 2; x <= 10; x = x + 0.2)
{
y = 3 * Math.Pow(x, 5) + 2 * Math.Pow(x, 3) + x;
listBox1.Items.Add(x.ToString()+ "\t\t" + y.ToString());
}
}
}

PRACTICA 6 PROBLEMA 2




namespace PRACTICA_6._2_CONSOLE
{
class Program
{
static void Main(string[] args)
{
double n, i, suma = 0;
Console.WriteLine("\n\nINTRODUCE UN NUMERO");
n = double.Parse(Console.ReadLine());
for (i = 1; i <= n; i = i + 2) { suma = suma + i; } Console.WriteLine("\n\nLA SUMA DE LOS IMPARES ES: {0} ", suma); Console.ReadLine();




PRACTICA EN WINDOWS



namespace PRACTICA_6._2_WINDOWS
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
double n, i, suma = 0;
n = double.Parse(textBox1.Text);
for (i = 1; i <= n; i = i + 2) { suma = suma + i; } textBox2.Text = suma.ToString(); } private void button2_Click(object sender, EventArgs e) { textBox1.Clear(); textBox2.Clear(); } private void button3_Click(object sender, EventArgs e) { Close(); }

PRACTICA 6 PROBLEMA 1




namespace practica_6._1_consola
{
class Program
{
static void Main(string[] args)
{
double n, i, factor = 1.0;
Console.WriteLine("\n\nINTRODUCE EL VALOR DEL FACTORIAL");
n = double.Parse(Console.ReadLine());
for (i = n; i >= 1; i--)
{
factor = factor * i;
}
Console.WriteLine("\n\nEL FACTORIAL ES: {0}", factor);
Console.ReadLine();

PRACTICA EN WINDOWS


namespace practica_6._1_windows
{
public partial class Form1 : Form
{
double factor, n, i;
public Form1()
{
factor = 1.0;
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
double n, i, factor = 1.0;
n = int.Parse(textBox1.Text);
for (i =n; i >= 1; i--)
for (i = n; i >= 1; i--)
{
factor = factor * i;
}
textBox2.Text = factor.ToString();
}
private void button2_Click(object sender, EventArgs e)
{
textBox1.Clear();
textBox2.Clear();
}
private void button3_Click(object sender, EventArgs e)
{
Close();
}
private void Form1_Load(object sender, EventArgs e)

PRACTICA 5.4



{
class Program
{
static void Main(string[] args)
{
double t, rad, x, y;
t = 0;
rad = Math.PI * 22.8 / 180;
Console.WriteLine("\ntiempo \tvalor de x \t\tvalor de y");
while(t<10)
{
x = 500 * t * Math.Cos(rad);
y = 500 * t * Math.Sin(rad);
Console.WriteLine("{0} \t{1} \t{2} ", t, x, y);
t = t + 0.5;
}
Console.ReadLine();



PRACTICA EN WINDOWS

namespace practica_5._8_windows
{
public partial class Form1 : Form
{
double T, RAD, X, Y;
public Form1()
{
T = 0;
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
double T, RAD, X, Y;
T = 0;
RAD = Math.PI * 22.8 / 180;
listBox1.Items.Add("TIEMPO \tVALOR DE X \t\tVALOR DE Y");
do
{
X = 500 * T * Math.Cos(RAD);
Y = 500 * T * Math.Sin(RAD);
listBox1.Items.Add(T.ToString() + "\t" + X.ToString() + "\t\t" + Y.ToString());
T=T+ 1.0/2.0;
}
while(T<=10); } private void button2_Click(object sender, EventArgs e) { listBox1.Items.Clear(); } private void button3_Click(object sender, EventArgs e) { Close(); } private void listBox1_SelectedIndexChanged(object sender, EventArgs e)





PRACTICA 5 PROBLEMA 3




class Program
{
static void Main(string[] args)
{
int num, anum, dig;
Console.WriteLine("\n\nintroduce un valor entero");
num = int.Parse(Console.ReadLine());
anum = num;
do
{
dig = anum % 10;
Console.WriteLine("\ndigito {0}", dig);
anum = anum / 10;
}
while (anum != 0);
Console.ReadLine();
}
}


PRACTICA EN WINDOWS


namespace practica_5._7_windows
{
public partial class Form1 : Form
{
int num, anum, dig;
public Form1()
{
num= anum= dig=0;
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
int num, anum, dig;
num = int.Parse(textBox1.Text);
anum = num;
do
{
dig = anum % 10;
listBox1.Items.Add("digito\t " + dig.ToString());
anum = anum / 10;
}
while (anum != 0);
}
private void button2_Click(object sender, EventArgs e)
{
textBox1.Clear();
listBox1.Items.Clear();
}
private void button3_Click(object sender, EventArgs e)
{
Close();
}

PRACTICA 5.2 D



namespace practica_5._6_console
{
class Program
{
static void Main(string[] args)
{
int c1, er;
c1 = 0;
er = 0;
do
{
Console.WriteLine(" \n Introduce Calificacion");
c1 = int.Parse(Console.ReadLine());
if (c1 <> 100)
{
er = er + 1;
}
}
while (er < 5);
Console.ReadLine();
}


PRACTICA EN WINDOWS



public partial class Form1 : Form
{
int c1, er;
public Form1()
{
c1 = 0;
er = 0;
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
c1 = int.Parse(textBox1.Text);
if (c1 <> 100)
{
listBox1.Items.Add(c1.ToString());
er = er + 1;
}
else
{
listBox1.Items.Add(c1);
}
if (er > 5)
{ Close(); }



PRACTICA 5.2 C




class Program
{
static void Main(string[] args)
{
int cl;
do
{
Console.WriteLine("introduce calificacion");
cl = int.Parse(Console.ReadLine());
Console.WriteLine("la calificacion:{0}", cl);
if (cl <> 100)
Console.WriteLine("calificacion incorrecta");
}
while (cl != 999);
Console.Read();


PRACTICA EN WINDOWS




namespace practica_5._5_windows
{
public partial class Form1 : Form
{
int c1, codigo = 999;
public Form1()
{
c1 = 0;
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
c1 = int.Parse(textBox1.Text);
if (c1 == codigo)
Close();
if (c1 <> 100)
{
textBox1.Enabled = false;
listBox1.Items.Add("Calificacion Incorrecta");
}
else
{
listBox1.Items.Add(c1);
}
}
private void button2_Click(object sender, EventArgs e)
{
textBox1.Enabled = true;
textBox1.Clear();
listBox1.Items.Clear();
}
private void button3_Click(object sender, EventArgs e)
{
Close();

PRACTICA 5.2 B



class Program
{
static void Main(string[] args)
{
int cl;
do
{
Console.WriteLine("introduce calificacion");
cl = int.Parse(Console.ReadLine());
Console.WriteLine("la calificacion:{0}", cl);
if (cl <> 100)
Console.WriteLine("calificacion incorrecta");
}
while (cl != 999);
Console.Read();
}

PRACTICA EN WINDOWS


namespace practica_5._5_windows
{
public partial class Form1 : Form
{
int c1, codigo = 999;
public Form1()
{
c1 = 0;
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
c1 = int.Parse(textBox1.Text);
if (c1 == codigo)
Close();
if (c1 <> 100)
{
textBox1.Enabled = false;
listBox1.Items.Add("Calificacion Incorrecta");
}
else
{
listBox1.Items.Add(c1);
}
}
private void button2_Click(object sender, EventArgs e)
{
textBox1.Enabled = true;
textBox1.Clear();
listBox1.Items.Clear();
}
private void button3_Click(object sender, EventArgs e)
{
Close();
}
private void Form1_Load(object sender, EventArgs e)
{








practica 5.2 A

practica 5.1 A consola y windows

consola










namespace practica_5._2_consola
{
class Program
{
static void Main(string[] args)
{
int cl;
do{
Console.WriteLine("introduce calificacion");
cl= int.Parse(Console.ReadLine());
Console.WriteLine("la calificacion:{0}",cl);
}
while(cl>=0 cl <=100); Console.Read();

practica en windows

namespace practica_5._3_windows
{
public partial class Form1 : Form
{
int c1;
public Form1()
{
c1 = 0;
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
c1 = int.Parse(textBox1.Text);
if (c1 <> 100)
{
textBox1.Enabled = false;
}
else
{
listBox1.Items.Add(c1);
}
}
private void button2_Click(object sender, EventArgs e)
{
textBox1.Enabled = true;
textBox1.Clear();
listBox1.Items.Clear();
}
private void button3_Click(object sender, EventArgs e)
{
Close();
}


practica 4.4 pies a metros



imagen


programa


class Program
{
static void Main(string[] args)
{
double pies,metros;
pies=2.0;
Console.WriteLine("pies\t\tmetros");
while (pies <= 20.0) { metros = pies/3.28; Console.WriteLine("{0}\t\t{1}", pies,metros); pies=pies+2; } Console.ReadKey();


practica en windows



public partial class Form1 : Form
{
double pies, metro;
public Form1()
{
pies = 2.0;
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
listBox1.Items.Add("pies metros");
while (pies <= 20.0) { metro = pies / 3.28; listBox1.Items.Add(pies.ToString() + " " + metro.ToString()); pies = pies + 2.0; }


practica 4.3 grados celsius y faherenheit



imagen


codigo



namespace practica_4._3_consola
{
class Program
{
static void Main(string[] args)
{
double celsius,Fahrenheit;
celsius=-10;
Console.WriteLine("celsius\t\farenheit");
while (celsius <= 60.0) { Fahrenheit=(9.0/5.0)*celsius+32.0; Console.WriteLine("{0}\t\t{1}", celsius,Fahrenheit); celsius = celsius +10; }
Console.ReadKey();






programa en windows



namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
double celsius, fahrenheit;
public Form1()
{
celsius = -10;
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
listBox1.Items.Add("celsius fahrenheit");
while (celsius <= 60.0) { fahrenheit=(9.0/5.0)*celsius+32.0; listBox1.Items.Add(celsius.ToString()+" " + fahrenheit.ToString()); celsius = celsius +10; } } private void button2_Click(object sender, EventArgs e) { Close();

practica 4.2


imagen


codigo

class Program
{
static void Main(string[] args)
{
int angulo;
Console.WriteLine("Introduce el Angulo");
angulo = int.Parse(Console.ReadLine());
if (angulo > 0 && angulo < 90)
Console.WriteLine("Cuadrante 1");
else
{
if (angulo > 90 && angulo < 180)
Console.WriteLine("Cuandrante 2");
else
{
if (angulo > 180 && angulo < 270)
Console.WriteLine("Cuandrante 3");
else
{
if (angulo > 270 && angulo < 360)
Console.WriteLine("Cuandrante 4");
else
{
switch (angulo)
{
case 0:
case 360: Console.WriteLine("Eje positivo x");
break;
case 90: Console.WriteLine("Eje positivo y");
break;
case 180: Console.WriteLine("Eje negativo x");
break;
case 270: Console.WriteLine("Eje negativo y");
break;

}
} Console.ReadKey();

programa en windows



public partial class Form1 : Form
{int angulo;
public Form1()
{angulo = 0;
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
angulo = int.Parse(textBox1.Text);
if (angulo > 0 && angulo < 90)
textBox2.Text = ("Cuadrante 1");
else
{
if (angulo > 90 && angulo < 180)
textBox2.Text = ("Cuadrante 2");
else
{
if (angulo > 180 && angulo < 270)
textBox2.Text = ("Cuadrante 3");
else
{
if (angulo > 270 && angulo < 360)
textBox2.Text = ("Cuadrante 4");
else
{
switch (angulo)
{
case 0:
case 360: textBox2.Text = ("Eje Positivo de x");
break;
case 90: textBox2.Text = ("Eje Positivo de y");
break;
case 180: textBox2.Text = ("Eje Negativo de x");
break;
case 270: textBox2.Text = ("Eje Negativo de y");
break;
}
}

private void button2_Click(object sender, EventArgs e)
{
textBox1.Clear();
textBox2.Clear();
}
private void button3_Click(object sender, EventArgs e)
{
Close();

practica 4

practica 4.1 codigo de seleccion

codigo


class Program
{
static void Main(string[] args)
{
double d2, d3, d4;
Console.WriteLine("Introduce los siguientes codigo 1,2,3 o 4");
Console.WriteLine("\n\nCodijo");
d2 = double.Parse(Console.ReadLine());
Console.WriteLine("\nintroduce primer numero");
d3 = double.Parse(Console.ReadLine());
Console.WriteLine("\nIntroduce segundo numero");
d4 = double.Parse(Console.ReadLine());
if (d2 == 1)
{
Console.WriteLine("\n\nSu suma es ");
d2 = d3 + d4;
}
else
{
if (d2 == 2)
{
Console.WriteLine("\n\nsu resta es ");
d2 = d3 - d4;
}
else
{
if (d2 == 3)
{
Console.WriteLine("\n\nsu multiplicacion es ");
d2 = d3 * d4;
}
else
{
if (d2 == 4)
{
Console.WriteLine("\n\nsu divicion es ");
d2 = d3 / d4;
}
else
{
Console.WriteLine("\n\nError no se puede dividir entre cero ");
d2 = d3 / d4;
d4 = 0;
}
}
}
}
Console.WriteLine("{0}", d2);
Console.ReadKey();






imagen




diagrama de flujo



practica en windowspublic partial class Form1 : Form
{
double d2, d3, d4;
public Form1()
{
d2 = d3 = d4;
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
d2 = double.Parse(textBox1.Text);
d3 = double.Parse(textBox2.Text);
d4 = double.Parse(textBox3.Text);
if (d2 == 1)
{
textBox5.Text="Su suma es ";
d2 = d3 + d4;
}
else
{
if (d2 == 2)
{
textBox5.Text="su resta es ";
d2 = d3 - d4;
}
else
{
if (d2 == 3)
{
textBox5.Text="su multiplicacion es ";
d2 = d3 * d4;
}
else
{
if (d2 == 4)
{
textBox5.Text="su divicion es ";
d2 = d3 / d4;
}
else
{
textBox5.Text="Error no se puede dividir entre cero ";
d2 = d3 / d4;
d4 = 0;
}
}
}
}
textBox4.Text = d2.ToString();
}
private void button2_Click(object sender, EventArgs e)
{
textBox1.Clear();
textBox2.Clear();
textBox3.Clear();
textBox4.Clear();
textBox5.Clear();
}
private void button3_Click(object sender, EventArgs e)
{
Close();


viernes, 16 de octubre de 2009

martes, 29 de septiembre de 2009

practica 2.1 2.2 2.3.

practica 2.1
codigo



using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace practica_2._1
{
class Program
{
static void Main(string[] args)
{
int n, m, p, rs;
Console.WriteLine("introduce la cantidad de resistores de 56 ohms");
n = int.Parse(Console.ReadLine());
Console.WriteLine("introduce la cantidad de resistores de 33 ohms");
m = int.Parse(Console.ReadLine());
Console.WriteLine("introduce la cantidad de resistores de 15 ohms");
p= int.Parse(Console.ReadLine());
rs= n*56+m*33+p*15;
Console.WriteLine("laresistensia total en serie es{0}",rs);
Console.ReadKey();

programa





practica 2.1 en windows

codigo

namespace practica_2._1_en_windows
{
public partial class Form1 : Form
{
int n, m, p, ps;
public Form1()
{
n = m = p = ps = 0;
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
n = int.Parse(textBox1.Text);
m = int.Parse(textBox2.Text);
p = int.Parse(textBox3.Text);
ps = n * 56 + m * 33 + p * 15;
label4.Text = " la resistencia total en serie es" + ps.ToString();
}
private void button2_Click(object sender, EventArgs e)
{
textBox1.Clear();
textBox2.Clear();
textBox3.Clear();
label4.Text = " ";
}
private void button3_Click(object sender, EventArgs e)
{
Close();

}
}
}

programa





practica 2.2 en consola
codigo

namespace practica_2._2_en_consola
{
class Program
{
static void Main(string[] args)
{
int distancia, vel, tiempo;
Console.WriteLine("programa para calcular la distancia en millas");
Console.WriteLine(" introduce el valor entero que reprecente la velosidad del viaje");
vel= int.Parse(Console.ReadLine());
Console.WriteLine("introduce el tiempo transcurrido");
tiempo= int.Parse(Console.ReadLine());
distancia= vel*tiempo;
Console.WriteLine(" la distancia total es {0} millas",distancia);
Console.ReadKey();
}
}
}

programa









practica 2.2 en windows

codigo
namespace practica_2._2_en_windows
{
public partial class Form1 : Form
{
int distancia, vel, tiempo;
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
vel = int.Parse(textBox1.Text);
tiempo = int.Parse(textBox2.Text);
distancia = vel * tiempo;
label3.Text ="la distancia total es " + distancia.ToString()+" millas";
}
private void button2_Click(object sender, EventArgs e)
{
textBox1.Clear();
textBox2.Clear();
label3.Text = " ";
}
private void button3_Click(object sender, EventArgs e)
{
Close();
}
}
}

programa









practica 2.3 en consola

codigo
namespace practica_2_3_console
{
class Program
{
static void Main(string[] args)
{
double costoAuto, costoTotal;
Console.WriteLine("introduce costo auto");
costoAuto = double.Parse(Console.ReadLine());
double ganancia=costoAuto*0.12;
double impuesto=costoAuto*0.06;
costoTotal = costoAuto + ganancia + impuesto;
Console.WriteLine("Costo Auto={0}\n ganancia Vendedor={1} \n Impuesto ={2} \n Costo Total ={3}" ,costoAuto, ganancia, impuesto, costoTotal);
Console.ReadKey();



programa





practica 2.3 en windows

codigo


namespace practica_2__3_en_windows_costo_de_un_auto
{
public partial class Form1 : Form
{
double costoauto, costototal, ganancia, impuesto;
public Form1()
{
costoauto = costototal = ganancia = impuesto = 0;
InitializeComponent();
}
private void Form1_Load(object sender, EventArgs e)
{
}
private void button3_Click(object sender, EventArgs e)
{
Close();
}
private void button1_Click(object sender, EventArgs e)
{
costoauto = double.Parse(textBox1.Text);
ganancia = costoauto * 0.12;
impuesto = costoauto * 0.06;
costototal = costoauto + ganancia + impuesto;
textBox2.Text = costoauto.ToString();
textBox3.Text = ganancia.ToString();
textBox4.Text = impuesto.ToString();
textBox5.Text=costototal.ToString();
ToString();





}
private void button2_Click(object sender, EventArgs e)
{
textBox1.Clear();
textBox2.Clear();
textBox3.Clear();
textBox4.Clear();
textBox5.Clear();





}
}
}



programa




practica 1-1

codigo

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace recta_rectangulo
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine(" \n\n\t\tprogrma tutorial de Quimica ");
Console.WriteLine(" \n\n\t\todjetivo General");
Console.WriteLine(" \n\n\t\tformar a los alumnos de licenciatura,");
Console.WriteLine(" \n\n\t\tmaestr¡a y doctorado, en los conocimientos");
Console.WriteLine(" \n\n\t\tactuales fundamentales y relevantes.2");
Console.WriteLine(" \n\n\t\ten el campo de la qu¡mica org nica para que");
Console.WriteLine(" \n\n\t\tse integren a la sociedad.");
Console.WriteLine(" \n\n\t\tNombre del autor: Ballinas Gordillo Wiliams");
Console.WriteLine(" \n\n\t\tNumero de version: 0.1");
Console.WriteLine(" \n\n\t\tfecha 01 de septiembre del 2009");
Console.ReadLine();



consola







practica 1-1 en windows






QUE ES C#?

C#


Es el nuevo lenguaje de propósito general diseñado por Microsoft para su plataforma .NET. Sus principales creadores son Scott Wiltamuth y Anders Hejlsberg, C# es un lenguaje de programación que toma las mejores características de lenguajes preexistentes como Visual Basic, Java o C++ y las combina en uno solo. El hecho de ser relativamente reciente no implica que sea inmaduro, pues Microsoft ha escrito la mayor parte de la BCL usándolo, por lo que su compilador es el más depurado y optimizado de los incluidos en el .NET Framework SDK.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 ya que C# carece de elementos heredados innecesarios en .NET. Por esta razón, se suele decir que C# es el lenguaje nativo de .NETLa sintaxis y estructuración de C# es muy parecida a la de C++ o Java, puesto que la intención de Microsoft es facilitar la migración de códigos escritos en estos lenguajes a C# y facilitar su aprendizaje a los desarrolladores habituados a ellos. Sin embargo, su sencillez y el alto nivel de productividad son comparables con los de Visual Basic.Un lenguaje que hubiese sido ideal utilizar para estos menesteres es Java, pero debido a problemas con la empresa creadora del mismo -Sun-, Microsoft ha tenido que desarrollar un nuevo lenguaje que añadiese a las ya probadas virtudes de Java las modificaciones que Microsoft tenía pensado añadirle para mejorarlo aún más y hacerlo un lenguaje orientado al desarrollo de componentes.


CARACTERISTICAS Sencillez:


C# elimina muchos elementos que otros lenguajes incluyen y que son innecesarios en .NET. Por ejemplo: El código escrito en C# es autocontenido, lo que significa que no necesita de ficheros adicionales al propio fuente tales como ficheros de cabecera o ficheros IDL El tamaño de los tipos de datos básicos es fijo e independiente del compilador, sistema operativo o máquina para quienes se compile (no como en C++), lo que facilita la portabilidad del código. No se incluyen elementos poco útiles de lenguajes como C++ tales como macros, herencia múltiple o la necesidad de un operador diferente del punto (.) acceder a miembros de espacios de nombres (::) Modernidad: C# incorpora en el propio lenguaje elementos que a lo largo de los años ha ido demostrándose son muy útiles para el desarrollo de aplicaciones y que en otros lenguajes como Java o C++ hay que simular, como un tipo básico decimal que permita realizar operaciones de alta precisión con reales de 128 bits (muy útil en el mundo financiero), la inclusión de una instrucción foreach que permita recorrer colecciones con facilidad y es ampliable a tipos definidos por el usuario, la inclusión de un tipo básico string para representar cadenas o la distinción de un tipo bool específico para representar valores lógicos. Orientación a objetos: Como todo lenguaje de programación de propósito general actual, C# es un lenguaje orientado a objetos, aunque eso es más bien una característica del CTS que de C#. Una diferencia de este enfoque orientado a objetos respecto al de otros lenguajes como C++ es que el de C# es más puro en tanto que 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. C# soporta todas las características propias del paradigma de programación orientada a objetos: encapsulación, herencia y polimorfismo.En lo referente a la encapsulación es importante señalar que aparte de los típicos modificadores public, private y protected, C# añade un cuarto modificador llamado internal, que puede combinarse con protected e indica que al elemento a cuya definición precede sólo puede accederse desde su mismo ensamblado.Respecto a la herencia -a diferencia de C++ y al igual que Java- C# sólo admite herencia simple de clases ya que la múltiple provoca más quebraderos de cabeza que facilidades y en la mayoría de los casos su utilidad puede ser simulada con facilidad mediante herencia múltiple de interfaces. De todos modos, esto vuelve a ser más bien una característica propia del CTS que de C#.Por otro lado y a diferencia de Java, en C# se ha optado por hacer que todos los métodos sean por defecto sellados y que los redefinibles hayan de marcarse con el modificador virtual (como en C++), lo que permite evitar errores derivados de redefiniciones accidentales. Además, un efecto secundario de esto es que las llamadas a los métodos serán más eficientes por defecto al no tenerse que buscar en la tabla de funciones virtuales la implementación de los mismos a la que se ha de llamar. Otro efecto secundario es que permite que las llamadas a los métodos virtuales se puedan hacer más eficientemente al contribuir a que el tamaño de dicha tabla se reduzca.Orientación a componentes: La propia sintaxis de C# incluye elementos propios del diseño de componentes que otros lenguajes tienen que simular mediante construcciones más o menos complejas. Es decir, la sintaxis de C# permite definir cómodamente propiedades (similares a campos de acceso controlado), eventos (asociación controlada de funciones de respuesta a notificaciones) o atributos (información sobre un tipo o sus miembros) Gestión automática de memoria: Como ya se comentó, todo lenguaje de .

NET tiene a su disposición el recolector de basura del CLR. Esto tiene el efecto en el lenguaje de que no es necesario incluir instrucciones de destrucción de objetos. Sin embargo, dado que la destrucción de los objetos a través del recolector de basura es indeterminista y sólo se realiza cuando éste se active –ya sea por falta de memoria, finalización de la aplicación o solicitud explícita en el fuente-, C# también proporciona un mecanismo de liberación de recursos determinista a través de la instrucción using. Seguridad de tipos: C# incluye mecanismos que permiten asegurar que los accesos a tipos de datos siempre se realicen correctamente, lo que permite evita que se produzcan errores difíciles de detectar por acceso a memoria no perteneciente a ningún objeto y es especialmente necesario en un entorno gestionado por un recolector de basura. Para ello se toman medidas del tipo: Sólo se admiten conversiones entre tipos compatibles. Esto es, entre un tipo y antecesores suyos, entre tipos para los que explícitamente se haya definido un operador de conversión, y entre un tipo y un tipo hijo suyo del que un objeto del primero almacenase una referencia del segundo (downcasting) Obviamente, lo último sólo puede comprobarlo en tiempo de ejecución el CLR y no el compilador, por lo que en realidad el CLR y el compilador colaboran para asegurar la corrección de las conversiones. No se pueden usar variables no inicializadas. El compilador da a los campos un valor por defecto consistente en ponerlos a cero y controla mediante análisis del flujo de control del fuente que no se lea ninguna variable local sin que se le haya asignado previamente algún valor. Se comprueba que todo acceso a los elementos de una tabla se realice con índices que se encuentren dentro del rango de la misma. Se puede controlar la producción de desbordamientos en operaciones aritméticas, informándose de ello con una excepción cuando ocurra. Sin embargo, para conseguirse un mayor rendimiento en la aritmética estas comprobaciones no se hacen por defecto al operar con variables sino sólo con constantes (se pueden detectar en tiempo de compilación) A diferencia de Java, C# incluye delegados, que son similares a los punteros a funciones de C++ pero siguen un enfoque orientado a objetos, pueden almacenar referencias a varios métodos simultáneamente, y se comprueba que los métodos a los que apunten tengan parámetros y valor de retorno del tipo indicado al definirlos. Pueden definirse métodos que admitan un número indefinido de parámetros de un cierto tipo, y a diferencia lenguajes como C/C++, en C# siempre se comprueba que los valores que se les pasen en cada llamada sean de los tipos apropiados. Instrucciones seguras: Para evitar errores muy comunes, en C# se han impuesto una serie de restricciones en el uso de las instrucciones de control más comunes. Por ejemplo, la guarda de toda condición ha de ser una expresión condicional y no aritmética, con lo que se evitan errores por confusión del operador de igualdad (==) con el de asignación (=); y todo caso de un switch ha de terminar en un break o goto que indique cuál es la siguiente acción a realizar, lo que evita la ejecución accidental de casos y facilita su reordenación. Sistema de tipos unificado: A diferencia de C++, en C# todos los tipos de datos que se definan siempre derivarán, aunque sea de manera implícita, de una clase base común llamada System.Object, por lo que dispondrán de todos los miembros definidos en ésta clase (es decir, serán “objetos”) A diferencia de Java, en C# esto también es aplicable a los tipos de datos básicos Además, para conseguir que ello no tenga una repercusión negativa en su nivel de rendimiento, se ha incluido un mecanismo transparente de boxing y unboxing con el que se consigue que sólo sean tratados como objetos cuando la situación lo requiera, y mientras tanto puede aplicárseles optimizaciones específicas.El hecho de que todos los tipos del lenguaje deriven de una clase común facilita enormemente el diseño de colecciones genéricas que puedan almacenar objetos de cualquier tipo.Extensibilidad de tipos básicos: C# permite definir, a través de estructuras, tipos de datos para los que se apliquen las mismas optimizaciones que para los tipos de datos básicos. Es decir, que se puedan almacenar directamente en pila (luego su creación, destrucción y acceso serán más rápidos) y se asignen por valor y no por referencia. Para conseguir que lo último no tenga efectos negativos al pasar estructuras como parámetros de métodos, se da la posibilidad de pasar referencias a pila a través del modificador de parámetro ref. Extensibilidad de operadores: Para facilitar la legibilidad del código y conseguir que los nuevos tipos de datos básicos que se definan a través de las estructuras estén al mismo nivel que los básicos predefinidos en el lenguaje, al igual que C++ y a diferencia de Java, 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 apliquen a diferentes tipos de objetos.Las redefiniciones de operadores se hacen de manera inteligente, de modo que a partir de una única definición de los operadores ++ y -- el compilador puede deducir automáticamente como ejecutarlos de manera prefijas y postifja; y definiendo operadores simples (como +), el compilador deduce cómo aplicar su versión de asignación compuesta (+=) Además, para asegurar la consistencia, el compilador vigila que los operadores con opuesto siempre se redefinan por parejas (por ejemplo, si se redefine ==, también hay que redefinir !=)También se da la posibilidad, a través del concepto de indizador, de redefinir el significado del operador [] para los tipos de dato definidos por el usuario, con lo que se consigue que se pueda acceder al mismo como si fuese una tabla. Esto es muy útil para trabajar con tipos que actúen como colecciones de objetos.Extensibilidad de modificadores: 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 adicional a la generada por el compilador que luego podrá ser consultada en tiempo ejecución a través de la librería 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.Versionable: C# incluye una política de versionado que permite crear nuevas versiones de tipos sin temor a que la introducción de nuevos miembros provoquen errores difíciles de detectar en tipos hijos previamente desarrollados y ya extendidos con miembros de igual nombre a los recién introducidos. Si una clase introduce un nuevo método cuyas redefiniciones deban seguir la regla de llamar a la versión de su padre en algún punto de su código, difícilmente seguirían esta regla miembros de su misma signatura definidos en clases hijas previamente a la definición del mismo en la clase padre; o si introduce un nuevo campo con el mismo nombre que algún método de una clase hija, la clase hija dejará de funcionar. Para evitar que esto ocurra, en C# se toman dos medidas:Se obliga a que toda redefinición deba incluir el modificador override, con lo que la versión de la clase hija nunca sería considerada como una redefinición de la versión de miembro en la clase padre ya que no incluiría override. Para evitar que por accidente un programador incluya este modificador, sólo se permite incluirlo en miembros que tengan la misma signatura que miembros marcados como redefinibles mediante el modificador virtual. Así además se evita el error tan frecuente en Java de creerse haber redefinido un miembro, pues si el miembro con override no existe en la clase padre se producirá un error de compilación. Si no se considera redefinición, entonces se considera que lo que se desea es ocultar el método de la clase padre, de modo que para la clase hija sea como si nunca hubiese existido. El compilador avisará de esta decisión a través de un mensaje de aviso que puede suprimirse incluyendo el modificador new en la definición del miembro en la clase hija para así indicarle explícitamente la intención de ocultación. Eficiente: En principio, en C# todo el código incluye numerosas restricciones para asegurar su seguridad y no permite el uso de punteros. Sin embargo, y a diferencia de Java, en C# es posible saltarse dichas restricciones manipulando objetos a través de punteros. Para ello basta marcar regiones de código como inseguras (modificador unsafe) y podrán usarse en ellas punteros de forma similar a cómo se hace en C++, lo que puede resultar vital para situaciones donde se necesite una eficiencia y velocidad procesamiento muy grandes. Compatible: Para facilitar la migración de programadores, C# no sólo mantiene una sintaxis muy similar a C, C++ o Java que permite incluir directamente en código escrito en C# fragmentos de código escrito en estos lenguajes, sino que el CLR también ofrece, a través de los llamados Platform Invocation Services (PInvoke), la posibilidad de acceder a código nativo escrito como funciones sueltas no orientadas a objetos tales como las DLLs de la API Win32. Nótese que la capacidad de usar punteros en código inseguro permite que se pueda acceder con facilidad a este tipo de funciones, ya que éstas muchas veces esperan recibir o devuelven punteros.

viernes, 11 de septiembre de 2009

lenguajes de descripcion de hardware VHDL, PLD, FPGA.

Lenguaje de descripción de hardware

Un lenguaje de descripción de hardware (HDL, Hardware Description Language) permite documentar las interconexiones y el comportamiento de un circuito electrónico, sin utilizar diagramas esquemáticos.
El flujo de diseño suele ser típico:
Definir la tarea o tareas que tiene que hacer el circuito.
Escribir el programa usando un lenguaje HDL. También existen programas de captura de esquemas que pueden hacer esto, pero no son útiles para diseños complicados.
Comprobación de la sintaxis y simulación del programa.
Programación del dispositivo y comprobación del funcionamiento.
Un rasgo común a estos lenguajes suele ser la independencia del hardware y la modularidad o jerarquía, es decir, una vez hecho un diseño éste puede ser usado dentro de otro diseño más complicado y con otro dispositivo compatible.
VHDL
VHDL es el acrónimo que representa la combinación de VHSIC y HDL, donde VHSIC es el acrónimo de Very High Speed Integrated Circuit y HDL es a su vez el acrónimo de Hardware Description Language.
Es un lenguaje usado por ingenieros definido por el IEEE (Institute of Electrical and Electronics Engineers) (ANSI/IEEE 1076-1993) que se usa para diseñar circuitos digitales. Otros métodos para diseñar circuitos son la captura de esquemas (con herramientas CAD) y los diagramas de bloques, pero éstos no son prácticos en diseños complejos. Otros lenguajes para el mismo propósito son Verilog y ABEL.
Aunque puede ser usado de forma general para describir cualquier circuito se usa principalmente para programar PLD (Programable Logic Device - Dispositivo Lógico Programable), FPGA (Field Programmable Gate Array), ASIC y similares.
HDL
(Hardware Description Language).- Lenguaje de Descripción de Hardware
Se le llama HDL a la sintaxis que se usa para describir la operación de un circuito y al archivo resultante se le llama archivo fuente.

Al proceso que se utiliza para generar un archivo de salida que se pueda tranferir a un programador de PLD´s a partir de un archivo fuente, se le llama compilar. Las herramientas que se utilizan para hacer esto se les llama compiladores lógicos.
Las herramientas CAD(Diseño Asistido por Computadora) pueden realizar gran parte del trabajo de manera automática. El diseñador utiliza el sistema CAD para simular el comportamiento del circuito y las herramientas CAD para implementar en forma automática el circuito en un chip, por ejemplo en un PLD(Dispositivo Logico Programable).
Muchos HDL proveen compiladores que permiten al diseñador representar un diagrama de estado. Pero el Lenguaje mas popular es el VHDL.
FPGA

Una FPGA (del inglés Field Programmable Gate Array) es un dispositivo semiconductor que contiene bloques de lógica cuya interconexión y funcionalidad se puede programar. La lógica programable puede reproducir desde funciones tan sencillas como las llevadas a cabo por una puerta lógica o un sistema combinacional hasta complejos sistemas en un chip (w:en:System-on-a-chip).
Las FPGAs se utilizan en aplicaciones similares a los ASICs sin embargo son más lentas, tienen un mayor consumo de potencia y no pueden abarcar sistemas tan complejos como ellos. A pesar de esto, las FPGAs tienen las ventajas de ser reprogramables (lo que añade una enorme flexibilidad al flujo de diseño), sus costes de desarrollo y adquisición son mucho menores para pequeñas cantidades de dispositivos y el tiempo de desarrollo es también menor.
Ciertos fabricantes cuentan con FPGAs que sólo se pueden programar una vez, por lo que sus ventajas e inconvenientes se encuentran a medio camino entre los ASICs y las FPGAs reprogramables.
Históricamente las FPGAs surgen como una evolución de los conceptos desarrollados en las PLAs y los CPLDs

sistema numérico Octal y Hexadecimal

Sistema octal


El sistema numérico en base 8 se llama octal y utiliza los dígitos 0 a 7.
Por ejemplo, el número binário para 74 (en decimal) es 1001010 (en binario), lo agruparíamos como 1 001 010. De modo que el número decimal 74 en octal es 112.
En informática, a veces se utiliza la numeración octal en vez de la hexadecimal. Tiene la ventaja de que no requiere utilizar otros símbolos diferentes de los dígitos. Sin embargo, para trabajar con bytes o conjuntos de ellos, asumiendo que un byte es una palabra de 8 bits, suele ser más cómodo el sistema hexadecimal, por cuanto todo byte así definido es completamente representable por dos dígitos hexadecimales.
Es posible que la numeración octal se usara en el pasado en lugar del decimal, por ejemplo, para contar los espacios interdigitales o los dedos distintos de los pulgares.

Fracciones


La numeración octal es tan buena como la binaria y la hexadecimal para operar con fracciones, puesto que el único factor primo para sus bases es 2. Todas las fracciones que tengan un denominador distinto de una potencia de dos tendrán un desarrollo octal periódico.



Sistema hexadecimal

El sistema hexadecimal, a veces abreviado como hex, es el sistema de numeración posicional de base 16 —empleando por tanto 16 símbolos—. Su uso actual está muy vinculado a la informática y ciencias de la computación, pues los computadores suelen utilizar el byte u octeto como unidad básica de memoria; y, debido a que un byte representa 28 valores posibles, y esto puede representarse como , que, según el teorema general de la numeración posicional, equivale al número en base 16 10016, dos dígitos hexadecimales corresponden exactamente —permiten representar la misma línea de enteros— a un byte.


En principio dado que el sistema usual de numeración es de base decimal y, por ello, sólo se dispone de diez dígitos, se adoptó la convención de usar las seis primeras letras del alfabeto latino para suplir los dígitos que nos faltan. El conjunto de símbolos sería, por tanto, el siguiente:
Se debe notar que A = 10, B = 11, C = 12, D = 13, E = 14 y F = 15. En ocasiones se emplean letras minúsculas en lugar de mayúsculas. Como en cualquier sistema de numeración posicional, el valor numérico de cada dígito es alterado dependiendo de su posición en la cadena de dígitos, quedando multiplicado por una cierta potencia de la base del sistema, que en este caso es 16. Por ejemplo: 3E0,A16 = 3×162 + E×161 + 0×160 + A×16-1 = 3×256 + 14×16 + 0×1 + 10×0,0625 = 992,625.

El sistema hexadecimal actual fue introducido en el ámbito de la computación por primera vez por IBM en 1963. Una representación anterior, con 0–9 y u–z, fue usada en 1956 por la computadora Bendix G-15.

Tarea 2 preguntas

1.-Explique por medio de un dibujo el funcionamiento interno de una computadora. Solo mencione lo que usted considere lo mas importante, con una sola frase.








2.-Investigue las caracteristicas mas importantes de un procesador, de una computadora actual.(ver las caracteristicas del fabricante).



En realidad "procesador" es un término relativamente moderno. Se refiere a lo que en los grandes ordenadores de antaño se conocía como Unidad Central de Proceso UCP (CPU "Central Processin Unit" en la literatura inglesa). Comenzó siendo del tamaño de un armario, posteriormente se redujo al de una gran caja, después se construyó en una placa de unas 15 x 15 pulgadas. Finalmente se construyó en un solo circuito integrado encapsulado en un "chip" que se inserta en un zócalo de la placa-base [0].




En los primeros tiempos de la informática personal, que podemos suponer se inicia con la introducción del PC ("Personal Computer") por IBM a mediados de 1981 [1], el mercado de microprocesadores para el PC estaba copado por Intel, que arrancando con el 8088 [2], un modesto procesador de 16 bits a 4.77 MHz de velocidad de reloj ( H2), fue sufriendo sucesivas mejoras; principalmente en lo que respecta a la velocidad (que en el 2001 ha alcanzado más de 1 GHz. para equipos comerciales); capacidad de procesamiento en paralelo; capacidad de los registros; cache interna y facilidades hardware para multiprogramación.
En la imágen adjunta sendas vistas, superior e inferior, de un procesador Intel 80386 de 16 MHz junto con el primitivo 8088.




Nota: En la actualidad existen procesadores fabricados por otras compañías (IBM, AMD, Cyrix, Etc.) que son compatibles a nivel ensamblador con el juego de instrucciones Intel, lo que permite que no todos los PCs sean necesariamente "Intel inside".

3.-Mencione 5 diferencias de los lenguajes de alto nivel y bajo nivel.

Ventajas del lenguaje ensamblador.
Los lenguajes ensambladores presentan la ventaja frente a los lenguajes máquina de su mayor facilidad de codificación y, en general, su velocidad de cálculo.

Desventajas del lenguaje ensamblador.
Los inconvenientes más notables de los lenguajes ensambladores son:
Dependencia total de la máquina lo que impide la transportabilidad de los programas. El lenguaje ensamblador del PC es distinto del lenguaje ensamblador del Apple Macintosh.
La formación de los programadores es más compleja que la correspondiente a los programadores de alto nivel, ya que no sólo las técnicas de programación, sino también el conocimiento del interior de la máquina.
Hoy día los lenguajes ensambladores tienen sus aplicaciones mas reducidas en la programación de aplicaciones y se centran en aplicaciones de tiempo real, control de procesos y de dispositivos electrónicos, etc

Los lenguajes de alto nivel logran la independencia del tipo de máquina y se aproximan al lenguaje natural. Se puede decir que el principal problema que presentan los lenguajes de alto nivel es la gran cantidad de ellos que existen actualmente en uso.
Los lenguajes de alto nivel, también denominados lenguajes evolucionados, surgen con posterioridad a los anteriores, con los siguientes objetivos, entre otros:


Lograr independencia de la máquina, pudiendo utilizar un mismo programa en diferentes equipos con la única condición de disponer de un programa traductor o compilador, que lo suministra el fabricante, para obtener el programa ejecutable en lenguaje binario de la máquina que se trate. Además, no se necesita conocer el hardware específico de dicha máquina.
Aproximarse al lenguaje natural, para que el programa se pueda escribir y leer de una forma más sencilla, eliminando muchas de las posibilidades de cometer errores que se daban en el lenguaje máquina, ya que se utilizan palabras (en inglés) en lugar de cadenas de símbolos sin ningún significado aparente.
Incluir rutinas de uso frecuente como son las de entrada/salida, funciones matemáticas, manejo de tablas, etc, que figuran en una especie de librería del lenguaje, de tal manera que se pueden utilizar siempre que se quieran sin necesidad de programarlas cada vez.

4.-Explique porque la memoria ram, se le considera el escritorio de trabajo, en una computadora.

La memoria principal o RAM (Random Access Memory, Memoria de Acceso Aleatorio) es donde el computador guarda los datos que está utilizando en el momento presente. El almacenamiento es considerado temporal por que los datos y programas permanecen en ella mientras que la computadora este encendida o no sea reiniciada.


Se le llama RAM por que es posible acceder a cualquier ubicación de ella aleatoria y rápidamente
Físicamente, están constituidas por un conjunto de chips o módulos de chips normalmente conectados a la tarjeta madre. Los chips de memoria son rectángulos negros que suelen ir soldados en grupos a unas plaquitas con "pines" o contactos:

La diferencia entre la RAM y otros tipos de memoria de almacenamiento, como los disquetes o los discos duros, es que la RAM es mucho más rápida, y que se borra al apagar el computador, no como los Disquetes o discos duros en donde la información permanece grabada.

Tipos de RAM


Hay muchos tipos de memorias DRAM, Fast Page, EDO, SDRAM, etc. Y lo que es peor, varios nombres. Trataremos estos cuatro, que son los principales, aunque mas adelante en este Informe encontrará prácticamente todos los demás tipos.
· DRAM: Dinamic-RAM, o RAM DINAMICA, ya que es "la original", y por tanto la más lenta.
· Usada hasta la época del 386, su velocidad típica es de 80 ó 70 nanosegundos (ns), tiempo éste que tarda en vaciarse para poder dar entrada a la siguiente serie de datos. Por ello, es más rápida la de 70 ns que la de 80 ns.
· Físicamente, aparece en forma de DIMMs o de SIMMs, siendo estos últimos de 30 contactos.
· Fast Page (FPM): a veces llamada DRAM (o sólo "RAM"), puesto que evoluciona directamente de ella, y se usa desde hace tanto que pocas veces se las diferencia. Algo más rápida, tanto por su estructura (el modo de Página Rápida) como por ser de 70 ó 60 ns.

COMPUTACION EN MEXICO

BREVE HISTORIA DE LA COMPUTACION EN MEXICO.

El inicio de la computación en México se remonta al año de 1959, en que la Universidad Nacional Autónoma de México instala la primera computadora, la cual es seguida en algunos meses por la instalación de un computador en la Dirección General de Estadística y otra en el Seguro Social.
En los años siguientes, en el Centro de Computo de la UNAM, la Compañía IBM y equipos contables Europeos (bull ) se instaló en 1960 algunos equipos de cómputo que fueron utilizados en forma experimental por diversos organismos federales y privados, como preámbulo para que estos contrataran sus propios equipos. En los años siguientes, en el Centro de Computo de la UNAM, la Compañía IBM y equipos contables Europeos (bull ) se instaló en 1960 algunos equipos de cómputo que fueron utilizados en forma experimental por diversos organismos federales y privados, como preámbulo para que estos contrataran sus propios equipos.
Tal fue el caso de PEMEX, CFE, Ferrocarriles Nacionales, Compañía de luz, Banco Nacional de México y de algunas grandes industrias. Para 1965, el número de computadoras instaladas alcanzaba la cifra de 50. La capacitación inicial de personal técnico se origino dado un alto grado de interés provocado por la computadora de la UNAM, en donde principiaron a darse cursos que atrajeron a las nuevas generaciones de ingenieros, actuarios y físicos.
Las empresas proveedoras d equipo que en ese tiempo operaban y que se reducían Bull y IBM, contaba también con sus programas de capacitación con los que sustentaban la formación del personal de sus nuevos clientes.v
En muchas de estas organizaciones usuarias, el personal técnico requerido era seleccionado de la propia organización y entrenando para sus nuevas funciones. Estas tendencias de crecimiento se mantuvieron hasta fines de la década de los sesentas, años en que el número de las computadoras rebasaban las 350. En muchas de estas organizaciones usuarias, el personal técnico requerido era seleccionado de la propia organización y entrenando para sus nuevas funciones. Estas tendencias de crecimiento se mantuvieron hasta fines de la década de los sesentas, años en que el número de las computadoras rebasaban las 350.




Desarrollo de la computación en México.

La computación es una actividad profesional que induce a la creatividad, al desarrollo
de la capacidad intelectual y del pensamiento abstracto, por eso quienes nos hemos
dedicado por un tiempo a desarrollar aplicaciones o herramientas de trabajo en este
campo, podemos recordar con enorme satisfacción la mayor parte de los proyectos en
los que hemos participado. En un buen número de casos nos hemos quedado
sorprendidos de nuestros propios logros y de los alcanzados por los equipos de trabajo
de los que formamos parte.
Esta grata experiencia la podemos extrapolar en muchos casos a las organizaciones en
las que hemos colaborado, aunque no en todos, pues en algunos de ellos, la mala
definición de los problemas, la falta de organización y de metodologías apropiadas
llevaron a la decisión de suspender o de cancelar determinados proyectos, ante la
existencia evidente de fallas, o la falta de credibilidad por la acumulación de retrasos.
Aún así, muchos somos los que podamos considerar que la balanza es positiva, si bien
la experiencia es cada vez menor en la medida en que las tendencias naturales, se han
ido hacia la implantación de soluciones adquiridas de proveedores externos
(generalmente extranjeros) de manera que el valor agregado localmente resulta
mínimo.
En donde las cosas son totalmente distintas es cuando pensamos a escala nacional:
Aquí, aunque la participación de México no representa más del 1.5% del mercado
mundial, el volumen de las actividades computacionales es y ha sido enorme a lo largo
de los casi 50 años en que ellas se han realizado, sin embargo, las aportaciones de
nuestro país al desarrollo informático internacional durante este periodo han sido nulas,
hecho que resulta desde luego penoso además de grave.