Skip to content
Snippets Groups Projects
Commit e4991f86 authored by Hamer Iboshi's avatar Hamer Iboshi
Browse files

add Project

parents
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Documentação.pdf 0 → 100755
+ 0
− 0
View file @ e4991f86
File added
README.md 0 → 100644
+ 1
− 0
View file @ e4991f86
Os detalhes deste projeto podem ser encontrados na Documentação.
TExtremos.c 0 → 100755
+ 267
− 0
View file @ e4991f86
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define notE -1 //Quando nao eh nenhuma das opcoes abaixo
#define infE 0
#define maxE 1
#define minE 2
TPolinomio PDerivar(TPolinomio *P){
int i,tam;
TPolinomio aux;
aux.quant = P->quant-1;
tam = aux.quant;
aux.poli = (double*) calloc(aux.quant,sizeof(double));
for(i=0;i<tam;i++){
aux.poli[i]=(i+1)*P->poli[i+1];
}
return aux;
}
void ExibeExtremos(TExtremo *Ext, int aloca, TPolinomio *Deri1, TPolinomio *Deri2){
int i;
if(aloca){
if(aloca == 1){
printf("O Polinomio nao Possui Maximos e Minimos Locais, pois eh uma reta\n");
}else if(aloca == 2){
ExibeE(Ext);
free(Ext->x);
free(Ext->y);
free(Ext->tipo);
free(Deri1->poli);
free(Deri2->poli);
}else if(aloca == 3){
ExibeE(Ext);
free(Ext->x);
free(Ext->y);
free(Ext->tipo);
free(Deri1->poli);
}else if(aloca == -1){
printf("O Polinomio nao Possui Raizes Reais\n");
}
}else{
printf("O Polinomio nao Possui Maximos e Minimos Locais\n");
}
}
void ExibeE(TExtremo *Ex){
int i;
if (Ex->quant == 1){
if(*Ex->tipo == 0)
printf("P(X,Y) = (%.2lf,%.2lf) Ponto de Inflexão\n",Ex->x[0],Ex->y[0]);
else if(*Ex->tipo == 1)
printf("P(X,Y) = (%.2lf,%.2lf) Maximo Local\n",*Ex->x,*Ex->y);
else
printf("P(X,Y) = (%.2lf,%.2lf) Minimo Local\n",*Ex->x,*Ex->y);
}else{
for(i=0;i<Ex->quant;i++){
if(Ex->tipo[i] == 0)
printf("P(X,Y) = (%.2lf,%.2lf) Ponto de Inflexão\n",Ex->x[i],Ex->y[i]);
else if(Ex->tipo[i] == 1)
printf("P(X,Y) = (%.2lf,%.2lf) Maximo Local\n",Ex->x[i],Ex->y[i]);
else if(Ex->tipo[i] == 2)
printf("P(X,Y) = (%.2lf,%.2lf) Minimo Local\n",Ex->x[i],Ex->y[i]);
}
}
}
TPolinomio EBriotRuffunni(TPolinomio *P,double aux,int *testResto){
TPolinomio Aux;
int i;
Aux.quant=P->quant-1;
Aux.poli =(double*)calloc(Aux.quant,sizeof(double));
for (i=0;i<Aux.quant;i++)
Aux.poli[i] = P->poli[i];
for (i=Aux.quant-1;i>=0;i++){
Aux.poli[i]+=P.poli[i+1]*aux;
}
if(Aux.poli[0] == 0)
testeResto = 1;
return Aux;
}
void ObterExtremos(TPolinomio *P){
int i,teste = 1,aloca=0,pass,possi[8],test,testResto = 0; //aloca usado para verificar se um malloc foi usado, para nao dar free quando nao utilizar nada
double delta;
TPolinomio Deri1,Deri2,Aux;
TExtremo Ext;
//PExibe(&Deri1);
//PExibe(&Deri2);
switch(P->quant-1){//Grau/Ordem do Polinomio
case 0:
aloca = 0;
break;
case 1:
aloca = 1;
break;
case 2:
aloca = 3;
Deri1 = PDerivar(P);
Ext.tipo = (int*) malloc(sizeof(int));
Ext.x = (double*) calloc(1,sizeof(double));
Ext.y = (double*) calloc(1,sizeof(double));
*Ext.x = ((-1*Deri1.poli[0])/Deri1.poli[1]);
*Ext.y = PObterValor(P,*Ext.x);
//printf("%.2lf %.2lf +1 %.2lf %.2lf\n",*Ext.x,*Ext.y,PObterValor(P,(*Ext.x)+1),PObterValor(P,(*Ext.x)-1));
if ((PObterValor(P,(*Ext.x)-1) > *Ext.y)&&(PObterValor(P,(*Ext.x)+1)>*Ext.y)){
*Ext.tipo = minE;
Ext.quant = 1;
}else if((PObterValor(P,(*Ext.x)-1)<*Ext.y)&&(PObterValor(P,(*Ext.x)+1)<*Ext.y)){
*Ext.tipo = maxE;
Ext.quant = 1;
}
break;
case 3:
Deri1 = PDerivar(P);
Deri2 = PDerivar(&Deri1);
aloca = 2;
pass = 1;
delta = (Deri1.poli[1]*Deri1.poli[1])-4*Deri1.poli[2]*Deri1.poli[0];
if(delta < 0){
aloca = -1;
}else if((int)delta == 0){
Ext.tipo = (int*) malloc(2*sizeof(int));
Ext.x = (double*) calloc(2,sizeof(double));
Ext.y = (double*) calloc(2,sizeof(double));
Ext.x[0] = (-1*Deri1.poli[1])/(Deri1.poli[2]*2);
Ext.y[0] = PObterValor(P,*Ext.x);
if ((PObterValor(P,(*Ext.x)-1)>*Ext.y)&&(PObterValor(P,(*Ext.x)+1)>*Ext.y)){
Ext.tipo[0] = minE;
}else if((PObterValor(P,(*Ext.x)-1)<*Ext.y)&&(PObterValor(P,(*Ext.x)+1)<*Ext.y)){
Ext.tipo[0] = maxE;
}else{
Ext.x[0] = (-1*Deri2.poli[0])/Deri2.poli[1];
Ext.y[0] = PObterValor(P,Ext.x[1]);
Ext.tipo[0] = infE;
Ext.quant = 1;
pass=0;
}
aloca = 2;
if (pass){
Ext.x[1] = (-1*Deri2.poli[0])/Deri2.poli[1];
Ext.y[1] = PObterValor(P,Ext.x[1]);
Ext.tipo[1] = infE;
Ext.quant = 2;
}
}else{
Ext.tipo = (int*) malloc(3*sizeof(int));
Ext.x = (double*) calloc(3,sizeof(double));
Ext.y = (double*) calloc(3,sizeof(double));
//Para Primeira Raiz de X
Ext.x[0] = (-1*Deri1.poli[1]+sqrt(delta))/(Deri1.poli[2]*2);
Ext.y[0] = PObterValor(P,Ext.x[0]);
if ((PObterValor(P,Ext.x[0]-1)>Ext.y[0])&&(PObterValor(P,Ext.x[0]+1)>Ext.y[0])){
Ext.tipo[0] = minE;
}else if((PObterValor(P,Ext.x[0]-1)<Ext.y[0])&&(PObterValor(P,Ext.x[0]+1)<Ext.y[0])){
Ext.tipo[0] = maxE;
}else{
Ext.tipo[0] = notE;
}
//Para segunda Raiz de X
Ext.x[1] = (-1*Deri1.poli[1]-sqrt(delta))/(Deri1.poli[2]*2);
Ext.y[1] = PObterValor(P,Ext.x[1]);
if ((PObterValor(P,Ext.x[1]-1)>Ext.y[1])&&(PObterValor(P,Ext.x[1]+1)>Ext.y[1])){
Ext.tipo[1] = minE;
}else if((PObterValor(P,Ext.x[1]-1)<Ext.y[1])&&(PObterValor(P,Ext.x[1]+1)<Ext.y[1])){
Ext.tipo[1] = maxE;
}else{
Ext.tipo[1] = notE;
}
//Inflexao
Ext.x[2] = (-1*Deri2.poli[0])/Deri2.poli[1];
Ext.y[2] = PObterValor(P,Ext.x[2]);
Ext.tipo[2] = infE;
Ext.quant = 3;
}
break;
case 4: //Para polinomios de grau 4
//encontrar possíveis raizes casos simples
i=0;
possi[0] = 1;
possi[1] = -1;
possi[2] = P->poli[0];
possi[3] = -P->poli[0];
possi[4] = 1/P->poli[P->quant-1];
possi[5] = -1/P->poli[P->quant-1];
possi[6] = P->poli[0]/P->poli[P->quant-1];
possi[7] = -P->poli[0]/P->poli[P->quant-1];
test=1;
for(i;(i<8)&&(test);i++){
if (PObterValor(P,possi[i]) == 0)
test=0;
}
Aux = EBriotRuffunni(P,possi[i],&testResto);
//casos complexos quando houver, testar mais
Deri1 = PDerivar(P);
Deri2 = PDerivar(&Deri1);
aloca = 2;
pass = 1;
delta = (Deri1.poli[1]*Deri1.poli[1])-4*Deri1.poli[2]*Deri1.poli[0];
if(delta < 0){
aloca = -1;
}else if((int)delta == 0){
Ext.tipo = (int*) malloc(2*sizeof(int));
Ext.x = (double*) calloc(2,sizeof(double));
Ext.y = (double*) calloc(2,sizeof(double));
Ext.x[0] = (-1*Deri1.poli[1])/(Deri1.poli[2]*2);
Ext.y[0] = PObterValor(&Aux,*Ext.x);
if ((PObterValor(&Aux,(*Ext.x)-1)>*Ext.y)&&(PObterValor(&Aux,(*Ext.x)+1)>*Ext.y)){
Ext.tipo[0] = minE;
}else if((PObterValor(&Aux,(*Ext.x)-1)<*Ext.y)&&(PObterValor(&Aux,(*Ext.x)+1)<*Ext.y)){
Ext.tipo[0] = maxE;
}else{
Ext.x[0] = (-1*Deri2.poli[0])/Deri2.poli[1];
Ext.y[0] = PObterValor(&Aux,Ext.x[1]);
Ext.tipo[0] = infE;
Ext.quant = 1;
pass=0;
}
aloca = 2;
if (pass){
Ext.x[1] = (-1*Deri2.poli[0])/Deri2.poli[1];
Ext.y[1] = PObterValor(&Aux,Ext.x[1]);
Ext.tipo[1] = infE;
Ext.quant = 2;
}
}else{
Ext.tipo = (int*) malloc(3*sizeof(int));
Ext.x = (double*) calloc(3,sizeof(double));
Ext.y = (double*) calloc(3,sizeof(double));
//Para Primeira Raiz de X
Ext.x[0] = (-1*Deri1.poli[1]+sqrt(delta))/(Deri1.poli[2]*2);
Ext.y[0] = PObterValor(&Aux,Ext.x[0]);
if ((PObterValor(&Aux,Ext.x[0]-1)>Ext.y[0])&&(PObterValor(&Aux,Ext.x[0]+1)>Ext.y[0])){
Ext.tipo[0] = minE;
}else if((PObterValor(&Aux,Ext.x[0]-1)<Ext.y[0])&&(PObterValor(&Aux,Ext.x[0]+1)<Ext.y[0])){
Ext.tipo[0] = maxE;
}else{
Ext.tipo[0] = notE;
}
//Para segunda Raiz de X
Ext.x[1] = (-1*Deri1.poli[1]-sqrt(delta))/(Deri1.poli[2]*2);
Ext.y[1] = PObterValor(&Aux,Ext.x[1]);
if ((PObterValor(&Aux,Ext.x[1]-1)>Ext.y[1])&&(PObterValor(&Aux,Ext.x[1]+1)>Ext.y[1])){
Ext.tipo[1] = minE;
}else if((PObterValor(&Aux,Ext.x[1]-1)<Ext.y[1])&&(PObterValor(&Aux,Ext.x[1]+1)<Ext.y[1])){
Ext.tipo[1] = maxE;
}else{
Ext.tipo[1] = notE;
}
//Inflexao
Ext.x[2] = (-1*Deri2.poli[0])/Deri2.poli[1];
Ext.y[2] = PObterValor(&Aux,Ext.x[2]);
Ext.tipo[2] = infE;
Ext.quant = 3;
free(Aux.poli);
break;
case 5:
//Para polinomios de grau 5
aloca=0;
// usar com goto tentativa:
break;
}
ExibeExtremos(&Ext,aloca,&Deri1,&Deri2);
}
TExtremos.h 0 → 100755
+ 17
− 0
View file @ e4991f86
typedef struct{
int *tipo;
double *x;
double *y;
int quant;
}TExtremo;
TPolinomio PDerivar(TPolinomio *P);
void ExibeExtremos(TExtremo *Ex, int aloca,TPolinomio *Deri1,TPolinomio *Deri2);
void ExibeE(TExtremo *Ex);
TPolinomio EBriotRuffunni(TPolinomio *P,double aux,int *testResto);
void ObterExtremos(TPolinomio *P);
TPolinomios.c 0 → 100755
+ 186
− 0
View file @ e4991f86
#include <stdio.h>
#include <stdlib.h>
// Funcoes potencia e zera polinomio sao apenas funcoes complementares.
double potencia(double num, int pot){
int i;
double n=1;
for (i=1;i<pot;i++){
n*=num;
}
return n;
}
void PAloca(double **P, int n){
(*P) = (double*)malloc(n*sizeof(double));
}
void PLibera (double **P){
free(*P);
}
void PCriar (TPolinomio *P){ //Leitura do menor grau para o maior grau (0,1,2,...)
int i;
scanf("%d",&P->quant);
PAloca(&P->poli,P->quant);
for (i=0;i<P->quant;i++){
scanf("%lf",&P->poli[i]);
}
}
void PExibe(TPolinomio *P){
int i,n=P->quant;
for (i=0;i<n;i++){
if (P->poli[i]){ //Se o valor do coeficiente for zero, ele nao exibe
if (i > 0){
if (P->poli[i]>=0)
printf(" + %.1lf X^%d",P->poli[i],i);
else
printf(" - %.1lf X^%d",-(P->poli[i]),i); //Para imprimir somente o menos da operação
}else
printf("%.1lf ",P->poli[i]);
}
}
printf("\n");
}
double PObterValor(TPolinomio *P, double x){
int i=0,n = P->quant;
double valor = 0;
valor+=P->poli[i];
for (i=1;i<n;i++)
valor+=potencia(x,i+1)*P->poli[i];
return valor;
}
int PObterOrdem(TPolinomio *P){
return P->quant-1;
}
void PAdicao(TPolinomio *P1, TPolinomio *P2, TPolinomio *Sum){
int i,l,l1 = P1->quant,l2 = P2->quant;
if (P1->quant == P2 ->quant){
l = P1->quant;
Sum->quant = l;
PAloca(&Sum->poli,Sum->quant);
for (i = 0; i<l;i++){
Sum->poli[i] = P1->poli[i] + P2->poli[i];
}
}else{
if (P1->quant > P2->quant){
l = l1;
Sum->quant = l;
PAloca(&Sum->poli,Sum->quant);
for (i = 0; i<l;i++){
if (i<l2){
Sum->poli[i] = P1->poli[i] + P2->poli[i];
}else{
Sum->poli[i] = P1->poli[i];
}
}
}else{
l = l2;
Sum->quant = l;
PAloca(&Sum->poli,Sum->quant);
for (i = 0; i<l;i++){
if (i<l1){
Sum->poli[i] = P1->poli[i] + P2->poli[i];
}else{
Sum->poli[i] = P2->poli[i];
}
}
}
}
}
void PSubtracao(TPolinomio *P1, TPolinomio *P2, TPolinomio *Sub){
int i,l,l1 = P1->quant,l2 = P2->quant; //l1 eh limite(o tamanho maximo da do polinomio) de P1, l2 eh o limite para P2
if (P1->quant == P2 ->quant){
l = P1->quant;
Sub->quant = l;
PAloca(&Sub->poli,Sub->quant);
for (i = 0; i<l;i++){
Sub->poli[i] = P1->poli[i] - P2->poli[i];
}
}else{
if (P1->quant > P2->quant){
l = l1;
Sub->quant = l;
PAloca(&Sub->poli,Sub->quant);
for (i = 0; i<l;i++){
if (i<l2){
Sub->poli[i] = P1->poli[i] - P2->poli[i];
}else{
Sub->poli[i] = P1->poli[i];
}
}
}else{
l = l2;
Sub->quant = l;
PAloca(&Sub->poli,Sub->quant);
for (i = 0; i<l;i++){
if (i<l1){
Sub->poli[i] = P1->poli[i] - P2->poli[i];
}else{
Sub->poli[i] = -(P2->poli[i]); //Como o polinomio dois eh o que vai subtrair e nesse grau nao existe um polnomio P1, nega-se o polinomio p2
}
}
}
}
}
void PProduto(TPolinomio *P1,TPolinomio *P2,TPolinomio *Prod){
int i,j,tam,l1 = P1->quant,l2 = P2->quant;
tam=l1+l2; //tamanho maximo = a soma dos maiores indices dos polinomios
Prod->quant=tam;
Prod->poli = (double*) calloc(Prod->quant,sizeof(double));
for(i=0;i<l1;i++){
for(j=0;j<l2;j++){
Prod->poli[i+j]+=P1->poli[i]*P2->poli[j];
}
}
}
//METODO DE HORNER
void PDivisao(TPolinomio P, TPolinomio Q, TPolinomio *D, TPolinomio *R){ //P e Q nao foi passado por referencia
int i,j,lP = P.quant,lQ = Q.quant,lD,div,Pi,Qi,Di,Ri,Ai,parametro; //Pi,Qi,Di,Ri,Ai sao usados para controlar os indices durante a divisao;
double *aux; //Div é o Parametro principal para realizar a divisão pelo método de Horner
aux = (double*) calloc(lP,sizeof(double));
parametro = lP-(lQ-1); //Parametro para o número de vezes que o método será implementado
D->quant = parametro;
R->quant=lQ;
D->poli = (double*) calloc(D->quant,sizeof(double));
R->poli = (double*) calloc(R->quant,sizeof(double));
lD=D->quant-1;
Di=lD-1;
lQ--;
Ri=lQ;
Pi = lP-2; //indice auxiliar fixo para manipular a divisao e utilizar o aux, diferente do Ai ele só diminui no final do for externo
div = Q.poli[lQ];
//Atribuir P para AUX
for (i=0;i<lP;i++)
aux[i]=P.poli[i];
//Inverter os Q elementos com excecao do div
//for (i=0;i<lQ;i++)
//Q.poli[i]=*Q.poli[i];
D->poli[Di+1]=P.poli[Pi+1]/div;
for (i=0;i<parametro;i++){
Ai=Pi;
Qi=lQ-1;
for(j=lQ-1 ;j>=0;j--){
aux[Ai]+=D->poli[Di+1]*Q.poli[Qi]*-1; //Pegando o Quociente da da divisão e invertendo os cocientes atraves do método de horner
Ai--;
if (Qi>0)
Qi--;
}
if(Di>=0)
D->poli[Di]+=aux[Pi]/div;
Pi--;
Di--;
}
//Calcula resto
for (i=0;i<Ri; i++) {
R->poli[i]=aux[i];
}
free(aux);
}
TPolinomios.h 0 → 100755
+ 26
− 0
View file @ e4991f86
typedef struct{
int quant;
double *poli;
}TPolinomio;
void PAloca(double **P, int n);
void PLibera (double **P);
void PCriar (TPolinomio *P);
double PObterValor(TPolinomio *P,double x);
int PObterOrdem(TPolinomio *P);
double potencia(double num, int pot);
void PAdicao(TPolinomio *P1, TPolinomio *P2, TPolinomio *Sum);
void PSubtracao(TPolinomio *P1, TPolinomio *P2, TPolinomio *Sub);
void PProduto(TPolinomio *P1, TPolinomio *P2, TPolinomio *Prod);
void PDivisao(TPolinomio P, TPolinomio Q, TPolinomio *D, TPolinomio *R);
void PExibe(TPolinomio *P);
main.c 0 → 100755
+ 103
− 0
View file @ e4991f86
#include <stdio.h>
#include <stdlib.h>
#include "TPolinomios.h"
#include "TPolinomios.c"
#include "TExtremos.h"
#include "TExtremos.c"
int main(){
int p;
double x;
TPolinomio P, Q, D, R,Sum,Sub,Prod; //D = Quociente, R = Resto, usado na PDivisao
int escolha;
scanf("%d",&escolha);
switch(escolha){
case 1: //Obter Valor de P(x) dado um X;
PCriar(&P);
scanf("%lf",&x);
printf("Valor = %.2lf\n",PObterValor(&P,x));
break;
case 2: //Obter Obter Ordem/grau
PCriar(&P);
printf("Ordem = %d\n",PObterOrdem(&P));
break;
case 3: //Adicao
PCriar(&P);
PCriar(&Q);
PAdicao(&P,&Q,&Sum);
PExibe(&Sum);
PLibera(&P.poli);
PLibera(&Q.poli);
PLibera(&Sum.poli);
break;
case 4: //Subtracao
PCriar(&P);
PCriar(&Q);
PSubtracao(&P,&Q,&Sub);
PExibe(&Sub); // Exibe Subtracao
PLibera(&P.poli);
PLibera(&Q.poli);
PLibera(&Sub.poli);
break;
case 5: // Produto
PCriar(&P);
PCriar(&Q);
PProduto(&P,&Q,&Prod);
PExibe(&Prod);
PLibera(&P.poli);
PLibera(&Q.poli);
PLibera(&Prod.poli);
break;
case 6: //Divisao
PCriar(&P);
PCriar(&Q);
PDivisao(P,Q,&D,&R);
printf("\nQuociente\n");
PExibe(&D);
printf("Resto\n");
PExibe(&R);
PLibera(&D.poli);
PLibera(&R.poli);
PLibera(&P.poli);
PLibera(&Q.poli);
break;
case 7:
PCriar(&P);
ObterExtremos(&P);
break;
default:
PCriar(&P);
PCriar(&Q);
PExibe(&P); //Polinomios digitados
PExibe(&Q);
PAdicao(&P,&Q,&Sum);
PSubtracao(&P,&Q,&Sub);
PProduto(&P,&Q,&Prod);
printf("Informe o X:\n");
scanf("%lf",&x);
PExibe(&Sum); // Exibe Soma
PExibe(&Sub); // Exibe Subtracao
PExibe(&Prod); // Exibe Produto
printf("Ordem %d\n",PObterOrdem(&P));
printf("Valor %.2lf\n",PObterValor(&P,x));
//Divisao
PDivisao(P,Q,&D,&R);
printf("\nQuociente\n");
PExibe(&D);
printf("Resto\n");
PExibe(&R);
PLibera(&D.poli);
PLibera(&R.poli);
//Procurar Extremos
ObterExtremos(&P);
PLibera(&P.poli);
PLibera(&Q.poli);
PLibera(&Sum.poli);
PLibera(&Sub.poli);
PLibera(&Prod.poli);
break;
}
return 0;
}
  • Jedian @jmb15 ·

    E aí, seu projeto está público, qualquer um pode ver. Só avisando o/

0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment