ESCUELA SUPERIOR POLITÉCNICA AGROPECUARIA DE MANABÍ

MANUEL FÉLIX LOPEZ

CARRERA COMPUTACIÓN

TERCER NIVEL

PROYECTO INTEGRADOR DE SABERES

TEMA:

PROGRAMA MATEMÁTICO EN LA RESOLUCIÓN DE SISTEMAS DE

ECUACIONES POR MÉTODO DE GAUSS_JORDÁN

AUTORES:

JOSE JOB HIDROVO POLO

LEANDRO ADRIAN MENDOZA ZAMBRANO

ANA CRISTINA MUÑOZ CEDEÑO…

FACILITADOR:

ING. JAVIER HERNÁN LÓPEZ ZAMBRANO, MGTR.

RED DE APRENDIZAJE:

ESTRUCTURA DE DATOS

CALCETA, FEBRERO 2020

 2

TABLA DE CONTENIDO
TEMA: .............................................................................................................................. 3
INTRODUCCIÓN ............................................................................................................ 4
OBJETIVOS ..................................................................................................................... 6
GENERAL: ...................................................................................................................... 6
ESPECÍFICOS: ................................................................................................................ 6
DESARROLLO METODOLÓGICO .............................................................................. 7
UBICACIÓN GEOGRÁFICA ......................................................................................... 7
EQUIPOS Y HERRAMIENTAS ..................................................................................... 8
TALENTO HUMANO ..................................................................................................... 8
Tabla1: Datos personales .................................................................................................. 8
MATERIALES FÍSICOS ................................................................................................. 8
Tabla2: Materiales utilizados para realizar modelo matemático ...................................... 8
MATERIALES LÓGICOS .............................................................................................. 8
Tabla3: Programa utilizado para la ejecución del modelo matemático ............................ 8
METODOLOGÍA DE LA INVESTIGACIÓN ................................................................ 9
MÉTODO EXPERIMENTAL ......................................................................................... 9
FASE 1. ANÁLISIS. ........................................................................................................ 9
FASE 2. SÍNTESIS ........................................................................................................ 10
FASE 3. HIPÓTEIS ........................................................................................................ 11
RESULTADOS .............................................................................................................. 12
PROGRAMA DE MATRICES ...................................................................................... 13
CONCLUSIONES .......................................................................................................... 28
BIBLIOGRAFÍA ............................................................................................................ 29
ANEXOS ........................................................................................................................ 30
ANEXO 1: Investigación inmediata revisión de contenido principal ............................ 31
ANEXO 2: Ejecución del programa matemático .......................................................... 31
ANEXO 3: ejecución del programa y observación de errores ....................................... 32
ANEXO 4: Ejecución del modelo matemático............................................................... 33
 3

TEMA:
PROGRAMA MATEMÁTICO EN LA RESOLUCIÓN DE
SISTEMAS DE ECUACIONES POR MÉTODO DE
GAUSS_JORDÁN
 4

INTRODUCCIÓN
(Graells, 2013) Las tecnologías de información y comunicación, mayormente conocidas
como “TIC”, son aquellas cuya base se centra en los campos de la informática, la
microelectrónica y las telecomunicaciones, para dar paso a la creación de nuevas formas
de comunicación.

Se trata de un conjunto de herramientas o recursos de tipo tecnológico y comunicacional,

que sirven para facilitar la emisión, acceso y tratamiento de la información mediante
códigos variados que pueden corresponder a textos, imágenes, sonidos, entre otros.

Como es común en todo proceso de comunicaciones, existe la emisión de un mensaje, y

en el caso de las TIC, este mensaje corresponde a datos e instrucciones enviadas de un
usuario a otro por medio de un canal digital o hardware y definido por un código
o software, en un contexto determinado por convenios internacionales.

Las TICS involucran además el desarrollo de las redes, por lo que permiten un mayor y
más fácil acceso a la información.

Para el proceso de desarrollo de un programa sugiere involucrar potencial con el objetivo

de obtener un producto que satisfaga las expectativas que emergen de las necesidades;
por esto, en la construcción de herramientas computacionales con orientación didáctica
es relevante considerar las habilidades de los estudiantes, así como definir en lo posible
el estilo de aprendizaje y con esta información planificar actividades que integren
aspectos que propicien una mejor comprensión del tema. (Martínez, 2012).

