503 lines
12 KiB
C++
503 lines
12 KiB
C++
|
#include <iostream> //cin, cout
|
|||
|
|
#include <conio.h> // getch
|
|||
|
|
#include <fstream>
|
|||
|
|
#include <stdio.h>
|
|||
|
|
#include <stdlib.h>
|
|||
|
|
#include <string.h>
|
|||
|
|
|
|||
|
|
#define MAXIMO 20
|
|||
|
|
#define M 5
|
|||
|
|
using namespace std;
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
class quebrado {
|
|||
|
|
int numerador, denominador;
|
|||
|
|
public:
|
|||
|
|
quebrado() { numerador=0; denominador=1; }
|
|||
|
|
quebrado(int n, int d=1);
|
|||
|
|
int getnumerador() { return numerador; }
|
|||
|
|
int getdenominador() {return denominador; }
|
|||
|
|
void valor(int n, int d=1);
|
|||
|
|
quebrado operator+(quebrado q);
|
|||
|
|
quebrado operator-(quebrado q);
|
|||
|
|
quebrado operator*(quebrado q);
|
|||
|
|
quebrado operator/(quebrado q);
|
|||
|
|
quebrado operator-();
|
|||
|
|
int operator==(quebrado q);
|
|||
|
|
void mostrar();
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
typedef quebrado tipoelemento ;
|
|||
|
|
|
|||
|
|
int mcd(int a, int b) {
|
|||
|
|
int comun,encontrado=0;
|
|||
|
|
a=abs(a);
|
|||
|
|
b=abs(b);
|
|||
|
|
if (a>b) comun=b;
|
|||
|
|
else comun=a;
|
|||
|
|
while (comun>1 && !encontrado)
|
|||
|
|
{
|
|||
|
|
if (a%comun==0 && b%comun==0)
|
|||
|
|
encontrado=1;
|
|||
|
|
else comun--;
|
|||
|
|
}
|
|||
|
|
return(comun);
|
|||
|
|
}
|
|||
|
|
//calcula el mcm de a y b (en positivo)
|
|||
|
|
int mcm(int a, int b) {
|
|||
|
|
int comun,encontrado;
|
|||
|
|
if (a<0) a=-a;
|
|||
|
|
if (b<0) b=-b;
|
|||
|
|
if (a>b) comun=a;
|
|||
|
|
else comun=b;
|
|||
|
|
encontrado=0;
|
|||
|
|
while (!encontrado) {
|
|||
|
|
if (comun%a==0 && comun%b==0)
|
|||
|
|
encontrado=1;
|
|||
|
|
else
|
|||
|
|
comun++;
|
|||
|
|
}
|
|||
|
|
return(comun);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
quebrado::quebrado(int n, int d) {
|
|||
|
|
if (d==0) cout << "\nError: Quebrado no valido";
|
|||
|
|
numerador=n; denominador=d;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void quebrado::valor(int n, int d) {
|
|||
|
|
if (d==0) cout << "\nError: Quebrado no valido";
|
|||
|
|
numerador=n; denominador=d;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void quebrado::mostrar() {
|
|||
|
|
if (denominador>0) cout << numerador << "/" << denominador;
|
|||
|
|
else cout << -numerador << "/" << -denominador;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
quebrado quebrado::operator/(quebrado q) {
|
|||
|
|
quebrado division;
|
|||
|
|
division.numerador=numerador*q.denominador;
|
|||
|
|
division.denominador=denominador*q.numerador;
|
|||
|
|
return division;
|
|||
|
|
}
|
|||
|
|
quebrado quebrado::operator-() {
|
|||
|
|
quebrado aux;
|
|||
|
|
aux.numerador=-numerador;
|
|||
|
|
aux.denominador=denominador;
|
|||
|
|
return aux;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int quebrado::operator==(quebrado q) {
|
|||
|
|
int igual;
|
|||
|
|
if (numerador*q.denominador==denominador*q.numerador)
|
|||
|
|
igual=1;
|
|||
|
|
else
|
|||
|
|
igual=0;
|
|||
|
|
return igual;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
quebrado quebrado::operator+(quebrado q) {
|
|||
|
|
quebrado suma;
|
|||
|
|
int comun;
|
|||
|
|
if (denominador==q.denominador) {
|
|||
|
|
suma.numerador= numerador + q.numerador;
|
|||
|
|
suma.denominador = denominador;
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
comun=mcm(denominador,q.denominador);
|
|||
|
|
suma.denominador = comun;
|
|||
|
|
suma.numerador=numerador*comun/denominador + q.numerador*comun/q.denominador;
|
|||
|
|
}
|
|||
|
|
return suma;
|
|||
|
|
}
|
|||
|
|
quebrado quebrado::operator-(quebrado q) {
|
|||
|
|
quebrado resta;
|
|||
|
|
q.numerador=-q.numerador;
|
|||
|
|
resta=(*this)+q;
|
|||
|
|
return(resta);
|
|||
|
|
}
|
|||
|
|
quebrado quebrado::operator*(quebrado q) {
|
|||
|
|
quebrado producto;
|
|||
|
|
producto.numerador=numerador*q.numerador;
|
|||
|
|
producto.denominador=denominador*q.denominador;
|
|||
|
|
return producto;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
class complejo {
|
|||
|
|
double real, imag;
|
|||
|
|
public:
|
|||
|
|
complejo(void) { real = 0.0; imag = 0.0; }
|
|||
|
|
complejo(double re, double im=0.0) { real = re; imag = im;}
|
|||
|
|
complejo(const complejo& r) { real = r.real;imag = r.imag;}
|
|||
|
|
void SetReal(double re) { real = re; }
|
|||
|
|
void SetImag(double im) { imag = im; }
|
|||
|
|
double GetReal(void) {return real; }
|
|||
|
|
double GetImag(void) {return imag; }
|
|||
|
|
complejo operator+(int e);
|
|||
|
|
complejo operator+(complejo c); //por valor
|
|||
|
|
complejo operator-(const complejo& c); //por ref
|
|||
|
|
int operator== (complejo c);
|
|||
|
|
complejo operator=(complejo c);
|
|||
|
|
complejo operator*(complejo c);
|
|||
|
|
complejo operator++(); // ++obj;
|
|||
|
|
complejo operator++(int notused); //obj++
|
|||
|
|
complejo operator-();
|
|||
|
|
void mostrar();
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
|
|||
|
|
complejo complejo::operator+ (int e) {
|
|||
|
|
complejo suma;
|
|||
|
|
suma.real = real + e; suma.imag = imag;
|
|||
|
|
return suma;
|
|||
|
|
}
|
|||
|
|
// sobrecarga de +
|
|||
|
|
complejo complejo::operator+ (complejo c) {
|
|||
|
|
complejo suma;
|
|||
|
|
suma.real = real + c.real;
|
|||
|
|
suma.imag = imag + c.imag;
|
|||
|
|
return suma;
|
|||
|
|
}
|
|||
|
|
// sobrecarga de -
|
|||
|
|
complejo complejo::operator- (const complejo &c) {
|
|||
|
|
complejo resta;
|
|||
|
|
resta.real = real - c.real;
|
|||
|
|
resta.imag = imag - c.imag;
|
|||
|
|
return resta;
|
|||
|
|
}
|
|||
|
|
// sobrecarga de ==
|
|||
|
|
int complejo::operator== (complejo c) {
|
|||
|
|
if (real==c.real && imag==c.imag)
|
|||
|
|
return 1;
|
|||
|
|
else
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
// sobrecarga de =
|
|||
|
|
complejo complejo::operator= (complejo c) {
|
|||
|
|
real=c.real; imag=c.imag;
|
|||
|
|
return c;
|
|||
|
|
}
|
|||
|
|
// sobrecarga de <20> unario
|
|||
|
|
complejo complejo::operator-() {
|
|||
|
|
complejo copia;
|
|||
|
|
copia.real=-real;
|
|||
|
|
copia.imag=-imag;
|
|||
|
|
return copia;
|
|||
|
|
}
|
|||
|
|
// sobrecarga de ++ (++obj)
|
|||
|
|
complejo complejo::operator++() {
|
|||
|
|
complejo copia;
|
|||
|
|
real++;
|
|||
|
|
copia.real=real;
|
|||
|
|
copia.imag=imag;
|
|||
|
|
return copia;
|
|||
|
|
}
|
|||
|
|
// sobrecarga de ++ (obj++)
|
|||
|
|
complejo complejo::operator++(int notused){
|
|||
|
|
complejo copia;
|
|||
|
|
copia.real=real;
|
|||
|
|
copia.imag=imag;
|
|||
|
|
real++;
|
|||
|
|
return copia;
|
|||
|
|
}
|
|||
|
|
//sobrecarga de *
|
|||
|
|
complejo complejo::operator*(complejo c){
|
|||
|
|
//Falta implementar
|
|||
|
|
complejo copia;
|
|||
|
|
|
|||
|
|
|
|||
|
|
return copia;
|
|||
|
|
}
|
|||
|
|
// mostrar complejo
|
|||
|
|
void complejo::mostrar(){
|
|||
|
|
if (imag>0)
|
|||
|
|
cout<<real<<"+"<<imag<<"i";
|
|||
|
|
else
|
|||
|
|
cout<<real<<imag<<"i";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
class matriz {
|
|||
|
|
private:
|
|||
|
|
tipoelemento celda[M][M];
|
|||
|
|
int fila,col;
|
|||
|
|
public:
|
|||
|
|
matriz(int f=0, int c=0);
|
|||
|
|
int getfila() { return fila; }
|
|||
|
|
int getcol() { return col; }
|
|||
|
|
bool operator==(matriz m);
|
|||
|
|
matriz operator*(matriz m);
|
|||
|
|
matriz operator+(matriz m);
|
|||
|
|
matriz operator-(matriz m);
|
|||
|
|
matriz operator-();
|
|||
|
|
void mostrar();
|
|||
|
|
void cargar();
|
|||
|
|
void cargar(char cad[]);
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
|
|||
|
|
void matriz::cargar(char cad[]) {
|
|||
|
|
int x, y;
|
|||
|
|
FILE *fin=NULL;
|
|||
|
|
do {
|
|||
|
|
cout << "Filas: "; cin >> fila;
|
|||
|
|
cout << "Columnas: "; cin >> col;
|
|||
|
|
} while (fila>M || fila<1 || col>M || col<1);
|
|||
|
|
cout << "Carga de una matriz " << fila << " x " << col << ":\n";
|
|||
|
|
fin = fopen(cad, "rb");
|
|||
|
|
if (fin != NULL) {
|
|||
|
|
for (int i=0; i<fila; i++)
|
|||
|
|
for (int j=0; j<col; j++) {
|
|||
|
|
int n= rand()%80+1;
|
|||
|
|
fseek(fin,sizeof(int)*n,SEEK_SET);
|
|||
|
|
fread(&x,sizeof(int),1,fin);
|
|||
|
|
fread(&y,sizeof(int),1,fin);
|
|||
|
|
tipoelemento A(x,y);
|
|||
|
|
celda[i][j]=A;
|
|||
|
|
cout << "[" << i+1 << "," << j+1 << "]: ";
|
|||
|
|
A.mostrar();
|
|||
|
|
cout<<'\n';
|
|||
|
|
}
|
|||
|
|
fclose(fin);
|
|||
|
|
fin = NULL;
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
cout << "Error al abrir el fichero de numeros\n";
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
void matriz::cargar() {
|
|||
|
|
int x, y;
|
|||
|
|
do {
|
|||
|
|
cout << "Filas: "; cin >> fila;
|
|||
|
|
cout << "Columnas: "; cin >> col;
|
|||
|
|
} while (fila>M || fila<1 || col>M || col<1);
|
|||
|
|
cout << "Carga de una matriz " << fila << " x " << col << ":\n";
|
|||
|
|
for (int i=0; i<fila; i++) {
|
|||
|
|
for (int j=0; j<col; j++) {
|
|||
|
|
cout << "[" << i+1 << "," << j+1 << "]: ";
|
|||
|
|
cin>>x>>y;
|
|||
|
|
tipoelemento A(x,y);
|
|||
|
|
celda[i][j]=A;
|
|||
|
|
//A.mostrar();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
matriz::matriz(int f, int c) {
|
|||
|
|
fila=f;
|
|||
|
|
col=c;
|
|||
|
|
for (int i=0; i<fila; i++)
|
|||
|
|
for (int j=0; j<col; j++)
|
|||
|
|
celda[i][j]=0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
bool matriz::operator==(matriz m){
|
|||
|
|
bool iguales=true;
|
|||
|
|
if (fila==m.fila && col==m.col){
|
|||
|
|
int i=0;
|
|||
|
|
while(i<fila && iguales)
|
|||
|
|
{
|
|||
|
|
int j=0;
|
|||
|
|
while(j<col && iguales){
|
|||
|
|
if (!(celda[i][j]==m.celda[i][j]))
|
|||
|
|
iguales=false;
|
|||
|
|
else j++;
|
|||
|
|
}
|
|||
|
|
i++;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else iguales=false;
|
|||
|
|
return iguales;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
matriz matriz::operator*(matriz m) {
|
|||
|
|
int i,j,k;
|
|||
|
|
tipoelemento prod;
|
|||
|
|
matriz p(fila,m.col);
|
|||
|
|
for (i=0; i< fila; i++)
|
|||
|
|
for (j=0; j< m.col; j++) {
|
|||
|
|
prod=0;
|
|||
|
|
for (k=0; k< col; k++)
|
|||
|
|
prod=prod+(celda[i][k]*m.celda[k][j]);
|
|||
|
|
p.celda[i][j]=prod;
|
|||
|
|
}
|
|||
|
|
return(p);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
matriz matriz::operator+(matriz m) {
|
|||
|
|
int i,j;
|
|||
|
|
matriz p(fila,col);
|
|||
|
|
for (i=0; i< fila; i++) {
|
|||
|
|
for (j=0; j< col; j++) {
|
|||
|
|
p.celda[i][j]=celda[i][j]+m.celda[i][j];
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return(p);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
matriz matriz::operator-(matriz m) {
|
|||
|
|
matriz p(fila,col);
|
|||
|
|
for (int i=0; i< fila; i++) {
|
|||
|
|
for (int j=0; j< col; j++) {
|
|||
|
|
p.celda[i][j]=celda[i][j]-m.celda[i][j];
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return(p);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
matriz matriz::operator-() {
|
|||
|
|
int i,j;
|
|||
|
|
matriz p(fila,col);
|
|||
|
|
for (i=0; i< fila; i++) {
|
|||
|
|
for (j=0; j< col; j++) {
|
|||
|
|
p.celda[i][j]=-celda[i][j];
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return(p);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void matriz::mostrar() {
|
|||
|
|
int i,j;
|
|||
|
|
for (i=0; i<fila; i++) {
|
|||
|
|
for (j=0; j< col; j++) {
|
|||
|
|
celda[i][j].mostrar();cout << "\t";
|
|||
|
|
}
|
|||
|
|
cout << "\n";
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
int main() {
|
|||
|
|
matriz m[MAXIMO];
|
|||
|
|
matriz result;
|
|||
|
|
int n,N=0;//Numero de matrices del vector
|
|||
|
|
int i,pos,pos2;
|
|||
|
|
char comando[20];
|
|||
|
|
bool salir=false;
|
|||
|
|
system("cls");
|
|||
|
|
|
|||
|
|
do {
|
|||
|
|
cout << ">";
|
|||
|
|
fflush(stdin); gets(comando);
|
|||
|
|
if (strcmp(comando,"cargar")==0) {
|
|||
|
|
cout<<"Cuantas matrices quieres cargar? \n"; cin>>n;
|
|||
|
|
if (n+N>=MAXIMO)
|
|||
|
|
cout<<"Se excede el numero de matrices con las que operar\n";
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
N=N+n;
|
|||
|
|
for (i=0;i<n;i++)
|
|||
|
|
m[i].cargar("numeros.dat");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else if (strcmp(comando,"listar")==0) { //listar
|
|||
|
|
if (N==0)
|
|||
|
|
cout << "No hay cargada ninguna matriz" << endl;
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
for (i=0;i<N;i++){
|
|||
|
|
cout<<"\nMatriz " <<i+1<<":\n\n";
|
|||
|
|
m[i].mostrar();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else if (strcmp(comando,"buscar")==0) { //buscar
|
|||
|
|
if (N==0)
|
|||
|
|
cout << "No hay cargada ninguna matriz" << endl;
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
result.cargar();
|
|||
|
|
|
|||
|
|
i=0;
|
|||
|
|
while (i<N && !(result==m[i]))
|
|||
|
|
i++;
|
|||
|
|
if (result==m[i])
|
|||
|
|
cout<<"\nLa matriz esta en la posicion "<<i<<" del vector\n";
|
|||
|
|
else cout<<"\nNo se ha encontrado la matriz\n";
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else if (comando[0]=='+'){
|
|||
|
|
switch(comando[1])
|
|||
|
|
{
|
|||
|
|
case '+': cout<<"Posicion?:";cin>>pos;//Insertar matriz en la posicion pos
|
|||
|
|
if (pos>=0 && pos<=N){
|
|||
|
|
N++;
|
|||
|
|
for(i=N-1;i>=pos;i--)
|
|||
|
|
m[i]=m[i-1];
|
|||
|
|
m[pos].cargar();
|
|||
|
|
}
|
|||
|
|
else cout<<"La posicion no es valida\n";break;
|
|||
|
|
case 0: cout<<"Posiciones?:";cin>>pos>>pos2;//Sumar matrices en estas posiciones
|
|||
|
|
if (pos>=0 && pos<N && pos2>=0 && pos2<N ){
|
|||
|
|
if (m[pos].getfila()!=m[pos2].getfila() || m[pos].getcol()!=m[pos2].getcol())
|
|||
|
|
cout << "Error: Las matrices no se pueden sumar" << endl;
|
|||
|
|
else {
|
|||
|
|
result= m[pos]+ m[pos2];
|
|||
|
|
cout<<"Matriz resultante:\n";result.mostrar();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else cout<<"Posiciones no validas\n";
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else if (comando[0]=='-') {
|
|||
|
|
switch(comando[1])
|
|||
|
|
{
|
|||
|
|
case '-':cout<<"Posicion?:";cin>>pos;//Eliminar matriz en la posicion pos
|
|||
|
|
if (pos>=0 && pos<N){
|
|||
|
|
for(i=pos;i<N-1;i++)
|
|||
|
|
m[i]=m[i+1];
|
|||
|
|
N--;
|
|||
|
|
}
|
|||
|
|
else cout<<"La posici<63>n no es valida\n";break;
|
|||
|
|
case 0: cout<<"Posiciones?:";cin>>pos>>pos2;//Restar matrices en estas posiciones
|
|||
|
|
if (pos>=0 && pos<N && pos2>=0 && pos2<N ){
|
|||
|
|
if (m[pos].getfila()!=m[pos2].getfila() || m[pos].getcol()!=m[pos2].getcol())
|
|||
|
|
cout << "Error: Las matrices no se pueden sumar" << endl;
|
|||
|
|
else {
|
|||
|
|
result= m[pos]-m[pos2];
|
|||
|
|
cout<<"Matriz resultante:\n";result.mostrar();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else cout<<"Posiciones no validas\n";
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else if (comando[0]=='*') {
|
|||
|
|
cout<<"Posiciones?:";cin>>pos>>pos2;//Multiplicar matrices en estas posiciones
|
|||
|
|
if (pos>=0 && pos<N && pos2>=0 && pos2<N){
|
|||
|
|
if (m[pos].getcol()!=m[pos2].getfila())
|
|||
|
|
cout << "Error: Las matrices no se pueden multiplicar" << endl;
|
|||
|
|
else {
|
|||
|
|
result= m[pos]*m[pos2];
|
|||
|
|
cout<<"Matriz resultante:\n";result.mostrar();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else cout<<"Posiciones no validas\n";
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
else if (comando[0]=='?') { //Mostrar una matriz del vector
|
|||
|
|
cout<<"Posicion?:";cin>>pos;
|
|||
|
|
if (pos>=0 && pos<N) m[pos].mostrar();
|
|||
|
|
else cout<<"La posicion no es valida\n";
|
|||
|
|
}
|
|||
|
|
else if (strcmp(comando,"salir")==0) salir=true;
|
|||
|
|
else
|
|||
|
|
cout << "comando o orden incorrecta" << endl;
|
|||
|
|
|
|||
|
|
} while (!salir);
|
|||
|
|
|
|||
|
|
return 0; // Valor de retorno al S.O.
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|