Sjsdnknerkjf

2018-1
[Programacion, Scilab]
Este curso está diseñado para llevar de la mano a personas totalmente ajenas al uso de esta
herramienta, iniciando con la etapa analizar y desglosar un problema en sentencias simples y
entendibles, para finalmente llegar a comprender y utilizar uno de los lenguajes más utilizados
en el área científica como lo es el Scilab.
[PROGRAMACIÓN, SCILAB]
Contenido
Introducción ........................................................................................................................................ 2
Scilab ................................................................................................................................................... 3
I.1 Conociendo la nueva herramienta .............................................................................................. 3
Principios de Programación ................................................................................................................ 6
II.1 Conceptos básicos de programación......................................................................................... 6
II.2 Operaciones básicas.................................................................................................................. 9
II.3 Principios de programación. ................................................................................................... 10
Tipos de Datos........................................................................................................................... 12
Instrucciones Condicionales ...................................................................................................... 13
Operadores relacionales ............................................................................................................ 14
Operadores lógicos .................................................................................................................... 15
Tablas de verdad de los operadores lógicos .............................................................................. 15
Instrucciones Cíclicas ................................................................................................................ 17
II.4 Vectores y matrices ............................................................................................................... 21
Vectores desde el teclado .......................................................................................................... 21
Matrices desde el teclado .......................................................................................................... 22
Operaciones matriciales. ........................................................................................................... 23
Algunas funciones matriciales. ................................................................................................. 26
II.5 Funciones y procedimientos ................................................................................................... 26
II.6 Manejo de archivos en Scilab ................................................................................................. 28
II.7 Gráficas................................................................................................................................... 32
ATOMS ............................................................................................................................................. 41
GUI Builder ................................................................................................................................... 41
Bibliografía ....................................................................................................................................... 42
Anexo No.1 ....................................................................................................................................... 44
RUBEN CASTAÑEDA BALDERAS 1

Introducción
La programación en el área científica es una herramienta importante e indispensable, sin la ella sería
imposible resolver algoritmos que requieren de un elevado número de operaciones o cuando
simplemente se tienen problemas donde la solución analítica no es una opción viable.
Empecemos imaginando que tenemos que resolver un sistema de tres incógnitas con sus respectivas
tres ecuaciones constitutivas, lo más sencillo es iniciar un modelo tradicional donde trabajemos
directamente en papel buscando la solución. Lo más probable es que no lleve poco tiempo y que la
exactitud de nuestro resultado dependa en gran medida del número de decimales después del punto
utilizadas en nuestra calculadora.
Ahora imaginemos que tenemos que resolver un sistema de cien incógnitas con sus respectivos cien
ecuaciones constitutivas, resolver dicho problema del modo tradicional nos llevaría demasiado
tiempo y quizás el resultado final este plagado de errores. Hacer lo mismo programando un método
numérico tal vez nos lleve un par de horas de trabajo, pero de solo pocos minutos para que la
computadora pueda resolverlo.
A pesar de que la programación se puede utilizar en un sin número de áreas del conocimiento, ha sido
encasillada como de uso exclusivo para aquellos que tienen una formación en el área de la informática
y de sistemas de computación. No obstante es una solución indispensable para todas las áreas del
conocimiento que requieren llevar más allá de lo ordinario su trabajo.
Este curso está diseñado para llevar de la mano a personas totalmente ajenas al uso de esta
herramienta, iniciando con la etapa analizar y desglosar un problema en sentencias simples y
entendibles, para finalmente llegar a comprender y utilizar una de las herramientas más utilizadas en
el área científica como lo es Scilab. A pesar de que el curso se enfoca en el uso de Scilab, el alumno
será capaz de programar en una diversidad de lenguajes como lo puede ser C, C++, MatLab, Pascal,
Java, Python etc.
Gran parte de la información aquí presentada ha sido recopilada de la lectura de muchos otros cursos
existentes en la red, como lo puede ser la plataforma edx.org, libros de principios de programación,
cursos de otras instituciones educativas, etc. Sin embargo la información ha sido adaptada y es
actualizada de acuerdo a las necesidades específicas de los alumnos de este curso en particular.

Scilab
I.1 Conociendo la nueva herramienta
SciLab es un lenguaje interpretado para cálculo científico, que fue desarrollado en 1990 por el
reconocido instituto francés de investigación INRIA (Institut National de Recherche en Informatique
et Automatique). Posteriormente colaboró en su desarrollo, la escuela de ingenieros ENPC (Ecole
Nationale de Ponts et Chaussées).
Desde mayo del 2003, es mantenido y desarrollado por “SciLab Consortium”, un consorcio de
empresas colaboradoras como Renault, Peugeot-Citroën, CEA (Commissariat à l'Energie Atomique),
CNES (Centre National d'Etudes spatiales), Dassault Aviation, EDF (Electricité de France), entre
otras.
Las facilidades de este software, es que nos permite hacer cálculos numéricos y algunos cálculos
simbólicos, como derivadas de funciones polinómicas y racionales. Posee cientos de funciones
matemáticas y la posibilidad de integrar programas en los lenguajes más usados (FORTRAN, Java y
C y C++).
Incluye numerosas herramientas: Gráficos 2D y 3D, álgebra lineal, matrices, resolución de sistemas
de ecuaciones diferenciales (explícita e implícita) y muchas cosas más que resultan de suma utilidad
para el estudio de las ciencias (matemática, física, química, astronomía, biología, etc.)
Sus principales características son:
 Software para cálculo científico.

 Interactivo
 Programable
 De libre uso, con la condición de siempre hacer referencia a sus autores.
 Y multiplataforma (Windows, Linux, etc.).
Scilab cuenta con un entorno de desarrollo que presenta distintas ventanas, las cuales cumplen con
una función en específico para facilitar la programación y el análisis del flujo de información en todo
momento.
La primera y más importante es la consola de Scilab (ver Figura No. 1), esta consola tiene como
finalidad correr cada uno de los comandos o instrucciones que vayamos tecleando y presentar los
resultados. Tiene la peculiaridad de poder acceder a comandos antes tecleados mediante el uso de las
teclas de navegación del teclado.

Figura No. 1 Consola de comandos de Scilab.
La segunda ventana llamada visualizador de variables o variable browser, nos permite observar las
variables que en este momento están en memoria activa, su tamaño y acceder directamente a sus
valores actuales (ver Figura No. 2).
Figura No. 2 Visualizador de variables

La tercera ventana con la que podemos contar dentro de Scilab es la del historial de comandos, en
esta podemos encontrar listados todos los comando utilizados durante una sesión de trabajo (ver
Figura No. 3), la ventana también permite exportar la tabla de contenido a un archivo de texto si se
desea consultar posteriormente.
Figura No. 3 Historial de comandos.

Principios de Programación
II.1 Conceptos básicos de programación.
Es importante iniciar con los conceptos básicos que nos permitirán adentrarnos poco a poco a la
programación, aprender su léxico, su función y el uso más cotidiano. El conocer la sintaxis y un
lenguaje de programación no nos convierte en programadores. La programación va más de la
mano en poder observar un problema y poder desglosarlo, de tal forma que, usando instrucciones
simples, que vayan paso a paso se pueda obtener el resultado deseado.
Algoritmo: En ocasiones hemos escuchado esta palabra, que en un inicio parece complicada de
describir pero podemos definirla simplemente como un método para resolver un problema mediante
una serie de pasos precisos, definidos y finitos. Precisos porque en todo momento debemos de tener
conocimiento del orden que sigue el flujo de mi información, definido porque conocemos la
transformación que sufre dicha información y finitos porque así como tiene un inicio debe de tener
un fin.
Programa: En ocasiones conocido como software, un programa de computadora, es una lista de

instrucciones paso a paso, escritas para una arquitectura de computadora, hace algunos años y para el
área de sistemas computacionales, cuando se hacía referencia a una arquitectura de computadora se
hablaba de un tipo de hardware y software específico de cada pc, sin embargo para fines prácticos del
curso hablamos por lo general en la plataforma de sistema operativo donde el programa debe de
correr, es decir si el programa corre en LINUX, WINDOWS, ANDROID, etc. etc.
La estructura básica de un programa contiene ver Figura No. 4:
 Entradas: Estos son los datos que alimentan a nuestro programa, por lo regular estos
provienen del teclado, archivos de texto, base de datos, etc.
 Procesos: Las operaciones que se realizan sobre los datos de entrada, es donde los datos
sufren una transformación.
 Salidas: Los resultados que salen de procesar la información inicial. Estas pueden ser
gráficas, imágenes, archivos de textos, registros en bases de datos, etc.
Lenguaje de programación: Es una técnica de comunicación estandarizada para describir las

instrucciones a una computadora. Cada lenguaje de programación tiene sus propias reglas de sintaxis
y semántica usadas que definen un programa de computadora.
Metodología: El proceso de la programación implica tener una metodología que nos guíe, para ello
se sugieren una serie de pasos que desglosan nuestro problema hasta llevarlo a un punto donde es más
sencillo comprender y entonces codificar. Sin embargo estos pasos son relativos al estilo de cada
programador, por ejemplo: habrá quienes con la experiencia prefieren realizar los pasos en el
momento de la codificación y otros que a pesar de esa experiencia prefieren hacerlo antes de la
codificación.

La metodología sugerida en este curso es la siguiente ver Figura No. 5:
1. Leer el problema: Un problema simple puede tornarse en uno sumamente complejo sino
entendemos de primera mano cual la problemática a resolver. Aquí es cuando la mayoría de los
novatos se diferencian de aquellos que tienen alguna experiencia previa. Para ello es
recomendable leer una y otra vez nuestro problema en busca de lagunas de información, conforme
leemos en repetidas ocasiones quizás esas lagunas vayan desapareciendo.
2. Hacer un análisis dividido en tres etapas:
 ¿Qué tenemos?: Con que información contamos para resolver nuestro problema.
 ¿Qué necesitamos?: Aparte de la información que me proporcionan necesito algo más o

es suficiente. Si es suficiente entonces que pasos debemos de hacer para resolver nuestro
problema.
 ¿Qué buscamos?: Finalmente que esperamos obtener como resultado.
Si después del análisis nos damos cuenta que la información con la que contamos no es suficiente
para llegar a nuestro resultado deducimos lo siguiente:
a) Nuestro problema está mal planteado y le falta información.

b) No hemos comprendido al 100% nuestro problema. Por lo tanto hay que regresar al paso no.1
de nuestra metodología.
3. Diseñar el algoritmo de solución: Ya que sabemos que nuestro problema si tiene solución, en lo
posible realizar un algoritmo en papel que resuelva mi problema. (Esta etapa generalmente
desaparece conforme el programador adquiere la suficiente experiencia del lenguaje de
programación y el control que tiene para visualizar los algoritmos al momento de codificar).
4. Codificar: Finalmente pasar este algoritmo al lenguaje de programación ideal para la resolución
de mi problema.
5. Comparar los resultados obtenidos contra los esperados, si no cumplen con nuestras expectativas
se procede a modificar de nuevo el algoritmo.
Nota:
 Los problemas de la vida real son un buen reflejo de programación, sin darnos cuenta
