#ifndef CADENA
#define CADENA
#include <string>
#include <iostream>
using namespace std;
class Cadena {
public: // constructor con valor
Cadena(char *cad) {
cadena = new char[strlen(cad)+1];//para el temaño exacto
strcpy(cadena, cad);
}
// constructor por defecto
Cadena() : cadena(NULL) {}
Cadena(int numCar){
cadena= new char[numCar];
strcpy(cadena,"");
}
Cadena(const Cadena &c) : cadena(NULL) {
*this = c; // copia toda el objeto
}
~Cadena() {
if(cadena)
delete[] cadena;
}
//Sobrecarga de operadores
Cadena &operator=(const Cadena &c); // asignacion
Cadena &operator=(char *cad){
strcpy(cadena, cad);
return *this;
}
bool operator==(const Cadena &c) const{ // igualdad de cadena
return !strcmp(cadena, c.cadena); //strcpm() retorna 0 si son iguales
}
bool operator!=(const Cadena &c) const{ // desigualdad de cadena
return strcmp(cadena, c.cadena);
}
bool operator<(const Cadena &c) const { // menor
return (strcmp(cadena, c.cadena) < 0) ; // si es menor retornará un nºnegativo
}
bool operator>(const Cadena &c) const { // mayor
return (strcmp(cadena, c.cadena) > 0) ;
}
bool operator<=(const Cadena &c) const {
return (strcmp(cadena, c.cadena) <= 0) ;
}
bool operator>=(const Cadena &c) const {
return (strcmp(cadena, c.cadena) >= 0) ;
}
Cadena operator+(char *cad ){
strcat(cadena,cad);
return *this;
}
Cadena operator+( Cadena &c){
strcat(cadena,c.cadena);
return *this;
}
const char* Lee() const {
return cadena;
}
private:
char *cadena;// puntero de tipo char para el almacenamiento de cadena
};
Cadena &Cadena::operator=(const Cadena &c){ /* sobrecarga del operador = para objetos
de tipo cadena para su igualaion*/
if(this != &c) { // no es el mismo objeto
if(cadena) delete[] cadena; // se libera primera la memoria para luego asignarle otra
if(c.cadena) {
cadena = new char[strlen(c.cadena)+1]; /* se le asigna memoria de nuevo a cadena
del obj this con la memoria del objeto
nuevo*/
strcpy(cadena, c.cadena);
}
else cadena = NULL; // no es necesario la igualacion es el mismo objeto
}
return *this;
}
ostream& operator<<(ostream &os, const Cadena &cad) /* para mostrar directamente
al objeto ejemplo
cout << cadena */
{
os << cad.Lee() ;
return os;
}
#endif
/* copyleft
José Romero
email: -------joseromerogc@gmail.com
*/
martes, 11 de septiembre de 2012
Libreria Cadena.h
Libreria Basico.h
#ifndef BASICO
#define BASICO
#include <iostream>
using namespace std;
int Contador(int Arreglo[],int nelem, int num ){
int contador=0,i;
for(i=0;i<nelem;i++)
{
if(Arreglo[i]==num)
contador++;
}
return contador;
}
#endif
domingo, 9 de septiembre de 2012
Libreria matbas.h
Basico.h
Cadena.h
-->
#ifndef MATBAS
#define MATBAS
#include <iostream>
#include <math.h>
#include <cstring>
#include "Cadena.h"
#include "basico.h"
using namespace std;
//constantes Matemáticas
const double pi=3.141592653589;
const double e=2.718281828459;
const double fi=1.618033988749
double CalcParteDecimalPura(double, int &);
double CalcParteDecimal(double);
double MaximoComunDivisor(double a, double b);
int NumeroDigitos(double num);
bool EsPeriodica(double, long int &);
double CalcParteEntera(double num){
return static_cast<int>(num);
}
double CalcParteDecimal(double num){
if(num<0)
num*=-1;
if(num==CalcParteEntera(num))
return 0;
else
return (num-CalcParteEntera(num));
}
bool EsDecimal(double num){
if(num<0)
num*=-1;
return num!=CalcParteEntera(num);
}
double CalcParteDecimalPura(double num, int &numdigdec){
double DigitosDecimales=num;
double j=10;//permite recorrer la parte decimal por sus digitos
numdigdec=0;
if(!EsDecimal(num)) return 0;
while(CalcParteDecimal(static_cast<float>(DigitosDecimales))>0){
DigitosDecimales=CalcParteDecimal(num)*j;
j*=10;
numdigdec++;
}
return DigitosDecimales;
}
int RestoF(double Dividendo, double Divisor){
int Cociente=static_cast<int>(CalcParteEntera(Dividendo/Divisor));
return Dividendo-Divisor*Cociente;
}
double MaximoComunDivisor(double a, double b){
if(a < b)
return MaximoComunDivisor(b,a);
if(b == 0)
return a;
return MaximoComunDivisor(b, static_cast<int>(a) %static_cast<int>(b));
}
int NumeroDigitos(double num){
int numdigitos=0;
int cociente=CalcParteEntera(num);
while(cociente){
cociente=cociente/10;
numdigitos++;
}
return numdigitos;
}
bool EsPeriodica(double num, long int &periodo){
bool TienePeriodo=true;
int numdig=NumeroDigitos(num);
int digitodecimal, cociente,
resto,i;
if(numdig<2&&!(numdig%2==0))
return false;
for(i=1; i<=numdig/2; i++ )
{
cociente=CalcParteEntera(num);
digitodecimal=RestoF(num,pow(10,i));
int j=0;
while( cociente )
{
resto=RestoF(cociente,pow(10,i));
cociente=cociente/(pow(10,i));
if(digitodecimal==resto){
j++;
}
if(digitodecimal!=resto && i==(numdig/2))
return false;
if(j>1){
if(EsPeriodica(digitodecimal, periodo))
periodo=digitodecimal/pow(10,NumeroDigitos(digitodecimal)-1);
else
periodo=digitodecimal;
}
digitodecimal=resto;
}
}
return TienePeriodo;
}
//operaciones basicas
double Resto(float, float);
double Resto(double Dividendo, double Divisor){
int Cociente=static_cast<int>(CalcParteEntera(Dividendo/Divisor));
return Dividendo-Divisor*Cociente;
}
class NumeroPura{
void CalcNumDiv();
public:
NumeroPura(double num);
void CambiarValor(double);
bool EsPrimo();
protected:
int numdiv, ParteEntera, NumDigitosDecimales;
double numero, ParteDecimal, DigitosDecimales, ParteDecimalPura;
};
NumeroPura::NumeroPura(double num){
numero=(num);
if(num<0)
num*=-1;
ParteEntera=CalcParteEntera(num);
ParteDecimal=CalcParteDecimal(num);
ParteDecimalPura=CalcParteDecimalPura(num,NumDigitosDecimales);
numdiv=0;
CalcNumDiv();
}
void NumeroPura::CambiarValor(double num){
numero=(num);
if(num<0)
num*=-1;
ParteEntera=CalcParteEntera(num);
ParteDecimal=CalcParteDecimal(num);
ParteDecimalPura=CalcParteDecimalPura(num,NumDigitosDecimales);
numdiv=0;
CalcNumDiv();
}
void NumeroPura::CalcNumDiv(){
numdiv=0;
int i;
for(i=1;i<=ParteEntera;i++){
if(ParteEntera%i==0)
numdiv++;
}
}
bool NumeroPura::EsPrimo(){
return (numdiv==2);
}
class Divisores:
public NumeroPura
{
int *Div;
void CalcularDivisores();
public:
Divisores(double num): NumeroPura(num){
};
~Divisores(){
delete Div;
delete[] Div;
}
int NumDiv();
void VerDivisores();
int ndivisor(int);
};
int Divisores::NumDiv(){
return numdiv;
}
void Divisores::CalcularDivisores(){
int i;
int ind=0;
Div=new int[numdiv];
for(i=1;i<=ParteEntera;i++){
if(ParteEntera%i==0){
Div[ind]=i;
ind++;
} } }
void Divisores::VerDivisores(){
CalcularDivisores();
cout << ParteEntera << ":" <<"{";
int i;
for(i=0;i<numdiv;i++){
cout <<Div[i];
if(i>=0&&i<numdiv-1)
cout <<",";
}
cout <<"}"<<endl;
}
int Divisores::ndivisor(int ind){
CalcularDivisores();
if(ind<0 || ind>numdiv-1)
return 0;
else
return Div[ind];
}
class FactoresPrimos:
public Divisores
{
int *FactPrim, numfactores;
void CalcNumFact();
void CalcFactores();
public:
FactoresPrimos(double num): Divisores(num){
CalcNumFact();
CalcFactores();
}
~FactoresPrimos(){
delete FactPrim;
delete[] FactPrim;
}
int NumFactores();
void VerFactoresPrimos();
int nFactores(int);
};
int FactoresPrimos::NumFactores(){
return numfactores;
}
void FactoresPrimos::CalcNumFact(){
int fact=2,num=ParteEntera;
double Aux=numero;
numfactores=0;
int i=0;
while(num!=1){
CambiarValor(fact);
if(EsPrimo())
if(num%fact==0){
numfactores++;
num=num/fact;
fact=2;
continue;
}
fact++;
}
CambiarValor(Aux);
}
void FactoresPrimos::CalcFactores()
{
int ind=0,fact=1, num=ParteEntera;
double Aux=numero;
FactPrim=new int[numfactores];
while(num!=1){
CambiarValor(fact);
if(EsPrimo())
if(num%fact==0){
FactPrim[ind]=fact;
num=num/fact;
fact=0;
ind++;
continue;}
fact++;
}
CambiarValor(Aux);
}
void FactoresPrimos::VerFactoresPrimos(){
int i;
cout <<ParteEntera <<":";
CambiarValor(ParteEntera);
if(!EsPrimo()){
for(i=0;i<numfactores;i++){
cout <<FactPrim[i];
if(i>=0&&i<numfactores-1)
cout <<"*";
}}
else
cout <<" Es un numero primo"<<endl;
}
int FactoresPrimos::nFactores(int ind){
if(ind<0 || ind>numfactores-1)
return 0;
else
return FactPrim[ind];
}
class Numero:
public FactoresPrimos
{
double Numerador, Denominador;
long int periodo, anteperiodo;
bool periodicomixta;
void CalcularFraccion();
void SimplificarFraccion();
bool EsPeriodicapura();
void CalcPeriodicoMixto();
void CalcAntePeriodo();
public:
Numero(double num):FactoresPrimos(num){
CalcularFraccion();
}
~Numero(){};
double VerParteEntera();
double VerParteDecimal();
double VerNumerador();
double VerDenominador();
double valor();
void CambiarValor(double num);
Cadena Valor();
};
void Numero::CalcularFraccion(){
int tieneperiodico=0;
CalcAntePeriodo();
if(EsPeriodicapura())
tieneperiodico=1;
if(anteperiodo)
CalcPeriodicoMixto();
else{
Numerador=numero*pow(10,NumDigitosDecimales);
Denominador=pow(10,NumDigitosDecimales)-tieneperiodico;}
SimplificarFraccion();
}
void Numero::SimplificarFraccion(){
int McD=MaximoComunDivisor(fabs(Numerador), fabs(Denominador));
Numerador/=McD;
Denominador/=McD;
}
bool Numero::EsPeriodicapura(){
return EsPeriodica(ParteDecimalPura,periodo);
}
void Numero::CalcAntePeriodo(){
periodo=0;
anteperiodo=0;
for(int i=NumDigitosDecimales-1; i>1; i-- ){
periodo=RestoF(ParteDecimalPura,pow(10,i));
anteperiodo=ParteDecimalPura/pow(10,i);
if(EsPeriodica(periodo,periodo)) break;
}
}
void Numero::CalcPeriodicoMixto(){
double PenterayAntePeri=(ParteEntera+anteperiodo/pow(10,
NumeroDigitos(anteperiodo)))*(pow(10,NumeroDigitos(anteperiodo)));
double DigitosPuro= PenterayAntePeri*(pow(10,NumeroDigitos(periodo)))+periodo;
Numerador= DigitosPuro-PenterayAntePeri;
Denominador=(pow(10,NumeroDigitos(periodo))-1)*(pow(10,NumeroDigitos(anteperiodo)));
}
double Numero::VerParteEntera(){
return ParteEntera;
}
double Numero::VerParteDecimal(){
return ParteDecimal;
}
double Numero::VerNumerador(){
return Numerador;
}
double Numero::VerDenominador(){
return Denominador;
}
double Numero::valor(){
return numero;
}
Cadena Numero::Valor(){
char valor[15];
Cadena CValor(valor);
if(!EsDecimal(numero)){
sprintf(valor,"%.0lf",numero);
}
else
{
sprintf(valor,"%.0lf/%.0lf",Numerador,Denominador);
}
CValor=valor;
return CValor;}
void Numero::CambiarValor(double num){
NumeroPura::CambiarValor(num);
CalcularFraccion();
}
class NumeroComplejo{
public:
NumeroComplejo(double Pi, double Pr);
~NumeroComplejo(){}
Cadena Valor();
protected:
double ParteReal, ParteImaginaria;
};
NumeroComplejo::NumeroComplejo(double pi, double pr=0.0){
ParteReal=pr;
ParteImaginaria=pi;
}
Cadena NumeroComplejo::Valor(){
char valor[15];
Numero NPr(ParteReal), NPi(ParteImaginaria);
Cadena CValor(valor), CPr(NPr.Valor()), CPi(NPi.Valor());
if(ParteImaginaria>0)
if(EsDecimal(ParteReal)&&EsDecimal(ParteReal))
sprintf(valor,"%s + %si",CPr.Lee(),CPi.Lee());
else
if(EsDecimal(ParteReal))
sprintf(valor,"%s + %.0lfi",CPr.Lee(),ParteImaginaria);
else
sprintf(valor,"%.0lf + %si",ParteReal,CPi.Lee());
else
if(EsDecimal(ParteReal)&&EsDecimal(ParteReal))
sprintf(valor,"%s%si",CPr.Lee(),CPi.Lee());
else
if(EsDecimal(ParteReal))
sprintf(valor,"%s%.0lfi",CPr.Lee(),ParteImaginaria);
else
sprintf(valor,"%.0lf%si",ParteReal,CPi.Lee());
CValor=valor;
return CValor;
}
class Radical
{
int Indice,Coeficiente, Radicando;
public:
Radical(int Rad, int Coef,int ind);
~Radical(){}
void Simplificar();
Cadena Mostrar();
};
Radical::Radical(int Rad, int Coef=1.0,int ind=2){
Numero radicando(Rad);
Coeficiente=Coef;
Indice=2;
if(radicando.EsPrimo())
Radicando=Rad;
else{
Radicando=Rad;
if(EsDecimal(sqrt(Radicando)))
Simplificar();
else{
Coeficiente*=sqrt(Radicando);
Radicando=0;
}}}
void Radical::Simplificar(){
Numero radicando(Radicando);
int factores[radicando.NumFactores()],i;
for(i=0;i<radicando.NumFactores();i++)
factores[i]=radicando.nFactores(i);
for(i=0;i<radicando.NumFactores();i++){
int Exponente;
if(i==0)
Exponente=Contador(factores,radicando.NumFactores(),factores[i]);
else
if(factores[i]!=factores[i-1])
Exponente=Contador(factores,radicando.NumFactores(),factores[i]);
else
Exponente=0;
if(Exponente>Indice){
int ExpCoef;
ExpCoef=Exponente/Indice;
Coeficiente*=pow(factores[i],ExpCoef);
Radicando/=pow(factores[i],ExpCoef*Indice);
}}}
Cadena Radical::Mostrar(){
char valor[15];
Cadena CValor(valor);
if(!Radicando)
sprintf(valor,"%d",Coeficiente);
else
if(Coeficiente==1)
sprintf(valor,"--%d/**(%d)**",Indice,Radicando);
else
sprintf(valor,"%d--%d/**(%d)**",Coeficiente,Indice,Radicando);
CValor=valor;
return CValor;
}
#endif
Esta libreria fue Creada por José Elias Romero Guanipa( Agosto, 2012)
Suscribirse a:
Entradas (Atom)