APLICACIÓN DE LAS ESTRUCUTRAS DE CONTROL EN CÓDIGO SCILAB

Presentar en código scilab los diferentes diseños (herramientas de la

programación: diagrama de flujo, pseudocódigo, técnicas de N-S),
utilizando las estructuras de control: secuencial, selectiva: de una, de doble
alternativa, si anidado y alternativa múltiples y las estructuras repetitivas:
mientras, desde o para y hacer mientras; según el enunciado del problema
a desarrollar.
Aplicando las estructuras de control:
SECUENCIAL:
1.- Presente un programa sencillo que realice un saludo y muestre dicho
saludo y la cantidad de caracteres que utiliza.
function saludo()
clc // limpia la pantalla
// se genera un programa de saludo
mensa='SALUDOS A TODOS LOS ESTUDIANTES DE
LA CLASE';
disp('Muestra el valor de la variable mensa');
disp(mensa);
// mostrar la longitud de la variable mensa en la
variable c
c=length(mensa);
printf('La longitud de la variable mensa es
%4d\n',c);
printf('El mensaje asignado en el programa es
%s\n',mensa);
endfunction
Alcances:
Se debe tener presente que scilab trabaja mayormente con el tipo de dato
real de doble precisión, como también con reales de simple precisión. Estos
datos se guardan con un tamaño de 8 bytes que tiene un tamaño de 15
cifras exactas. Además del tipo real, se puede trabajar con strings, matrices,
hipermatrices y estructuras más avanzadas.
Dentro de los tipos de datos se tiene: números reales de doble precisión,
números complejos (complex), cadena de caracteres. Ver manual scilab
págs. 15 a 20.

Comentario:
1.- El saludo lo hace a través de una sentencia de asignación (operador de
asignación =) utilizando la variable mensa
2.- Presenta por pantalla el contenido de mensa (string - cadena de
caracteres) precedido de una hilera descriptiva.
3.- Utiliza la función length( ) que permite contabilizar el total de
caracteres de mensa y asigna a la variable c, que guarda un valor numérico
entero.
4.- Muestra por pantalla dos sentencias de salida (printf) a las variables c y
mensa con sus respectivos formatos de tipos de datos (códigos)
acompañados con hileras descriptivas.

2.- Lea una cadena por teclado en la variable cad

e indique el tamaño de dicha cadena

function lon_nom()
// ingrese una cadena
cad=input('Ingrese una cadena : ','s');
//determine la longitud de la cadena
num=length(cad); // num guardará un dato numérico
printf('La longitud de cad es %4d\n',num);//disp( )
endfunction
Comentarios:

3.- Calcula la constante de equilibrio para la reacción: N2(g) + 3H2(g) = 2

NH3(g)

function cons_equi()
// calcula la constante de equilibrio para una reaccion
// N2(g) + 3H2(g) = 2NH3(g)
clc;
clear;
delfG1=-16.6; //energía standar de Gibbs para NH3 en
KJ mol^-1
delfG2=0; //energía estandar de Gibbs para N2 en KJ
mol^-1
delfG3=0; //energia estandar de Gibbs para NH3 en KJ
mol^-1
delrGo=2*delfG1-(delfG2 + 3*delfG3); //energai
estandar de Gibbs cambia
//para la reacción KJ mol^-1
R=8.314;//Gas constante en JK^-1 mol^-1
T=298; // Temperatura en K
Kp=exp(-delrGo*1000/(R*T)); //Consatante de
equilibrio para la reaccion
//(constante de equilibrio para la reacción esta dado
por
//Kp=(PNH3/Pdeg)^2/((PN2/Pdeg)*(PH2/Pdeg)^2)
printf('constante de equilibrio = %.1f*10^5',Kp*10^-
5);
endfunction
ESTRUCTURA SELECTIVA

(a) Alternativa simple

En clases.

(b) Doble alternativa

4.- Se tiene inicialmente SbCl5 gaseoso y cuando el sistema alcanza el

equilibrio, la presión total del sistema es 1 atm. SbCl5(g)⇔SbCl3(g)+Cl2(g).
Hallar la presión parcial de SbCl5 en el equilibrio y el total de presiones.
Desarrollar el diagrama de Flujo y el Programa en Scilab.

function pres_parc()
// Se tiene inicialmente SbCl5 gaseoso y cuando el
sistema alcanza el equilibrio, la presión total del sistema
es 1 atm. SbCl5(g)⇔SbCl3(g)+Cl2(g). Hallar la presión
parcial de SbCl5 en el equilibrio y el total de presiones.
Desarrollar el diagrama de Flujo y el Programa en
Scilab.
.

clc

disp('Ejercicio: Se tiene inicialmente SbCl5 gaseoso y

cuando el sistema alcanza el equilibrio, la presión total
del sistema es 1 atm. SbCl5(g)⇔SbCl3(g)+Cl2(g)')
Kp=0.225
Pt=1 //en atm
x1=((-2*Kp)+sqrt((2*Kp)^2-(4*-1*Kp)))/2
x2=((-2*Kp)-sqrt((2*Kp)^2-(4*-1*Kp)))/2
if x1>=0 then
disp(x1,'Presión parcial del SbCl5 disociado: ')
P=Pt-x1
disp(P,'Presión inicial del SbCl5: ')
Peq_SbCl5=P-x1
disp(Peq_SbCl5,'Presión del SbCl5 en el equilibrio: ')
else
disp(x2,'Presión parcial del SbCl5 disociado: ')
 P=1-x2
disp(P,'Presión inicial del SbCl5: ')
Peq_SbCl5=P-x2
disp(Peq_SbCl5,'Presión del SbCl5 en el equilibrio: ')
end
endfunction
(c) Si anidado
(c.1):
function calif()
clc
//leer el dato a calificar
calif=input('Ingrese el dato a calificar : ');
if calif >= 90 then
disp(calif); disp('Calificación alta');
else
if calif >= 80 & calif < 90 then
disp(calif); disp('Calificacion buena');
else
if calif >=70 & calif < 80 then
disp(calif); disp('Calificación regular');
else
if calif >=69 & calif < 70 then
disp(calif); disp('Calificacion deficiente
');
else
disp(calif); disp('Calificacion muy
deficient ');
end
end
end
end
end
(c.2):
function califica_ifelse()
clc
//leer el dato a calificar
calif=input('Ingrese el dato a calificar :');
//utiliza ifelse
if calif >= 90 then
disp(calif); disp('A Calificación alta');
elseif calif >= 80 & calif < 90 then
disp(calif); disp('B Calificacion buena');
elseif calif >=70 & calif < 80 then
disp(calif); disp('C Calificación regular');
elseif calif >=69 & calif < 70 then
disp(calif); disp('D Calificacion
deficiente ');
else
disp(calif); disp('E Calificacion muy
deficient ');
end
endfunction
(d) Selectiva de múltiples alternativas

function menu_opciones()
clc
// diseñe un programa que presente un menu de 4
opciones
// cada opción resuelva usando la estructura
condicional de multiples
// alternativas
printf('\t\tMENU DE OPCIONES\n');
printf('\t 1.-Cadena - su longitud\n');
printf('\t 2.-Raiz cuadrada de un dato\n');
printf('\t 3.-Definir dato par o impar por teclado\n');
printf('\t 4.- Fin del Menu\n');
// proceda a seleccionar su opción
opc=input('Ingrese su opcion : ');
// se utiliza la estructura de selección switch
switch opc
case 1 then
cad=input('Ingrese una cadena :','s');
longi_cad=length(cad);
printf('Su longitud es %4d\n',longi_cad);
case 2 then
//lea un dato numerico entero
dato=input('Ingrese un dato : ');
//encuentre su raiz cuadrada
raizcua=sqrt(dato);
printf('La raiz cuadrada de %4d es %10.2f\n',dato,
raizcua);
case 3 then
// se lee dato por teclado
dato=input('Ingrese el dato a evaluar : ');
// se evalua el dato
if (modulo(dato,2)==0)
printf('El dato %5d es par \n',dato);
else
printf('El dato %5d no es par\n', dato);
end
case 4 then
printf('\t\t\tFIN DEL MENU\n');
otherwise
disp('Error en el ingreso de opción');
end //fin del switch
endfunction

Comentarios: