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.
|
||
}
|
||
|
||
|