El Dev-C++, es un IDE para crear aplicaciones utilizando el lenguaje de

programación C++, que ocupa muy poco tamaño en el disco duro, ideal para crear
programas pequeños en las que solo sea necesario demostrar el uso de estructuras de
control y estructuras de datos, estas aplicaciones se pueden compilar rápidamente y
ejecutar en forma de consola (EcuRed, 2016)

Dev-C++ es un compilador y entorno de desarrollo para C/C++

Consiste en un editor de múltiples ventanas integrado con un compilador que nos

permitirá una compilación, un enlace y una ejecución de aplicaciones rápida y de fácil
uso. C/C++ son lenguajes de programación, donde C++ fue creado para extender el
lenguaje de programación c y así dar la posibilidad de usar manipulación de objetos.
 5

Dev-C++, pues no usa símbolos, así como en los diagramas de flujo, si no que usa códigos
para remplazar aquellos símbolos, por eso es importante saber hacer un diagrama de
flujo/algoritmo, para poder realizar bien un programa en C, C++, o cualquier programa
que use lenguaje de programación con código, porque la idea sigue siendo la mismo solo
cambian los símbolos por palabras restringidas en dicho lenguaje (VÁSQUEZ, 2014).

Bien el Dev-C++ es un IDE (entorno de desarrollo integrado).

¿Qué es un entorno de desarrollo integrado?

Pues lo resumiría en un SW que te permite manipular instrucciones y compilar código de

cierto lenguaje de programación en este caso del LENGUAJE C++, en este IDE te permite
manejar tanto el clásico C o su versión siguiente C++ (c más, más o c plus plus). también
existen otros como el Turbo++, el NetBeans que es para java también te soporta C/C++.

(Carvajal, 2015) El método de Gauss-Jordán Consiste en hacer transformaciones

elementales en las filas de la matriz para llegar a obtener la matriz identidad se utiliza
operaciones con matrices para resolver sistemas de ecuaciones de n número de variables.
este método es tratar de encontrar la matriz identidad que es una matriz con 0 y 1 donde
los 1 están en diagonal se logra mediante operaciones de suma, resta y multiplicación,
entonces, si se quiere convertir la primera matriz en la segunda.
 6

OBJETIVOS

GENERAL:
Desarrollar un programa en la resolución de sistemas de ecuaciones por método de
Gauss_Jordán con los estudiantes del tercer nivel de la carrera de computación para
mejorar la compresión en el área de estudio.

ESPECÍFICOS:
 Conocer los conceptos teóricos de álgebra lineal para aplicar la resolución del
método de eliminación de gauss_jordán.
 Comprender y analizar el método de eliminación de Gauss _Jordán.
 Diseñar el modelo matemático en el programa de C++.
 Demostrar el correcto funcionamiento del modelo matemático a través de la
prueba de validación
 7

DESARROLLO METODOLÓGICO

UBICACIÓN GEOGRÁFICA
El proyecto se desarrolló en la Escuela Superior Politécnica Agropecuaria de Manabí
Manuel Félix López que se encuentra ubicada en el sitio El Limón a 3km de la ciudad de
Calceta en la provincia de Manabí.

Dentro de las siguientes coordenadas:

 Latitud 0º 49’ 10’’ sur.

 Longitud 80º 10’ 40’’ oeste.
 Altitud 15 m.s.n.m.

Fuente: Escuela Superior Politécnica Agropecuaria de Manabí (ESPAM), 2013.

 8

EQUIPOS Y HERRAMIENTAS
TALENTO HUMANO

Tabla1: Datos personales

PARTICIPANTES NOMBRES Y APELLIDOS

Jose Job Hidrovo Polo

Leandro Adrian Mendoza Zambrano

Ana Cristina Muñoz Cedeño

ESTUDIANTES
Stefano Leonardo Plazarte Leones

Antonio Adolfo Solórzano Cusme

FACILITADOR Ing. Javier Hernán López Zambrano, Mgtr.

MATERIALES FÍSICOS
Tabla2: Materiales utilizados para realizar modelo matemático
MATERIALES Y HERRAMIENTAS CANTIDAD
Libros de texto 4
Memoria flash 2
Ordenadores 3
Laboratorios informáticos 1
Calculadoras 3

MATERIALES LÓGICOS
Tabla3: Programa utilizado para la ejecución del modelo matemático
MATERIALES Y HERRAMIENTAS CANTIDAD
Internet ∞
Programa informático Dev- C++ 2
Microsoft Word 2
 9

METODOLOGÍA DE LA INVESTIGACIÓN

MÉTODO EXPERIMENTAL
Según (Cajal, 2013) El método científico experimental es un conjunto de técnicas que se
utilizan para investigar fenómenos, adquirir nuevos conocimientos o corregir e integrar
conocimientos previos.

Se utiliza en la investigación científica y se basa en la observación sistemática, la toma

de mediciones, la experimentación, la formulación de pruebas y la modificación de
hipótesis. Este método general se lleva a cabo no sólo en biología, sino en química, física,
geología y otras ciencias. En este método se recopilan datos para comparar las mediciones
de comportamiento de un grupo control, con las mediciones de un grupo experimental.

La utilización de las estrategias de este método nos sirve para mejorar la comprensión de
estudios de matices y para así poder comprobar que la información extraída de los libros
de algebra lineal son correctas.

Las destrezas y conocimientos adquiridos en las instalaciones de la ESPAM MFL en la

cuidad de Calceta, es de gran importancia para la ejecución del proyecto en conjunto con
los integrantes de equipo de trabajo de investigación del PIS, siendo de gran ayuda para
la mejor comprensión en los estudiantes del tercer nivel de la carrera de computación en
la materia integradora de estructura de datos ya que se emplearon temáticas importantes
referente a la programación en el lenguaje de C++ como lo es la gestión dinámica
implementando conocimientos de las lista y dentro de las listas se implementando otras
lista en el programa y aplicando los conceptos de algebra lineal.

FASE 1. ANÁLISIS.
(Rada, 2011) El álgebra lineal es la rama de las matemáticas que estudia conceptos tales
como vectores, matrices, sistemas de ecuaciones lineales y en un enfoque más formal,
espacios vectoriales, y sus transformaciones lineales. Es un área activa que tiene
conexiones con muchas áreas dentro y fuera de las matemáticas como análisis funcional,
ecuaciones diferenciales, investigación de operaciones, gráficas por computadora,
ingeniería, etc.

Se debe de tener en cuenta toda la información aplicada en este trabajo de investigación

la cual nos ayudó a la resolución de los ejercicios atreves del programa implementado en
 10

Dev, ajustándose a las necesidades y de esta manera poder recurrir a la información como
herramienta de planificación.

FASE 2. SÍNTESIS
Por medio de la implementación y ejecución del proyecto integrador se obtuvo un
programa el cual permite la creación y utilización de matrices de manera dinámica, este
programa fue desarrollado en el lenguaje de programación C++ en la aplicación DevC++,
este nos permitió la correcta comprensión e implementación del uso de las listas simples.

Ventajas.

 Es una calculadora de matrices con múltiples funciones

 Se utiliza la gestión dinámica en vez de una estática.

Desventajas.

 Todos los números tienen que ser ingresados con signos no importa que sean al
principio más o menos si la está la unidad y es positivo tiene que poner el signo.
 Es más complejo de comprender y analizar.

Proceso de creación del código el cual permite ingresar:

1. Se procede a la creación de 4 estructuras para poder almacenar la información de

las cuales 2 estructuras nos permiten guardar la lista de funciones y un id, las otras
2 estructuras guardan los resultados obtenidos del método gauss_jordán.
2. Para el ingreso de la información de la matriz se hace uso de las funciones de
insertar al final de una lista simple abierta con algunas de estas funciones retorne
el nodo ingresado y este se almacene en otro puntero.
3. Para el ingreso de los datos de la matriz se usó una de las funciones de búsqueda
de una lista simple abierta.
4. En el main principal se crean 2 listas una lista función y otra lista puntos de tipo
nodo este nos sirvió para el ingreso de la matriz además de las variables para poder
guardar la información.
5. Para el orden se usa una función que indique cuantas incógnitas hay que encontrar.
6. Una vez obtenido las incógnitas procedemos a ubicar los valores en sus
respectivas filas y columnas.
 11

Manejo del programa de producto vectorial:

1. Abrir el programa.
2. Dar clic en copilar y ejecutar.
3. Se desplegará un menú con cinco opciones:
 INGRESAR FUNCIÓN
 SACAR PROCESO
 ELIMINAR FUNCIONES INGRESADAS
 MÉTODO DEGAUSS JORDAN
 SALIR
4. Al seleccionar la opción 1: ingresar las funciones a realizar guardándose en una
lista.
5. Al seleccionar la opción 2: de las funciones ingresadas se separan las letras con
los números para ingresarlas en un vector.
6. Al seleccionar la opción 3: en las listas de funciones se extrae las funciones
ingresadas se muestra y se elimina, se repite el proceso.
7. Al seleccionar la opción 4: procedemos a la ejecución con el método de
gauss_jordan.
8. Opción 5: salir del programa.

FASE 3. HIPÓTEIS
Es una posible solución a un problema específico. Es decir, es un conjunto de
afirmaciones articuladas lógicamente que permite esclarecer una situación “inexplicable”
hasta el momento de la formulación de la misma. Asimismo, según el diccionario de la
RAE, es conveniente señalar que, en el ámbito científico, una hipótesis se establece
“provisionalmente como base de una investigación que puede confirmar o negar la
validez de aquella” (Real Academia Española 2017) (Esapañola, 2017). Esta última
precisión conceptual permite evidenciar que la hipótesis es el elemento central de toda
investigación científica, ya que condensa las afirmaciones esenciales de la misma y
permite determinar los objetivos de la investigación. No obstante, según la disciplina
científica, la hipótesis puede ser validada o refutada a través de la experimentación
durante el proceso de investigación.
 12

RESULTADOS

Los resultados obtenidos mediante la investigación del cálculo de los problemas de

matrices dan a entender que el objetivo planteado “Desarrollar un programa que permita
almacenar y resolver problemas matrices mediante el uso de listas simples logrando a
través del nuevo modelo sustituir la gestión estática por una gestión dinámica en el
programa de DEVC++” Se desarrolló con éxito ya que el programa permite almacenar y
calcular los resultados de las diversas operaciones.

Del mismo modo, se verifica la hipótesis ¿El desarrollo de un programa que permita el
ingreso y resolución de matrices por medio del uso de la gestión dinámica ayudara a los
estudiantes de la carrera de computación del tercer semestre en la materia de algebra lineal
mediante el software DevC++? Ya que mediante este programa los estudiantes podrán
entender mejor el proceso de solventación de ejercicios planteados en clase, por otro lado,
también ayudara en la materia de Estructura de datos ya que los estudiantes conocerán
los beneficios de la gestión dinámica, así como sus diferentes aplicaciones.
 13

PROGRAMA DE MATRICES
#include <iostream>
#include <stdio.h>
#include <ctype.h>
#include <conio.h>
#include <string.h>
#include<math.h>
#include<stdlib.h>
using namespace std;
struct tda_dato_x{
string letra;
double x;
int id;
};
struct tda_dato{
string dato;
int id;
};
struct Nodo{
tda_dato dato;
Nodo *siguiente;
};
struct Nodo_x{
tda_dato_x dato;
Nodo_x *siguiente;
};
/////////////////////////////
void eliminar_simple_inicio(Nodo *&lista){

if(lista==NULL){
cout<<"No existen datos \n";
 14

}
else{
while(lista!=NULL){
Nodo *aux=lista;
cout<<"Dato recuperado :"<<aux->dato.dato<<endl;
lista=aux->siguiente;
delete(aux);
}
cout<<"No existen datos \n";
}
}
void eliminar_simple_inicio_x(Nodo_x* &lista){
if(lista==NULL){
cout<<"No existen datos \n";
}
else{
while(lista!=NULL){
Nodo_x *aux=lista;
cout<<"\n"<<aux->dato.letra<<" : "<<aux->dato.x<< endl;
lista = aux->siguiente;
delete(aux);
}
cout<<"No existen datos \n";
}
}
/////////////////////////
void insertar_simple_final(Nodo *&lista,tda_dato n){
Nodo *nuevo=new(Nodo);
nuevo->dato=n;
nuevo->siguiente=NULL;
 15

if(lista==NULL){
lista=nuevo;
}
else{
Nodo *aux=lista;
while(aux->siguiente!=NULL){
aux=aux->siguiente;
}
aux->siguiente=nuevo;
}
}
//////////////////////////
/////////////////////////
void insertar_simple_final_x(Nodo_x *&lista,tda_dato_x n){
Nodo_x *nuevo=new(Nodo_x);
nuevo->dato=n;
nuevo->siguiente=NULL;
if(lista==NULL){
lista=nuevo;
}
else{
Nodo_x *aux=lista;
while(aux->siguiente!=NULL){
aux=aux->siguiente;
}
aux->siguiente=nuevo;
}
}
//////////////////////////
void fila(int k, int ind,double M[20][20],int n){
 16

double co;
if(k!=ind){
for(int i=0;i<n+1;i++){
co=M[k][i];
M[k][i]=M[ind][i];
M[ind][i]=co;
}
}
}
int gauss_jordan(double M[20][20],int n,Nodo_x* &puntos,int id,string L){
double may;
int ind;
double pivote;
tda_dato_x x;
for(int k=0;k<n;k++){
may=abs(M[k][k]);
ind=k;
for(int l=k+1;l<n;l++){
if( may < abs(M[l][k])){
may = abs(M[l][k]);
ind=l;
}
}
fila(k,ind,M,n);
if(M[k][k]==0){
return 0;
}
else{
for(int i=0;i<n;i++){
if(i!=k){
 17

pivote=-M[i][k];
for(int j=k;j<n+1;j++){
M[i][j] = M[i][j]+(pivote*(M[k][j]/M[k][k]));
}
}
else{
pivote=M[k][k];
for(int j=k;j<n+1;j++){
M[i][j]=M[i][j]/pivote;
}
}
}
}
}
string mnn;
for(int kl=0;kl<n;kl++){
x.x=M[kl][n];
x.id=id;
mnn=L[kl];
x.letra = mnn;

insertar_simple_final_x(puntos,x);
}
return 1;
}
/////////////////////////////////////////////////////+1X+1Y+1Z+1U=+10 +2X-1Y-2Z+2U=+2 +1X-
2Y+3Z-1U=+2 +1X+2Y-4Z+2U=+1
void ingresar_numero(string l,int numero,double A[][20],char x ,int f,int c){
for( int i=0;i<=l.length();i++){
if(int (l[i])==int (x)){
A[f][i]=numero;
 18

}
}
}
////////////////////////////////////////////////////////
void sarmun(string l ,string m ,double A[][20],int f){
string n="";
int c=0,c2=0,p=0;
string x="";
int h=0,numero=0;
for(int i =0;i<=m.length();i++){
if('-'==m[i]){
h=-1;
}
if('+'==m[i]){
h=1;
}
if ('0' <=m[i] && m[i] <= '9' ){
c=1;
n=n+m[i];
}
if ((('0' > m[i] || m[i] > '9' )) && c==1){
numero=atoi(n.c_str());
numero=numero*h;
cout<<endl<<numero<<endl;
ingresar_numero(l,numero,A,char(m[i]),f,p);
p++;
numero=0;
n="";
c=0;
c2=1;
 19

}
if('='==m[i]){
for(int j=i+1;j<=m.length();j++){
x=x+m[i];
}
}
}
A[f][m.length()]=atoi(x.c_str());
for(int i=0;i<l.length();i++){
for(int j=0;j<l.length()+1;j++){
cout<<A[i][j]<<" ";
}
cout<<endl;
}
}
//////////////////////////////////////////////////
void sacarletra2(string &l,char m){
int c=1;
if((65<= int (m) ) && (90>= int (m) && 43!= int (m ) && int (m)!=45)){
for(int i=0;i<l.length();i++){

if(int (l[i] ) == int (m)){

<
< c=0<<<<<<;
}
}
if(c == 1 ){
l=l+m;
}
}
 20

}
void sacarletra1(double A[][20],string m,string &L){
char mm=' ';
int mn;
for(int i=0;i<m.length();i++){
mm=m[i];
sacarletra2(L,mm);
}
}
///////////////////////////////
int ERRORES(string funcion){
int id=0,co=0;
if(funcion.length() == 0){
return 0;
}
else
if(int (funcion[0] )!= 43 && int ( funcion[0])!=45 ){
return 0;
}
for(int k=0;k<funcion.length();k++){
if(97<= funcion[k] && 122 >=funcion[k]){
return 0;
}
if(funcion[k]=='=' ){
id=k;
co=1;
}
}
for(int k=id;k<funcion.length();k++){
if(97<= funcion[k] && 122 >=funcion[k]){
 21

return 0;
}
}
return 1;
}
void ingreso_errroneo(){
system("cls");
system("color E5") ;
cout<<"\n*********************";
cout<<"\n*********************";
cout<<"\n** **";
cout<<"\n** **";
cout<<"\n** **";
cout<<"\n** ERROR **";
cout<<"\n** **";
cout<<"\n** **";
cout<<"\n** **";
cout<<"\n*********************";
cout<<"\n*********************\n";
system("pause");
system("cls");
system("color 05") ;
}
int main(){
Nodo *lista_funciones=NULL;
tda_dato funcion;
Nodo_x *lista_puntos=NULL;
tda_dato puntos;
int cifun=0;
int id=1;
 22

string L;
char op;
int f=0;
string m;
int n;
double A[20][20]={0};
do{
system("cls");
system("color 05") ;
cout<<"\n\t\t*********************";
cout<<"\n\t\t*********************";
cout<<"\n\t\t** METODO DE GAUSS JORDAN **";
cout<<"\n\t\t** **";
cout<<"\n\t\t** 1)INGRESAR FUNCION **";
cout<<"\n\t\t** 2)PROSESO **";
cout<<"\n\t\t** 3)ELIMINAR FUNCIONES INGRESADAS **";
cout<<"\n\t\t** 4)METODO DE GAUSS **";
cout<<"\n\t\t** 5)LISTAR FUNCIONES **";
cout<<"\n\t\t** 6)SALIR **";
cout<<"\n\t\t*********************";
cout<<"\n\t\t*********************\n";
cout<<"\t\t\t op= ";cin>>op;
system("pause");
system("cls");
if(op=='1')
int op2,cio;
do{
system("cls");
cout<<"\n\t\t** **";
cout<<"\n\t\t** **";
 23

cout<<"\n\t\t** 1)ingresar funcion **";

cout<<"\n\t\t** 2)salir **";
cout<<"\n\t\t op= ";cin>>op2;
system("cls");
if(1 == op2){
cout<<"\n\t\t*** funcion: ";
cin>>funcion.dato;
funcion.id=id;
cio= ERRORES(funcion.dato);
if( cio == 1){
insertar_simple_final(lista_funciones,funcion);
}else{
ingreso_errroneo();
}
}
}while(op2!=2);
if(cio==1){
id++;
}
system("pause");
}
if(op=='2'){
int idf=0;
Nodo *aux= lista_funciones;
cout<<"\n \t\t\t ingresar id de la funciones ";cin>>cifun;
while(aux!=NULL){
if(aux->dato.id == cifun){
sacarletra1(A,aux->dato.dato,L);
idf=1;
}
 24

aux=aux->siguiente;
}
if(idf==1){
aux= lista_funciones;
while(aux!=NULL){
if(aux->dato.id == cifun){
sarmun(L ,aux->dato.dato ,A,f);
f++;
}
aux=aux->siguiente;
}
}else{
ingreso_errroneo();
}
f=0;
system("pause");
}
if(op=='3'){
eliminar_simple_inicio(lista_funciones);
eliminar_simple_inicio_x(lista_puntos);
cout<<endl;
system("pause");
}
if(op=='4'){
Nodo_x *auxbus=lista_puntos;
if(lista_puntos==NULL){
if(gauss_jordan(A,L.length(),lista_puntos,cifun,L)==1){
for(int i=0;i<L.length();i++){
for(int j=0;j<L.length()+1;j++){
cout<<"\t "<<A[i][j];
 25

A[i][j]=0;
}
cout<<endl<<endl;
}
}else{
ingreso_errroneo();
}
}else{
do{
if(cifun==auxbus->dato.id){

cout<<"\n\n \t\t\t YA FUERON ENCONTRADOS LOS

PUNTOS DE LA ID INGRESADA";

goto FIN;
}
auxbus=auxbus->siguiente;
}while( auxbus!=NULL );
if(gauss_jordan(A,L.length(),lista_puntos,cifun,L)==1){
for(int i=0;i<L.length();i++){
for(int j=0;j<L.length()+1;j++){
cout<<"\t "<<A[i][j];
A[i][j]=0;
}
cout<<endl<<endl;
}
}else{
ingreso_errroneo();
}
}
FIN:
 26

f=0;
L="";
system("pause");
}
if(op=='5'){
Nodo *listar = lista_funciones;
Nodo_x *axpu=lista_puntos;
if(listar == NULL){
ingreso_errroneo();
}else {
for(int kl=1;kl<id; kl++){
cout<<"\n id funciones ";
do{
if(kl==listar->dato.id){
cout<<"\n\n\t\t"<<kl <<"\t\t"<<listar->dato.dato;
}
listar=listar->siguiente;
}while(listar!=NULL);
cout<<"\n\n\n PUNTOS \n\n ";
if(axpu!=NULL){
do{
if(kl==axpu->dato.id){
cout<<"\t\t"<<axpu->dato.letra<<" : "<<axpu->dato.x;
}else{
cout<<"\t no disponible";
}
axpu=axpu->siguiente;
}while(axpu!=NULL);
 27

axpu=lista_puntos;
}else{
cout<<"\n\\t no disponible\n\n";
}
listar = lista_funciones;
}
}
cout<<"\n\n\n";
system("pause");
}
}while(op!='6');
return 0;
}
 28

CONCLUSIONES
Los autores de la presente investigación concluyen que:

La creación del programa para insertar y calcular matrices de forma dinámica fue un éxito
además se concluye para la correcta creación del programa se debe tener en cuenta el
proceso de resolución de diversos problemas con matrices además cabe recalcar el uso de
las listas simples las cuales facilitaron el ingreso y tratamiento de datos además de la
correcta verificación de los resultados obtenidos.
 29

BIBLIOGRAFÍA
Cajal. (12 de Noviembre de 2013). Lifeder.com. Obtenido de Lifeder.com:
https://www.lifeder.com/metodo-cientifico-experimental/

Carvajal. (3 de Agosto de 2015). Matemáticas básicas. Obtenido de Matemáticas básicas:

https://www.institutoazteca.mx/e-
azteca/pluginfile.php/17890/mod_resource/content/1/Matem%C3%A1ticas%20
b%C3%A1sicas%20Unidad%203.pdf

EcuRed. (3 de noviembre de 2016). Dev-C++. Obtenido de Dev-C++:

https://www.ecured.cu/index.php?title=Especial:Citar&page=Dev-
C%2B%2B&id=2725055

Esapañola, R. A. (10 de Octubre de 2017). La formulación de hipótesis. Santiago.

Obtenido de Real Academia Española: http://dle.rae.es/?id=KUtnGU1