vivimos tomando decisiones, repitiendo patrones y procesando información.

Figura No. 4 Estructura básica de un programa
Figura No. 5 Pasos para resolver un problema.
Variable: En programación, una variable está formada por un espacio en el sistema de almacenaje
(memoria principal de un ordenador) y un nombre simbólico (un identificador) que está asociado a
dicho espacio. Ese espacio contiene información conocida o desconocida, es decir un valor. El
nombre de la variable es la forma usual de referirse al valor almacenado: esta separación entre nombre
y contenido permite que el nombre sea usado independientemente de la información exacta que
representa. Scilab diferencia las letras minúsculas de las mayúsculas, por lo cual una variable T y una
t minúscula pueden ser parte del mismo algoritmo y tener valores distintos. Los nombres en Scilab
constan hasta de 24 caracteres, el primero debe ser una letra o $, los subsecuentes pueden ser letras,
números, #, _, $, !.

Constante: En programación, una constante es un valor que no puede ser alterado/modificado durante
la ejecución de un programa, únicamente puede ser leído. Por ejemplo el valor de 𝜋 (%pi) o la
constante de Euler (%e).
II.2 Operaciones básicas

Para comenzar a trabajar en el entorno de Scilab y la programación es preciso iniciar con las
operaciones básicas que se pueden trabajar directamente en la consola, analizar sus alcances y
familiarizarse con el funcionamiento interno del lenguaje. Es importante en este punto hacer hincapié
que aún y cuando los ejercicios suelen ser sencillos, se deben de hacer en tiempo y forma.
Asignación de valores a una variable:

a=4
A=2.5
b=3.8
Suma:
Si x=3.5 calcular y= x+2.8
x=3.5
y=x+2.8
Resta:
Si x=31.75, calcular y=x-7.32
x=31.75
y=x-7.32
Multiplicación:
Si x=9.45, calcular y=6.92x+2.67
x=9.45
y=6.92*x+2.67
División:
Si x=32.97, calcular y=9.78/45.21x
x=32.97
y=9.78/(45.21*x)
Potenciación:
Si x=3, calcular x3
x=3
x^3
Raíz cuadrada:
Si x=81, calcular raíz cuadrada de x
x=81
sqrt(x)
Nota:
 La presencia de punto y coma al final de las ordenes hacen que Scilab no muestre el
resultado en pantalla. Sin embargo, la orden tuvo efecto.

Ejercicio No.1: Transforme la siguiente ecuación en sentencias que puedan ser comprendidas por la
computadora y evalúe la expresión suponiendo que x=3.28.
𝑥 3 (2𝑥 2 + 3.56𝑥 − 5.21)

𝑦=
√3𝑥 + 2.3
Ejercicio No.2: Transforme la siguiente ecuación en sentencias que puedan ser comprendidas por la
computadora y evalúe la expresión suponiendo que x=9.67, y=1.98.
𝑧 = (10𝑥 + 𝑦√3𝑦𝑥 4 + 𝑦 2 )(𝑥 3 + 𝑥𝑦 2 + 5.9)
Ejercicio No.3: Consideremos la ecuación general de segundo grado (ecuación cuadrática) que tiene
la forma:
𝑎𝑥 2 + 𝑏𝑥 + 𝑐 = 0
Resolver esta ecuación implica encontrar el valor o los valores de 𝑥 que cumplen con la expresión,
si es que existen. Para ello utilizamos la fórmula general que tiene la siguiente expresión:
−𝑏 ± √𝑏 2 − 4𝑎𝑐
𝑥=
2𝑎
Supongamos que contamos con los siguientes valores:
𝑎 = 15.35, 𝑏 = 200.9, 𝑐 = 34
Calcule el valor o los valores de 𝑥.
II.3 Principios de programación.

En este apartado aprenderemos basados en pequeños ejemplos como utilizar la lógica y el
conocimiento del lenguaje para realizar programas que servirán como base para posteriores trabajos
más complejos y ricos en conocimiento.
Para poder crear un programa debemos de hacerlo fuera de la consola de Scilab para ello hacemos
uso de SciNotes, esta herramienta nos permite crear un archivo con extensión .sce que posteriormente
mandaremos correr en la consola para obtener resultados.

Figura No. 6 SciNotes de Scilab.
Ejemplo No.1 Crearemos un programa que le solicite al usuario un par de números y que finalmente
presente las operaciones básicas aplicadas sobre estos: suma, resta, multiplicación y división.
// Programa de operaciones de un par de números opción básica

clear;
clc;
a = input("Dame el primer valor:");
b = input("Dame el segundo valor:");
disp(a+b,"La suma de a y b es:");
disp(a-b,"La resta de a y b es:");
disp(a*b,"La multiplicación entre a y b es:");
disp(a/b,"La división entre a y b es:");
Ejemplo No.2 Crearemos un programa que calcule el área de un triángulo si el usuario proporciona
la base y la altura.
//Programa para calcular el área de un triangulo

clear;
clc;
base = input("Introduce el valor de la base del triángulo:");
altura = input("Introduce el valor de la altura del triángulo:");
area = (base*altura)/2.0;
disp(area,"El área del triángulo es:");

Ejercicio No.4: Crea un programa que permita calcular el volumen de un pirámide de base
rectangular.
Ejercicio No.5: Crea un programa que permita calcular el área de una corona circular.
Ejercicio No.6: Crea un programa que implemente la fórmula general, permitiendo resolver las
ecuaciones de segundo grado que tienen la siguiente forma 𝑎𝑥 2 + 𝑏𝑥 + 𝑐 = 0.
Nota:
 Si en algún momento surge la duda de cómo usar un comando en particular solo basta
usar el comando help comando_a_buscar en la consola de Scilab para que aparezca la
ayuda sobre ese comando. Conforme vayan subiendo la complejidad de los ejemplos y
ejercicios se irán incorporando a nuestro léxico nuevos comandos y aprenderemos su
utilidad.
Hasta este momento hemos visto pequeños ejemplos utilizando siempre valores numéricos, sin
embargo Scilab cuenta con diferentes tipos de datos que puede manejar y dependiendo del tipo de
dato tiene restricciones aplicables sobre estos.
Tipos de Datos
Scilab tiene la peculiaridad de siempre trabajar con el tipo real de doble precisión, aun así cuenta con
la posibilidad de trabajar datos enteros, booleanos, strings, matrices, hipermatrices (arreglos de más
de dos dimensiones), estructuras de datos (agrupaciones bajo un mismo nombre de datos de naturaleza
diferente) y vectores o matrices de celdas (son vectores o matrices cuyos elementos pueden ser
cualquier otro tipo de dato).

Números reales de doble precisión

Los elementos constitutivos de vectores y matrices son números reales almacenados en 8 bytes (53
bits para la mantisa y 11 para el exponente de 2; entre 15 y 16 cifras decimales equivalentes). Por ello
es importante tomar en cuenta lo siguiente: aun y cuando los cálculos computacionales pueden ser
considerados con una alta precisión el número de dígitos después del punto o cifras decimales tienen
un límite predefinido, por lo tanto es siempre responsabilidad del usuario valorar sus estrategias de
programación para no trabajar con cifras sumamente opuestas que puedan provocar errores.
Existen algunos comandos que se pueden utilizar en la consola para conocer los límites máximos y
mínimos que pueden usarse en este tipo de datos.
 %eps devuelve la diferencia entre 1.0 y el número de coma flotante inmediatamente superior.
Da una idea de la precisión o número de cifras almacenadas.
 number_properties("tiny") devuelve el número más pequeño con que se puede trabajar.
 number_properties("huge") devuelve el número más grande con que se puede trabajar.
Números complejos (complex)

Scilab tiene la habilidad de manejar los números complejos, dado que en algunas ocasiones la gama
de números reales no es suficiente. Para ello Scilab tiene como variable compleja a:
 %i
Constantes
 ans nombre por defecto de la variable utilizada en los resultados no asignados a otra variable
directamente.
 %pi número pi.
 %e número de Euler.
 %nan indefinido.
 %inf infinito.
Instrucciones Condicionales
Son aquellas instrucciones en donde se tienen dos caminos, un camino cuando la condición es
verdadera y otra cuando es falsa. Si la condición dentro de la instrucción condicional es verdadera
entonces el programa entra en su estructura y efectúa una o más instrucciones que ahí están definidas,
de ser falsa la condición, el programa evita entrar en esa secuencia y continúa con el cuerpo del
programa ver Figura No. 7.
Figura No. 7 Estructura de una instrucción condicional simple.

Existen también condicionales compuestas-simples en donde si la condición es verdadera realiza una

serie de acciones y si es falsa otras totalmente distintas, al final ambas convergen en el cuerpo del
programa ver Figura No. 8.
Figura No. 8 Estructura de una instrucción condicional compuesta-simple.
También se cuentan con condicionales compuestas, estas consisten en una serie de condicionales
simples encadenadas, lo que permite que existan múltiples caminos y acciones antes de regresar al
cuerpo principal del programa ver Figura No. 9.
Figura No. 9 Estructura de una instrucción condicional compuesta.
Operadores relacionales
Para formar una condición que pueda ser evaluada dentro de las sentencias IF es necesario conocer
los operadores relacionales.
 a == b Realiza la comparación para saber si a es igual a b.

 a ~= b or a <> b Realiza una comparación para conocer si a es diferente de b.

 a < b Realiza una comparación para conocer si a es menor a b.

 a <= b Realiza una comparación para conocer si a es menor o igual a b.
 a > b Realiza la comparación para conocer si a es mayor a b.
 a >= b Realiza la comparación para conocer si a es mayor o igual a b.
Si la condición se cumple los operadores relacionales regresan un valor verdadero en caso contrario
un valor de falso.
Operadores lógicos
Los operadores lógicos de Scilab son los siguientes:
 & and
 | or
 ~ negación lógica
Tablas de verdad de los operadores lógicos
Operador lógico & Operador lógico | Operador lógico ~

a b resultado a b resultado a resultado
%T %T %T %T %T %T %T %F
%T %F %F %T %F %T %F %T
%F %T %F %F %T %T
%F %F %F %F %F %F
Ejemplo No.3: Crearemos un programa que dados dos valores de entrada, imprima siempre la
división del mayor entre el menor de los números.
//Programa que compara un par de números y regresa siempre la división del mayor entre el
menor
clear;
clc;
divi=0;
a=input("Introduce el valor de a:");
b=input("Introduce el valor de b:");
if a >= b then
divi = a/b;
else
divi = b/a;
end
disp(divi,"El resultado de la división es:");
Ejemplo No.4: Crearemos un programa que pida que se le den tres números, el programa deberá
de ser capaz de identificar cuál de los tres es el mayor.

//Cual número es el más grande de los tres

clear;
clc;
a = input("Dame el valor de a:");
b = input("Dame el valor de b:");
c = input("Dame el valor de c:");
if a > b & a > c then

disp("a es valor más alto");
elseif b > c then
disp("b es el valor más alto");
else
disp("c es el valor más alto");
end
Ejercicio No.7: Crea un programa que implemente la fórmula general, permitiendo resolver las
ecuaciones de segundo grado que tienen la siguiente forma 𝑎𝑥 2 + 𝑏𝑥 + 𝑐 = 0, siempre y cuando el
resultado no sea un número complejo. El programa debe de avisar al usuario que con los valores
que está introduciendo no se puede realizar el cálculo si así se amerita.
Ejercicio No.8: Escribe un programa que pida al usuario tres números, el primero de ellos asignado
a una variable día, el segundo al mes y finalmente el año, con los tres dígitos comprobar si la fecha
introducida es válida o invalida e informarle al usuario mediante un mensaje. Nota importante,
tomaremos en cuenta que febrero tiene 28 días y los años validos solo serán a partir del año 1.
Ejercicio No.9: Escribe un programa que dado un valor de x y z este sea evaluado en la siguiente
función discontinua y pueda determinar el valor de f(x,z).
𝑥 3 + 3𝑧 − 28 𝑠𝑖 𝑥 < 0 𝑦 𝑧 < 0
−𝑧 𝑠𝑖 𝑥 = 0 𝑜 𝑧 = 0
√4𝑥 2 𝜋 + 3.25
𝑓(𝑥, 𝑧) = 𝑠𝑖 𝑥 > 0 𝑦 𝑧 < 0
350 − 2.9𝑧
𝜋
9.45𝑥𝑧 3 + 2.93
{ 𝑒 𝑥𝑧 𝑠𝑖 𝑥 > 0 𝑦 𝑧 > 0
Ejercicio No.10: Escribe un programa que permita al usuario usar al Ley de Ohm. La ley de Ohm
establece una relación entre la intensidad de corriente (I) que circula por el circuito, la diferencia
de potencial (V) y la resistencia del mismo (R):
𝑉
𝐼=
𝑅
El programa deberá de presentar un mensaje donde indique que si el usuario quiere calcular la
intensidad debe de presionar el número 1, si desea el voltaje debe de presionar el número 2, si desea
el voltaje presionar el número 3. Una vez que conozcas la decisión del usuario solicita los datos
necesarios para realizar cada cálculo; por ejemplo si el usuario presiona el 1, es necesario solicitarle
el voltaje y la resistencia para poder realizar el cálculo de la intensidad. Finalmente el programa
debe de presentar el resultado.

Instrucciones Cíclicas
Las computadoras están diseñadas especialmente para todas aquellas pequeñas aplicaciones en las
cuales una operación o conjunto de ellas deben repetirse muchas veces. Las estructuras que repiten
una secuencia de instrucciones un número determinado de veces se denominan bucles y se denomina
iteración al hecho de repetir la ejecución de una secuencia de acciones.
Instrucciones Cíclicas (for)

En muchas ocasiones se conoce de antemano el número de veces que se desean ejecutar las acciones
de un ciclo. En estos casos, se debe de usar la estructura for. La estructura for ejecuta las acciones del
cuerpo del ciclo un número específico de veces y de modo automático controla el número de
iteraciones o pasos a través del cuerpo del mismo ver Figura No. 10.
Figura No. 10 Estructura de una instrucción cíclica desde hasta.
La estructura para hacer uso del for es la siguiente:
//esto se utiliza solo cuando no queremos incrementos de uno en uno
for índice=valor_inicial: incremento/decremento: valor_final
<comandos o instrucciones>
end
//esto se utiliza cuando queremos incrementos de uno en uno
for índice=valor_inicial:valor_final
end

Ejemplo No.5: Hacer un programa que imprima los números del 10000 al 0, en orden decreciente
en decrementos de 2.5 en 2.5.
//Programa que imprime los números en orden decreciente del 10000 al 0 en decrementos de 2.5
clear;
clc;
for i=10000: -1: 0
disp(i);
end
Ejemplo No.6: Crear un programa que despliegue las tablas de multiplicar de un número n que desee
el usuario desde (n x 1) hasta llegar a (n x m) según sea indicado. Por ejemplo el usuario indica que
desea la tabla del 5 hasta llegar al 5x4, en este ejemplo n=5 y m=4;
//Programa que pide la tabla y el número de veces que deseamos que se calcule
clear;
clc;
n = input("Dame el valor de la tabla que deseas calcular:");
m = input("Hasta que número deseas llegar:");
for i=1:m
disp(n*i);
end
Ejercicio No.11: Hacer un programa que pida un número y calcule el factorial de este. Recordemos
el factorial de un número es el producto de todos los enteros desde 1 hasta el número dado inclusive,
ejemplo. Factorial de 5 = 5x4x3x2x1= 120. Hay que verificar que el número que introduzca el
usuario sea mayor a 0 antes de realizar las operaciones sobre este.
Ejercicio No.12: Hacer un programa que pida un número y presente la suma del número a la
potencia del mismo hasta llegar a 1. Ejemplo. 5 = 54+43+32+21+10
Ejercicio No.13: Escribe un programa que solicite un número y realice una sumatoria desde ese
número hasta llegar al 1, con la siguiente condición, si el número es par se eleva al cubo, si es impar
se eleva al cuadrado antes de ser sumado. Te puedes auxiliar del comando pmodulo. Ejemplo. 8 =
83+72+63+52+43+32+23+12
Ejercicio No.14: Hacer un programa para la sucesión de Fibonacci. La sucesión de Fibonacci es la

siguiente: 1, 1, 2, 3, 5, 8, 13, 21, 34,…
Es decir, f1=1, f2=1, y cada uno de los siguientes términos de la sucesión se calculan sumando los
dos anteriores: fi = fi-1+fi-2. El programa debe de pedir al usuario cuantos valores de la serie se desean
calcular y presentarlos al usuario.
Ejercicio No.15: Crea un programa que lance n veces un dado virtual utilizando el comando
variable=floor(rand()*6)+1, tendrás que calcular cuantas veces apareció cada uno de los números
del 1 al 6. El valor de n será solicitado al usuario.

Instrucciones Cíclicas (while)

La estructura repetitiva while es aquella en que el cuerpo del ciclo se repite mientras se cumple una
determinada condición. Cuando se ejecuta la instrucción while la primera cosa que sucede es que se
evalúa la condición (una expresión booleana). Si se evalúa falsa, no se toma ninguna acción y el
programa prosigue en la siguiente instrucción fuera del ciclo. Si la expresión booleana es verdadera,
entonces se ejecuta el cuerpo del ciclo, después de lo cual se evalúa de nuevo la expresión booleana.
Este proceso se repite una y otra vez mientras la expresión booleana (condición) sea verdadera ver
Figura No. 11 .
Figura No. 11 Estructura de una instrucción cíclica mientras.
La estructura para hacer uso del while es la siguiente:
while (condicional)
end
Ejemplo No.7: Crear un programa que pida al usuario un número, si el número introducido es mayor
a cero deberá de sumarlo a una variable acumulativa y volver a preguntar por otro número, sin
embargo si el número es menor o igual a 0, dejara de preguntar, procederá a calcular y presentar el
promedio de los anteriores n dígitos introducidos.

//Programa que pide n veces un número y si es menor o igual a 0 salir y dar el promedio de los n-
1 números anteriores
clear;
clc;
conta = 0;
acumu = 0;
prom = 0;
x = input("Dame un número:");
while (x > 0)
conta = conta+1;
acumu = acumu+x;
x = input("Dame un número:");
end
prom = acumu/conta;
disp(conta,"El número de valores capturados es:")
disp(prom,"El promedio de todos los número introducidos es:");
Ejercicio No.16: Escribe un programa que pida al usuario tres números, el primero de ellos asignado
a una variable día, el segundo al mes y finalmente el año, con los tres dígitos comprobar si la fecha
introducida es válida. Mostrar un mensaje al usuario de si la fecha está correctamente o no escrita,
el programa terminara hasta que el usuario introduzca una fecha válida. Nota importante,
tomaremos en cuenta que febrero tiene 28 días y los años serán a partir del año 1.
Ejercicio No. 17: Escribe un programa que pueda calcular el máximo común divisor de un par de
números enteros positivos a y b. Como recordatorio, el máximo común divisor es el número entero
más grande que divide a cada uno de los números sin tener residuo. Por ejemplo:
El máximo común divisor de 2 y 12 es 2
Un tip es comenzar a probar con un número igual al más pequeño de ambos números introducidos
por el usuario y reducir iterativamente este valor de prueba en 1 hasta llegar al caso donde dicho
valor pueda dividir tanto a a como a b sin dejar residuo o simplemente finalizar si ese valor de prueba
llego a 1.
Ejercicio No. 18: Escribe un programa que le permita a la computadora adivinar un número entero
entre 0 y 100 que el usuario introduzca por medio del teclado, utilizando el siguiente algoritmo:
𝑙𝑖+𝑙𝑠
 Calcular un número entero intermedio entre el límite inferior y el superior 2 (utiliza el
comando int para truncar la parte decimal).
 Presentarle el número al usuario y preguntarle lo siguiente: Este es tu número presiona 1,
el número es más pequeño al número que introdujiste presiona 2, el número es más grande
al número que introdujiste presiona 3.
 Si el usuario eligió la opción 1, el programa deberá de decir, “Te adivine tu número, el
número es” y presentar el número.

 Si el usuario eligió la opción 2, el programa cambiara su límite inferior por el número

calculado y continuara calculando un nuevo número y preguntando hasta encontrar el
resultado.
 Si el usuario eligió la opción 3, el programa cambiara su límite superior por el número
calculado y continuara calculando un nuevo número y preguntando hasta encontrar el
resultado.
Ejercicio No.19: Realizar un programa que calcule la raíz cuadrada mediante un método iterativo.
El cálculo de √𝑥 puede realizarse de forma aproximada mediante un método iterativo. Se estima
𝑥
inicialmente la solución como 𝑆𝑖 = lo cual sólo es cierto en el caso de x=4. Seguidamente
2
𝑆𝑖2 −𝑥
calculamos una nueva aproximación 𝑆𝑖+1 = 𝑆𝑖 − .
2𝑆𝑖
Si la diferencia en valor absoluto entre las dos aproximaciones es inferior a cierto umbral o error,
|𝑆𝑖+1 − 𝑆𝑖 | < 𝑒𝑟𝑟𝑜𝑟 damos por buena la última aproximación, sino realizamos una nueva
aproximación. El programa deberá de solicitar el umbral de error y el valor de x al cual se le quiere
calcular la raíz.
Ejercicio No.20: Aproximación del sin por medio de la serie de Taylor.

𝒏
(−𝟏)𝒌
𝒔𝒊𝒏(𝒙) ≈ ∑ 𝒙𝟐𝒌+𝟏
(𝟐𝒌 + 𝟏)!
𝒌=𝟎
Lo ideal en una serie de Taylor es que n tienda al infinito y entonces estaremos más cerca del valor
real de sin(x), sin embargo nosotros terminaremos el programa cuando la diferencia entre la
aproximación en k y de k+1 sea menor a un error dado por el usuario. Realizar un programa que
pida el valor de x en grados, lo convierta a radianes y aplique la aproximación y dé como resultado
el sin de ese valor x.
II.4 Vectores y matrices

Scilab es una herramienta de cálculo muy potente en lo que a matrices se refiere, en Scilab no hay
vectores como tales, los vectores se deben asimilar a matrices de una sola fila o vectores fila (tamaño
1 x n) o a matrices de una sola columna o vectores columna (tamaño n x 1).
Vectores desde el teclado

Tipo de comando Expresión general Ejemplo
Definición de un vector fila 𝑎 = [𝑛1 , 𝑛2 , 𝑛3 , … , 𝑛4 ] f=[45,75,76,89]
𝑎 = [𝑛1 𝑛2 𝑛3 … 𝑛4 ] f=[45 75 76 89]
Vector fila de unos 𝑎 = 𝑜𝑛𝑒𝑠(1, 𝑚) d=ones(1,9)
m = número de elementos
Vector fila de ceros 𝑎 = 𝑧𝑒𝑟𝑜𝑠(1, 𝑚) h=zeros(1,5)
Vector fila de números 𝑎 = 𝑟𝑎𝑛𝑑(1, 𝑚) z=rand(1,7)
aleatorios m = número de elementos

Vector fila con elementos 𝑎 = 𝑙𝑖: 𝑙𝑠 a=1:15

espaciados uniformemente de li es el límite inferior
uno en uno ls es el límite superior
Vector fila con elementos 𝑎 = 𝑙𝑖: 𝑝𝑎𝑠𝑜: 𝑙𝑠 a=7:0.01:9
espaciados dado un incremento li es el límite inferior
ls es el límite superior
paso es el paso entre cada
número del vector
Vector fila con elementos 𝑎 = 𝑙𝑖𝑛𝑠𝑝𝑎𝑐𝑒(𝑙𝑖, 𝑙𝑠, 𝑛𝑒) n=linspace(3,5,100)
linealmente espaciados li es el límite inferior
ls es el límite superior
ne es el número de elementos que
se deben de generar entre el
límite inferior y el superior
Definición de un vector 𝑎 = [𝑛1 ; 𝑛2 ; 𝑛3 ; … ; 𝑛4 ] f=[45;75;76;89]
columna
Vector columna de unos 𝑎 = 𝑜𝑛𝑒𝑠(𝑚, 1) d=ones(9,1)
Vector columna de ceros 𝑎 = 𝑧𝑒𝑟𝑜𝑠(𝑚, 1) h=zeros(5,1)
Vector columna de números 𝑎 = 𝑟𝑎𝑛𝑑(𝑚, 1) z=rand(7,1)
aleatorios m = número de elementos
Tamaño de un vector (no 𝑛 = 𝑙𝑒𝑛𝑔𝑡ℎ(𝑎) f=[45,75,76,89]
importa si es fila o columna) a es el nombre del vector tam=length(f)
Ingresar al elemento de un 𝑎(𝑝) f(4)
vector p es la posición del dato dentro
del vector, p siempre debe de ser
>= 1
Matrices desde el teclado

Tipo de comando Expresión general Ejemplo
Definición de una matriz 𝐴 = [𝑛11 , 𝑛12 , 𝑛13 , … , 𝑛1𝑚 ; A=[1,2,3;20,35,45;50,70,80]
𝑛21 , 𝑛22 , 𝑛23 , … , 𝑛2𝑚 ;
𝑛𝑘1 , 𝑛𝑘2 , 𝑛𝑘3 , … , 𝑛𝑘𝑚 ]
Matriz de unos 𝐴 = 𝑜𝑛𝑒𝑠(𝑛, 𝑚) D=ones(5,9)
n = número de renglones
m = número de columnas
Matriz de ceros 𝐴 = 𝑧𝑒𝑟𝑜𝑠(𝑛, 𝑚) H=zeros(2,5)
Matriz de números aleatorios 𝐴 = 𝑟𝑎𝑛𝑑(𝑛, 𝑚) Z=rand(3,3)
Matriz identidad 𝐴 = 𝑒𝑦𝑒(𝑛, 𝑛) B=eye(4,4)
n = número de renglones y
columnas de la matriz
Ingresar al elemento de una 𝐴(𝑖, 𝑗) B(1,3)
matriz i es el renglón donde está
posicionado el dato

j es la columna donde está

posicionado el dato
Número de elementos de una 𝑛 = 𝑙𝑒𝑛𝑔𝑡ℎ(𝐴) F=[45,75;76,89]
matriz A es el nombre de la matriz tam=length(F)
Número de renglones y 𝑛 = 𝑠𝑖𝑧𝑒(𝐴) t=size(F)
columnas de una matriz A es el nombre de la matriz
Creación de una matriz a partir 𝐵 = 𝐴(𝑟𝑖: 𝑟𝑠, 𝑐𝑖: 𝑐𝑠) B=A(1:5,4:6)
de otra ri = renglón inferior B=A(:,1:3)
rs = renglón superior B=A(4:6,:)
ci = columna inferior
cs = columna superior
Operaciones matriciales.
Suma y resta de matrices: La suma o resta de dos matrices A ± B con dimensiones 𝑚 − 𝑝𝑜𝑟 − 𝑛, se
calcula como sigue:
[𝐴 ± 𝐵]𝑖,𝑗 = 𝐴𝑖,𝑗 ± 𝐵𝑖,𝑗
donde 1 ≤ 𝑖 ≤ 𝑚 𝑦 1 ≤ 𝑗 ≤ 𝑛.
Ejemplo:
Ejemplo No.8: Realizar un programa que haga la suma de un par de matrices utilizando el
procedimiento de la suma antes descrita.
//Programa para la suma de un par de matrices

clear
clc
//Definición de las matrices A y B
A=[1 3 1; 1 0 0];
B=[0 0 5; 7 5 0];
//Sacar el tamaño de las matrices

C=size(A);
for i=1: C(1)

for j=1: C(2)
D(i,j)=A(i,j)+B(i,j);
end
end
disp(D);

Multiplicación de una matriz por un escalar: La multiplicación 𝑘A de una matriz A y un número

escalar 𝑘 resulta de multiplicar cada entrada de A por k:
𝑘[𝐴]𝑖,𝑗 = 𝑘 ∙ 𝐴𝑖,𝑗
Ejemplo:
Ejemplo No.9: Realizar un programa que haga la multiplicación de una matriz por un escalar
utilizando el procedimiento antes descrito.
//Programa para multiplicar una matriz A por un escalar c

clear
clc
//Definición de la matriz A y el escalar c
A=[1 8 -3; 4 -2 5];
c=2;
//Sacar el tamaño de la matriz

B=size(A);
for i=1: B(1)

for j=1: B(2)
D(i,j)=c*A(i,j);
end
end
disp(D);
Transpuesta de una matriz: La transposición de una matriz de 𝑚 − 𝑝𝑜𝑟 − 𝑛 llamada A es la matriz

𝑛 − 𝑝𝑜𝑟 − 𝑚 A𝑇 formado por el giro de filas en columnas y viceversa:
[𝐴]𝑖,𝑗 = [𝐴𝑇 ]𝑗,𝑖
Ejemplo:
Ejemplo No.10: Siguiendo el procedimiento anterior generar un programa que saque la transpuesta
de una matriz.

//Programa para la transpuesta de una matriz

clear
clc
//Definición de la matriz A
A=[1 2 3; 0 -6 7];
//Sacar el tamaño de la matriz

B=size(A);
for i=1: B(1)

for j=1: B(2)
At(j,i)=A(i,j);
end
end
disp(At);
Producto matricial: El producto matricial de dos matrices se define sólo si el número de columnas
de la matriz de la izquierda es el mismo que el número de filas de la matriz de la derecha. Si A es una
matriz 𝑚 − 𝑝𝑜𝑟 − 𝑛 y B es una matriz 𝑛 − 𝑝𝑜𝑟 − 𝑝, entonces su producto matricial AB es la matriz
𝑚 − 𝑝𝑜𝑟 − 𝑝 cuyas entradas vienen dadas por producto escalar de la fila correspondiente de A y la
correspondiente columna de 𝐵:
𝑛
[𝐴𝐵]𝑖,𝑗 = 𝐴𝑖,1 𝐵1,𝑗 + 𝐴𝑖,2 𝐵2,𝑗 + ⋯ + 𝐴𝑖,𝑛 𝐵𝑛,𝑗 = ∑ 𝐴𝑖,𝑟 𝐵𝑟,𝑗

𝑟=1
donde 1 ≤ 𝑖 ≤ 𝑚 𝑦 1 ≤ 𝑗 ≤ 𝑝 . Por ejemplo, la entrada subrayada 2340 en el producto se calcula

como (2 x 1000) + (3 x 100) + (4 x 10) = 2340:
0 1000
2 3 4 3 2340
[ ] [1 100 ] = [ ]
1 0 0 0 1000
0 10
Ejercicio No.21: Realizar un programa que calcule la multiplicación de un par de matrices, A y B.
Multiplicación de elemento por elemento correspondiente: El producto matricial sigue una serie de
reglas que permiten determinar la matriz resultante a partir de la iteración y suma entre sus filas por
columnas. Sin embargo en ocasiones podemos requerir multiplicar una matriz contra otra pero que
cada elemento se multiplique únicamente contra el elemento en la misma posición pero de la otra
matriz, dicho de otro modo.
[𝐴. 𝐵]𝑖,𝑗 = 𝐴𝑖,𝑗 𝐵𝑖,𝑗
Ejemplo:
0.1 0.2 2 1 0.2 0.2

[ ].[ ]=[ ]
0.7 0.1 3 4 2.1 0.4

Ejercicio No.22: Realizar un programa que calcule la multiplicación elemento por elemento de un
par de matrices, A y B.
Nota:
La forma vista para realizar operaciones sirve para que los alumnos comprendan los procesos
que tiene que realizar una computadora para sumar matrices, multiplicar etc. Sin embargo Scilab
tiene predefinidas funciones para evitar tal disyuntiva.
Sumar dos matrices en Scilab: Si A es una matriz y B otra matriz es tan sencillo como poner A+B,
restar una matriz a otra A-B, multiplicar una matriz A*B.
Algunas funciones matriciales.
Sumatoria de elementos de una matriz:

𝑛 𝑚
𝑆𝑢𝑚𝑎 = ∑ ∑ 𝐴𝑖,𝑗
𝑖=1 𝑗=1
Ejercicio No.23: Realizar un programa que calcule la sumatoria de una matriz A.
Ejercicio No.24: Realizar un programa que calcule la productoria de una matriz A.
Ejercicio No.25: Realice un programa que dada un matriz m x n aleatoria, busque el valor máximo
y su posición dentro de la matriz.
Nota:
 Existe el comando min que es semejante al max la diferencia está en que este busca el
mínimo.
 Mean es otro comando que se puede usar en los vectores o las matrices, este calcula el
promedio de la matriz o el vector.
 Median comando semejante a mean pero para la mediana.
 St-deviation semejante a mean pero para la desviación estándar.
 Sum semejante a mean pero para la suma.
 Prod semejante a mean pero para el producto.
 Norm(x) calcula la norma euclidiana del vector x.
II.5 Funciones y procedimientos
Una función o procedimiento tiene la finalidad de realizar tareas específicas que por alguna razón se
repetirán un número de veces en el programa principal. Los subprogramas ayudan a tener más legible
nuestro código y localizar errores.
La estructura de la función es la siguiente:
function [var_sa11,var_sal2,…,var_saln]=nombre_funcion(var_entra1,var_entra2,…,var_entran)

proceso1
proceso2
proceson
endfunction
Ejemplo No.11: Convertiremos los Ejercicios No.4, No.5, No.8, No.17, No.19 en funciones.
Ejercicio No.26 Hacer una función para la sucesión de Fibonacci utilizando vectores. La sucesión
de Fibonacci es la siguiente: 1, 1, 2, 3, 5, 8, 13, 21, 34,…
Es decir, f1=1, f2=1, y cada uno de los siguientes términos de la sucesión se calculan sumando los
dos anteriores: fi = fi-1+fi-2. La función tendrá como parámetros de entrada el número de términos
que desea el usuario se calculen y devolver el vector con los elementos de la serie de Fibonacci.
Ejercicio No. 27: Hacer una función que implemente la criba de Eratóstenes. Eratóstenes era un
griego que se dio cuenta que si en una lista de números tachaba todos los múltiplos de cada primo,
en la lista solo quedaban primos. La función deberá de utilizar este método para calcular los número
primos existentes de 1 hasta el límite superior que desee el usuario. Los parámetros de entrada es el
límite superior y de salida la función debe de regresar en un vector la lista de número primos
comprendidos entre el 1 y el límite superior. Ejemplo:
Tenemos un vector con los primeros 40 valores.
Iniciamos buscando los números primos a partir del número 2, tachando todos los múltiplos de dos,
esto lo hacemos brincando de dos en dos las posiciones del vector y sustituyendo el valor por un 0.

Seguido de esto se procede a buscar la siguiente posición en el vector que sea distinta a 0, y
procedemos a brincar entre posiciones de acuerdo al número seleccionado.
Continuamos haciendo esta acción hasta que hayamos recorrido todo el vector en busca de un
número por borrar.
Al final solo quedaran los números primos en el vector.
II.6 Manejo de archivos en Scilab
Scilab maneja algunos comandos para el manejo de archivos, en este momento analizaremos la
utilización de dos de ellos que a nuestro punto de vista son los más sencillos.
El primero de estos es el comando read, su estructura para utilizarlo es la siguiente:
variable = read(“nombre_del_archivo”,no_filas,no_columnas);

En la variable se cargara el archivo, si este consta de varias columnas y renglones entonces la variable
se convertirá en una matriz. Si en nuestro archivo no conocemos de antemano el número de filas
podemos poner como dato -1, esto le dirá a Scilab que cargue todas las filas del archivo.
Algo muy importante a tomar en cuenta, es que el archivo debe de estar guardado en la carpeta de
trabajo de Scilab de lo contrario jamás se podrá cargar el archivo en la variable. Sin embargo podemos
hacer uso de un par de comandos para cambiar esa carpeta de trabajo originalmente dispuesta por
Scilab a la carpeta donde trabajas actualmente.
Primeramente usamos el comando pwd() este comando nos mostrara la ruta actual de trabajo de
Scilab, si esta ruta no es la ruta donde tienes el archivo entonces procedemos a utilizar el comando
chdir(“nuevaruta”), este comando se encargara de cambiar la ruta anterior por la ruta que tu
dispongas y donde se supones tendrás el archivo de texto guardado.

Ejercicio No.28: Crear una función que reciba los valores de un vector x proveniente del archivo
datos28.txt y determinar lo siguiente:
La suma de todos ellos:

𝑛
𝑆 = ∑ 𝑥𝑖
𝑖=1
La suma de los cuadrados:

𝑛
𝑆𝑐 = ∑ 𝑥𝑖2
𝑖=1
La media:
𝑆
𝑀=
𝑛
La varianza:
𝑆𝑐
𝑉= − 𝑀2
𝑛
La desviación típica:
𝑠 = √𝑉
El mayor de los datos y su posición
El menor de los datos y su posición

La función debe de recibir el vector x con los datos y regresar en una sola variable cada uno de los
cálculos solicitados. Para este ejercicio revisar el uso del comando struct.
Ejercicio No.29: Método de la burbuja.
El primer ordenamiento que presentamos es quizá el más ampliamente conocido entre los estudiantes
que se inician en la programación. Una de las características de este ordenamiento es que es fácil
de entender y programar. Aunque, es uno de los algoritmos más ineficiente.
La idea básica subyacente en el ordenamiento de burbuja es pasar a través del arreglo de datos
varias veces en forma secuencial. Cada paso consiste en la comparación de cada elemento en el
arreglo con su sucesor (x[i] con x[i+1]) y el intercambio de los dos elementos si no están en el orden
correcto. Considérese el siguiente arreglo de datos:
25 57 48 37 12 92 86 33
En el primer paso se realizan las siguientes operaciones:
x[1] con x[2] (25 con 57) no intercambio.
x[2] con x[3] (57 con 48) intercambio.
x[5] con x[6] (57 con 92) no intercambio.
Así después del primer paso, el arreglo está en el siguiente orden:
25 48 37 12 57 86 33 92
Obsérvese que después del primer paso, el elemento mayor (en este caso 92) está en la posición
correcta dentro del arreglo. En general x[n-i] estará en su posición correcta después de la iteración
i. El método se lama ordenamiento de burbuja porque cada número “burbujea” con lentitud hacia
su posición correcta.
Tips:
 Para intercambiar un valor entre dos variables distintas o dos posiciones de una matriz o de
un vector se utiliza una variable auxiliar de la siguiente manera.
A=10, B = 15 intercambiar el valor de A a B y viceversa.
aux = A
A=B
B = aux

C = 15 25 35 45 intercambiar el valor de C en la posición 1 con la posición 4 y viceversa.

aux = C(1)
C(1) = C(4)
C(4) = aux
 El método de la burbuja debe de comparar x(i) con la posición x(i+1) pero solo hasta que i
llegue a n-1 siendo n el número total de elementos en el vector.
 El recorrido anterior se hace n-1 veces para que puedas tener la certeza de tener acomodado
el vector.
Crea una función que reciba un vector con los elementos en desorden y regrese el mismo vector pero
ordenado.
Ejercicio No.30: Método de selección.
Este método de ordenación consta de los siguientes pasos (suponiendo ordenación de menor a
mayor).
 Buscamos el menor elemento del vector. Lo intercambiamos por el primero en la lista.

 Buscamos el menor elemento del vector iniciando del segundo elemento. Lo intercambiamos
por el segundo.
 Así sucesivamente…
Crea una función que reciba un vector con los elementos en desorden y regrese el mismo vector pero
ordenado.
Ejemplo 12: Hacer uso del comando gsort(x','lr','i'), para poder hacer el ordenamiento de datos más
simple, utilizando herramientas propias de Scilab.
II.7 Gráficas
Una de las funcionalidades que identifica más a Scilab es la forma relativamente fácil de graficar. A
diferencia de muchos lenguajes de programación donde tienes que apoyarte de elementos externos
para graficar o donde tienes que desarrollar el programa que grafique lo que deseamos, Scilab
incorpora herramientas que con simples comandos puede llegar a presentar gráficas de muy alta
calidad y funcionalidad.
Ejemplo No.13: Crearemos un programa que dada una función en un intervalo grafiquemos los
resultados. En este primer ejemplo de graficación usaremos la programación de funciones.
Dada la siguiente función:
𝑥 3 (2𝑥 2 + 3.56𝑥 − 5.21)

𝑦=
√3𝑥 + 2.3
En un intervalo de [0.1,38.5]
//Programa que grafica una función en un rango de datos

xdel(winsid());//se encarga de borrar las gráficas si estas ya existen
clear
clc
function y=fx(x)//Función encargada de obtener los valores de y en cada valor de x
for i=1:length(x)
y(i)=(x(i)^3*(2*x(i)^2+3.56*x(i)-5.21))/sqrt(3*x(i)+2.3);
end
endfunction
//Definición los valores

x = linspace(0.1,38.5,100);
y=fx(x);
plot(x,y);
xlabel("$0\le x\le 38.5$","fontsize",4,"color","red");
ylabel("$y(x)=\frac{x^3(2x^2+3.56x-5.21)}{\sqrt{3x+2.3}$","fontsize",4,"color","red");
title("Gráfica de la función","color","red","fontsize",4);
Opciones del plot:
plot(varx,vary,”LíneaColorMarca”)
Línea Color Marca

- Sólida r rojo + más
-. Raya y punto g verde o círculo
: Punteada b azul *asterisco
c cyan . punto
m magenta x por
y amarillo s cuadrado
k negro d rombo
w blanco ^ v < > triángulos
Ejemplos:
plot(x,y,”-r.”);
plot(x,y,”-g+”);
plot(x,y,”y”);
plot(x,y,”s”);

Ejemplo No.14: Crear un programa que grafique el resultado de un par de funciones
Dada las siguientes funciones:
𝑥 3 (2𝑥 2 + 3.56𝑥 − 5.21)

𝑦=
√3𝑥 + 2.3
𝑧 = (10𝑥 + 𝑦√3𝑦𝑥 4 + 𝑦 2 )(𝑥 3 + 𝑥𝑦 2 + 5.9)
//Programa que grafique un par de dos funciones

clear
clc
for i=1:length(x)
y(i)=(x(i)^3*(2*x(i)^2+3.56*x(i)-5.21))/sqrt(3*x(i)+2.3);
end
endfunction
function z=fxy(x, y)//Función encargada de obtener los valores de y en cada valor de x

for i=1:length(x)
z(i)=(10*x(i)+y(i)*sqrt(3*y(i)*x(i)^4+y(i)^2))*(x(i)^3+x(i)*y(i)^2+5.9);
end
endfunction

x = linspace(0.1,38.5,100);
y=fx(x);
z=fxy(x,y);
plot(x,y,"red");
plot(x,z,"blue");
xlabel("$0\le x\le 38.5$","fontsize",4,"color","black");
ylabel("Valores de la funcion 1 y 2","fontsize",4,"color","black");
title("Gráfica de las funciones","color","black","fontsize",4);
legend(["$y=\frac{x^3(2x^2+3.56x-
5.21)}{\sqrt{3x+2.3}$";"$z=(10x+y\sqrt{3xy^4+y^2})(x^3+xy^2+5.9)$"]);

Ejemplo No.15: Crear un programa basado en el ejemplo anterior pero utilizando subplot.
Dada las siguientes funciones:
𝑥 3 (2𝑥 2 + 3.56𝑥 − 5.21)

𝑦=
√3𝑥 + 2.3
𝑧 = (10𝑥 + 𝑦√3𝑦𝑥 4 + 𝑦 2 )(𝑥 3 + 𝑥𝑦 2 + 5.9)
//Programa utilizando el subplot

clear
clc
for i=1:length(x)
y(i)=(x(i)^3*(2*x(i)^2+3.56*x(i)-5.21))/sqrt(3*x(i)+2.3);
end
endfunction

for i=1:length(x)
end
endfunction

x = linspace(0.1,38.5,100);
y=fx(x);
z=fxy(x,y);
subplot(2,1,1);
plot(x,y,"red");
ylabel("Valores de la función1","fontsize",4,"color","black");
legend("$y=\frac{x^3(2x^2+3.56x-5.21)}{\sqrt{3x+2.3}$","color","black","fontsize",4);
subplot(2,1,2);
plot(x,z,"blue");
ylabel("Valores de la funcion2","fontsize",4,"color","black");
legend("$z=(10x+y\sqrt{3xy^4+y^2})(x^3+xy^2+5.9)$","color","black","fontsize",4);

Ejemplo No.16: Crear un programa basado en el ejemplo anterior pero utilizando gráficas
separadas.
//Programa utilizando el gráficas separas

clear;
clc;
for i=1:length(x)
y(i)=(x(i)^3*(2*x(i)^2+3.56*x(i)-5.21))/sqrt(3*x(i)+2.3);
end
endfunction

for i=1:length(x)
end
endfunction

x = linspace(0.1,38.5,100);
y=fx(x);
z=fxy(x,y);
scf;
plot(x,y,"red");
ylabel("$y=\frac{x^3(2x^2+3.56x-5.21)}{\sqrt{3x+2.3}$","fontsize",4,"color","black");
scf;
plot(x,z,"blue");
ylabel("$z=(10x+y\sqrt{3xy^4+y^2})(x^3+xy^2+5.9)$","fontsize",4,"color","black");
Ejemplo No.17: Generar una superficie de acuerdo a la siguiente ecuación:
𝑍 = 𝑋 sin 𝑋 2 cos 𝑌
Donde −𝜋 ≤ 𝑋 ≤ 𝜋 y −𝜋 ≤ 𝑌 ≤ 𝜋

//Ejemplo No. 17 Creación de una superficie

xdel(winsid());
clear;
clc;
x = -%pi:0.1:%pi;
y = -%pi:0.1:%pi;
[X,Y] = meshgrid(x,y);
tamano = size(X);
for i=1:tamano(1)
for j=1:tamano(2)
Z(i,j)=X(i,j)*sin(X(i,j))^2*cos(Y(i,j));
end
end
xset("colormap",jetcolormap(128));
surf(X,Y,Z);
xlabel('X');
ylabel('Y');
zlabel('Z');
Ejemplo No.18: Generar las siguientes graficas de acuerdo a lo que se pide:
• Grafique la función densidad de probabilidad de X siendo una v.a. Gaussiana con media 0
y una desviación estándar de 1.
• Grafique la función densidad de probabilidad de Y siendo una v.a. Gaussiana con media 5
y una desviación estándar de 1/2.
• Grafique la función densidad de probabilidad conjunta para X y Y, siendo ambas variables

independientes.
La distribución normal o Gaussiana está definida por:
1 𝑥−𝜇
𝑓(𝑥) = 𝑒𝑥𝑝 (− )
√2𝜋 2𝜎 2
Donde 𝜇 es igual a la media y 𝜎 es igual a la desviación estándar.

//Probabilidad y estadística
xdel(winsid());
clear;
clc;
stacksize('max');
//Primera parte distribución de X
des_es = 1;
media = 0;
x = -5:0.1:5;
fx = (1/(sqrt(2*%pi)*des_es))*exp(-(x-media).^2/(2*des_es^2));
subplot(2,1,1);
plot(x,fx,"r");
//Segunda parte distribución de Y
des_es = 1/2;
media = 5;
y = 0:0.1:10;
fy = (1/(sqrt(2*%pi)*des_es))*exp(-(y-media).^2/(2*des_es^2));
subplot(2,1,1);
plot(y,fy,"b");
//Tercera parte distribucion conjunta
C=fy'*fx;
subplot(2,1,2);
xset("colormap",jetcolormap(2500));
surf(x,y,C);
Ejemplo No.19: Crearemos un programa que presente la gráfica de la siguiente ecuación, solicite el
límite inferior y superior para posteriormente pintar el área deseada por el usuario. La grafica va
de -3 a 3.
2 2
𝑓(𝑥) = 𝑒 −𝑥
√𝜋
//Determinar un área definida por el usuario

xdel(winsid());
clear;
clc;
x=-3:0.01:3;
fx=2/sqrt(%pi)*exp(-x.^2);
plot(x,fx);
a = input("Límite inferior (a) -3 <= a < b : ");

b = input("Límite superior (b) a < b <= 3 : ");
x2 = a:0.01:b;
xpoly([a x2 b],[0 2/sqrt(%pi)*exp(-x2.^2) 0],"lines",1);
p=get("hdl");
p.polyline_style = 5;
p.foreground = 20;

Ejemplo No.20: Generar un programa que permita plotear varias graficas que comparten el eje x
pero no el eje y de tal modo que puedan ser vistos sus valores correctamente.
𝑓(𝑥) = 𝑠𝑒𝑛𝑥
𝑥
𝑔(𝑥) = 𝑐𝑜𝑠
5
donde 1 ≤ 𝑥 ≤ 30
//Ejemplo No.20 plot con varios ejes y

xdel(winsid());
clear;
clc;
//Cálculo de las diferentes funciones

x=linspace(1,30,200);
fx = sin(x/2);
gx = cos(x/5);
//Creación de la primera gráfica

a1 = newaxes();
a1.filled = "off";
a1.axes_visible(1) = "off";
a1.y_location = "left";
a1.tight_limits = "on";
a1.foreground = 5;
a1.font_color = 5;
plot(x,fx,"red");
//Creación de la segunda gráfica

a2 = newaxes();
a2.filled = "off";
a2.axes_visible(1) = "off";
a2.y_location = "right";
a2.tight_limits = "on";
a2.foreground = 1;
a2.font_color = 1;
plot(x,gx,"black");

Ejemplo No.21: Utilizar las gráficas de contorno, junto con las gráficas la de superficie para
presentar los resultados de la siguiente ecuación:
𝑧 = 𝑥 sin 𝑥 2 cos 𝑦
Donde −𝜋 ≤ 𝑥 ≤ 𝜋 y −𝜋 ≤ 𝑦 ≤ 𝜋
// Ejemplo No.19
xdel(winsid());
clear;
clc;
function [z]=superficie(x, y)
z=sin(x)^2*cos(y)
endfunction
x = -%pi:0.1:%pi;
y = -%pi:0.1:%pi;
z=feval(x,y,superficie);
contour(x,y,z+0.2*abs(z),20,flag=[0 2 4]);
plot3d(x,y,z);
Ejemplo No.22: Realizar la gráfica de pie de acuerdo a los siguientes datos recolectados en una
escuela, donde se encuestaron a un total de 200 alumnos de cuál era su deporte favorito.
Deporte Alumnos que les gusta dicho deporte

Baloncesto 45
Beisbol 15
Futbol 70
Gimnasia 10
Atletismo 25
Natación 35
//Grafica de pie
xdel(winsid());
clear;
clc;
noalumnos = [45 15 70 10 25 35];

deportes = ["Baloncesto","Beisbol","Futbol","Gimnasia","Atletismo","Natacion"];
apagados = [1 0 0 0 0 0];
pie(noalumnos,apagados,deportes);
title("Grafica de preferencia de deportes");
xs2jpg(gcf(),'C:\Users\Yoguircb\Documents\scilab clase\Curso para maestría en TEC
II\Apuntes\foo.jpg');

ATOMS
Conocidos en otros lenguajes como toolboxs (MATLAB), a diferencia de otros lenguajes Scilab no
provee herramientas adicionales a la paquetería propia del software. Sin embargo crea una cultura de
colaboración, en donde los usuarios crean módulos de herramientas para propósito específico y
permite al resto de los usuarios la posibilidad de utilizarlos a su favor.
Tiene entre sus características principales lo siguiente:
 Módulos externos que extienden las capacidades de Scilab en campos específicos algunos
ejemplos son: Reconocimiento de patrones, redes neuronales, manejo del puerto serie,
comunicación con Arduino, manejo de imágenes, robótica, estadística aplicada etc.
 Proporcionan nuevas características y documentación para usuarios de Scilab: Como una de

sus principales virtudes es que todo desarrollador de ATOMS debe de proveer la
documentación pertinente para apoyo de su herramienta.
 Estos módulos pueden ser puestos a disposición de los usuarios directamente desde la consola
de Scilab a través de una nueva función denominada ATOMS (gestión automática de
módulos para Scilab), si el autor del módulo lo desea.
Módulo Función
Serial Communication Toolbox Un kit de herramientas para la comunicación a través del puerto
serie.
ANN Toolbox Un kit de herramientas para las redes neuronales artificiales,
basado en el libro "Matrix ANN“.
Lolimot Kit de herramientas para el desarrollo de redes neuronales.
USB Toolbox Funciones para comunicación con el puerto USB.

Image Processing Design Toolbox Kit de herramientas para el procesamiento de imágenes.
Arduino Permite la comunicación a través del puerto serial con ARDUINO.
Fuzzy Logic Toolbox Kit de herramientas para lógica difusa.

Robotics Toolbox Kit de herramientas para la simulación de robots manipuladores.
sciGPGPU Permite la programación paralela a través de la GPUs
Python Interaction Mechanism in Scilab Permite manipular algunos objetos de PYTON desde Scilab
Java Interaction Mechanism in Scilab Permite manipular algunos objetos de JAVA desde Scilab
GUI Builder Permite crear entornos de interfaz gráfica
GUI Builder
Scilab cuenta con una serie de comandos para generar pequeñas interfaces graficas que permitan
hacer programas más sencillos y atractivos para los usuarios. Sin embargo lamentablemente no son

sencillos de usar, la mayoría utiliza un gran número de parámetros que dificultan un poco su
construcción y manipulación.
Para hacer este proceso más sencillo existe una de las herramientas de creación de GUIs de manera
intuitiva, con esto se logra que el usuario dedique mayormente su tiempo en el desarrollo de los
cálculos y no en la construcción de la interfaz.
Bibliografía
 Scilab and SIP for Image Processing, Ricardo Fabbri1, Odemir Martinez Bruno, Luciano
da Fontoura Costa, Institute of Mathematical and Computer Sciences, University of São
Paulo, Brazil, Physics Institute of São Carlos, University of São Paulo, Brazil, Polytechnic
Institute, State University of Rio de Janeiro, Brazil.
 UNA INTRODUCCIÓN RÁPIDA A SCILAB, Rosa Echevarría Líbano – Dpto.

Ecuaciones Diferenciales y Análisis Numérico – Universidad de Sevilla.
 INTRODUCTION TO CONTROL SYSTEMS IN SCILAB, www.openeering.com.
 Curso de Scilab, Introducción Parte I y II. Prof. Enrique Eduardo Gavorskis Souto, Prof.
Francisco M. Gonzalez-Logatt.
 Scilab Textbook Companion for Digital Image Processing by S. Jayaraman, S.

Esakkirajan And T. Veerakumar Created by R.Senthilkumar M.E., Assistant Professor
Electronics Engineering Inst. of Road and Transport Tech., Erode College Teacher Dr.
R.K.Gnanamurhty, Principal,V. C. E. W. Cross-Checked by Anuradha Amrutkar, IIT
Bombay
 DSP Notes: Sound I/O and Spectrums, Dr. Fred DePiero, CalPoly State University.
 Utility Software II, lab 9 , Jacek Wiślicki, jacenty@kis.p.lodz.pl
 DT228/4 Graphics & Image Processing, Lab 2
 PLOTTING IN SCILAB, www.openeering.com.
 Image Processing with Scilab and Image Processing Design Toolbox, Dr. Eng. (J) Harald
Galda, 2011.
 DATA ANALYSIS AND STATISTICS, www.openeering.com.
 Data Mining with Scilab. Didacticiel - Études de cas, Ricco Rakotomalala
 Desarrollo de un ambiente de simulación para controladores clásicos mediante Scilah,

Br. Carlos Aparicio, tutor Prof. Miguel Ríos, 2009. Universidad de Los Andes Mérida,
Venezuela.
 Guía introductoria al usuario del simulador XCOS de Scilab aplicado a la simulación

de sistemas de control, Edinson Bautista Quiroga. Universidad Pontificia Bolivariana,

Facultad de ingeniería, departamento de control, Programa ingeniería electrónica

Bucaramanga 2012.
 INTRODUCCIÓN A XCOS (SCILAB), Entorno de programación y diagramas de bloques

mediante software libre, CACHEME.ORG
 Modeling and Simulation in Scilab/Scicos, Stephen L. Campbell, Jean-Philippe Chancelier

and Ramine Nikoukhah, Springer.
 CÁLCULO CON SCILAB, Jorge Antonio Polanía Puentes.
 LENGUAJE DE PROGRAMACIÓN SCILAB, Ceduvirt.
 Cómo importar datos en Scilab, Autor Maracelo Luda Contacto marceluda@gmail.com.
 INTRODUCCIÓN A SCILAB (Programa de cálculo numérico), LABORATORIO DE

COMPUTACIÓN DE ALTO DESEMPEÑO (LCAD), FACULTAD DE INGENIERÍA
UNIVERSIDAD NACIONAL DE ASUNCIÓN.
 DATA FITTING IN SCILAB, www.openeering.com
 FIRST STEPS WITH SCILAB, www.openeering.com
 Fundamentos y aplicaciones de Scilab, version 1.0, Andrés Alfonso Caro, Cesar Valero
Sepúlveda.
 Introducción a SCILAB, Héctor Manuel Mora Escobar, Departamento de Matemáticas,

Universidad Nacional de Colombia, Bogotá, mayo del 2005
 HOW TO DEVELOP A GRAPHICAL USER INTERFACE (GUI) IN SCILAB,

www.openeering.com
 Manual de Iniciación de Scilab.
 Métodos Numéricos con SCILAB, Héctor Manuel Mora Escobar, hctormora@yahoo.com

hmmorae@unal.edu.co, www.hectormora.info, 3 de enero de 2013.
 SOLVING NONLINEAR SYSTEMS IN SCILAB, www.openeering.com
 PLOTTING IN SCILAB, www.openeering.com
 Scilab for very beginners, Scilab Enterprises S.A.S -- 143 bis rue Yves Le Coz --‐ 78000
Versailles (France) --‐ www.scilab--‐enterprises.com
 SCILAB AS A CALCULATOR, www.openeering.com
 Introduction to Computer Science and Programming Using Python (MIT)

www.edx.org

Anexo No.1
Comando Función
clear Clear sin argumentos, clear elimina todas las variables
creadas previamente (excepto las variables globales),
funciona de la misma manera si usamos clear all.
clear A,b borra las variables indicadas de la memoria
del computador.
clc clc borra toda la entrada y la salida de la ventana de
comandos (dicho en otras palabras borra la pantalla de
comandos).
disp Muestra en pantalla la información que se requiere, ya
sea mensajes o valores de variables.
disp(‘El valor es’);
disp(xi)
// El uso de las dos diagonales le indica a Scilab que lo
que le sigue en la misma línea es un comentario, que
sirve para documentar nuestro código pero que jamás es
ejecutado por el computador.
input x= input(‘Dame el valor de x’);
Permite almacenar en x el valor de lo solicitado por
pantalla.
abs( ) Valor absoluto
acosh ( ) Arcocoseno hiperbólico
asinh( ) Arcoseno hiperbólico
atanh( ) Arcotangente hiperbólico
cosh( ) Coseno hiperbólico
coth( ) Cotangente hiperbólico
log( ) Logaritmo natural
acos( ) Arcocoseno
asin( ) Arcoseno
atan( ) Arcotangente
cos( ) Coseno
cotg( ) Cotangente
exp( ) Función exponencial ex
log10( ) Logaritmo decimal
log2( ) Logaritmo en base dos
max( ) Máximo
min( ) Mínimo
pmodulo( ) Residuo entero
rand() Número aleatorio
round() Redondeo
xgrid Activa la inclusión de una cuadrícula en el dibujo. Con
xgrid(‘off’) desaparece la cuadrícula.
plot2d2 Dibuja un diagrama de escalera
plot2d3 Dibuja un diagrama de barras
plot2d4 Diagrama de flechas
fplot2d Dibuja una función
contour2d Dibuja curvas de nivel en 2 dimensiones

fcontour2d Dibuja curvas de nivel en 2 dimensiones a partir de una

función
grayplot Dibuja una superficie con colores
fgrayplot Dibuja una superficie con colores a partir de una
función
errbar Dibuja un diagrama de errores
histplot Dibuja un histograma
xdel(winsid()) Similar a clear y clc pero para gráficas
pwd( ) Nos da la ruta donde se está trabajando.
chdir(“ruta") Cambia la ruta donde se trabaja.
xs2jpg(0,“nombre.jpg", 1) Guardar una gráfica en formato jpg.
xs2pdf(0,“nombre") Guardar una gráfica en formato pdf.
read(“archivo”,renglonres,columnas) Lee un archivo.
write(“archivo”,varible) Guarda una variable en un archivo
det() Este comando cal.cula el determinante de una matriz
inv() Este comando calcula la inversa de una matriz.
mean() Permite realizar el promedio, ya sea por renglón, por
columna o incluso por toda la matriz.
sum() Permite realizar la sumatoria, ya sea por renglón, por
columna o incluso toda una matriz en su totalidad.
median() Realiza el cálculo de la mediana de una matriz o vector,
en el caso de la matriz puede ser por renglones o
columnas.
stdev() Realiza el cálculo de la desviación estándar de una
matriz o vector, en el caso de la matriz puede ser por
renglones o columnas.

Sjsdnknerkjf

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Sjsdnknerkjf

Caricato da

Copyright:

Formati disponibili

2018-1

RUBEN CASTAÑEDA BALDERAS 1

RUBEN CASTAÑEDA BALDERAS 2

I.1 Conociendo la nueva herramienta

Sus principales características son:

 Software para cálculo científico.

RUBEN CASTAÑEDA BALDERAS 3

Figura No. 1 Consola de comandos de Scilab.

Figura No. 2 Visualizador de variables

RUBEN CASTAÑEDA BALDERAS 4

Figura No. 3 Historial de comandos.

RUBEN CASTAÑEDA BALDERAS 5

Programa: En ocasiones conocido como software, un programa de computadora, es una lista de

La estructura básica de un programa contiene ver Figura No. 4:

Lenguaje de programación: Es una técnica de comunicación estandarizada para describir las

RUBEN CASTAÑEDA BALDERAS 6

La metodología sugerida en este curso es la siguiente ver Figura No. 5:

2. Hacer un análisis dividido en tres etapas:

 ¿Qué necesitamos?: Aparte de la información que me proporcionan necesito algo más o

 ¿Qué buscamos?: Finalmente que esperamos obtener como resultado.

a) Nuestro problema está mal planteado y le falta información.

RUBEN CASTAÑEDA BALDERAS 7

Figura No. 4 Estructura básica de un programa

Figura No. 5 Pasos para resolver un problema.

RUBEN CASTAÑEDA BALDERAS 8

II.2 Operaciones básicas

Asignación de valores a una variable:

RUBEN CASTAÑEDA BALDERAS 9

𝑥 3 (2𝑥 2 + 3.56𝑥 − 5.21)

𝑧 = (10𝑥 + 𝑦√3𝑦𝑥 4 + 𝑦 2 )(𝑥 3 + 𝑥𝑦 2 + 5.9)

Supongamos que contamos con los siguientes valores:

Calcule el valor o los valores de 𝑥.

II.3 Principios de programación.

RUBEN CASTAÑEDA BALDERAS 10

Figura No. 6 SciNotes de Scilab.

// Programa de operaciones de un par de números opción básica

//Programa para calcular el área de un triangulo

RUBEN CASTAÑEDA BALDERAS 11

RUBEN CASTAÑEDA BALDERAS 12

Números reales de doble precisión

Números complejos (complex)

Figura No. 7 Estructura de una instrucción condicional simple.

RUBEN CASTAÑEDA BALDERAS 13

Existen también condicionales compuestas-simples en donde si la condición es verdadera realiza una

Figura No. 8 Estructura de una instrucción condicional compuesta-simple.

Figura No. 9 Estructura de una instrucción condicional compuesta.

 a == b Realiza la comparación para saber si a es igual a b.

RUBEN CASTAÑEDA BALDERAS 14

 a < b Realiza una comparación para conocer si a es menor a b.

Tablas de verdad de los operadores lógicos

Operador lógico & Operador lógico | Operador lógico ~

RUBEN CASTAÑEDA BALDERAS 15

//Cual número es el más grande de los tres

if a > b & a > c then

RUBEN CASTAÑEDA BALDERAS 16

Instrucciones Cíclicas (for)

Figura No. 10 Estructura de una instrucción cíclica desde hasta.

La estructura para hacer uso del for es la siguiente:

//esto se utiliza solo cuando no queremos incrementos de uno en uno

for índice=valor_inicial: incremento/decremento: valor_final

//esto se utiliza cuando queremos incrementos de uno en uno

RUBEN CASTAÑEDA BALDERAS 17

Ejercicio No.14: Hacer un programa para la sucesión de Fibonacci. La sucesión de Fibonacci es la