Graells, M. (2013). Impacto de las Tic en la educación: Funciones y limitaciones. 3C TIC,

52-68.

Martínez, M. L. (28 de Noviembre de 2012). Universidad Veracruzana . Obtenido de La

importancia de la Ingeniería de Software en el desarrollo de Software Educativo.
: https://www.uv.mx/mis/files/2012/11/LinaLopezMtzANIEI2007.pdf

Rada. (Nobiembre de 2011). EcuRed. Obtenido de EcuRed:

https://nickpgill.github.io/files/2014/07/libro-algebra-lineal.pdf

VÁSQUEZ. (2014). Fundamentos de la Informática. Obtenido de Fundamentos de la

Informática: El Entorno Integrado de Desarrollo Dev-C++. Recuperado de:
http://www.uhu.es/04004/material/El_Entorno_DevC.pdf
 30

ANEXOS
 31

ANEXO 1: Investigación inmediata revisión de contenido principal

Ilustración 1: Recopilación de los datos del programa matemático

ANEXO 2: Ejecución del programa matemático

Ilustración 2: Corrección de la recopilación de datos e inicio de la codificación

 32

ANEXO 3: ejecución del programa y observación de errores

Ilustración 3: Corrección de los errores que muestra el programa matemático.

 33

ANEXO 4: Ejecución del modelo matemático

(INTERFAZ DEL PROGRAMA)

(MENU DE INGRESO DE FUNCIONES )

(MENU DE LISTAR LAS FUNCIONES)

 34

(MENU DEL PROCESO)

(OPCION 5)

(OPCION 3)