A funcao pow()

joao76
(usa Solaris)

Enviado em 11/09/2013 - 07:31h

Testei as operacoes:
pow(2,2)=4;
pow(3,2)=9;
pow(4,2)=16;
pow(5,2)=24; ??? Por que?
pow(6,2)=36;
pow(7,2)=49;
...

Antecipo agradecimentos...

EnzoFerber
(usa FreeBSD)

Enviado em 11/09/2013 - 08:54h

Coloca seu código, porque assim tá complicado, aqui funcionou:

enzo C $ gcc -o pow pow.c -lm

enzo C $ ./pow

pow(0,2): 0.000000

pow(1,2): 1.000000

pow(2,2): 4.000000

pow(3,2): 9.000000

pow(4,2): 16.000000

pow(5,2): 25.000000

pow(6,2): 36.000000

pow(7,2): 49.000000

pow(8,2): 64.000000

pow(9,2): 81.000000

 

pow.c:

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <math.h>



int main ( void ) { 

	register int i;



	for ( i = 0; i < 10; i++ ) printf ( "pow(%d,2): %f\n", i, pow(i,2));



	return 0;

}



 

Você mesmo está escrevendo a função pow() ou está usando a biblioteca matemática?

Enzo Ferber
[]'s

ianclever
(usa Arch Linux)

Enviado em 11/09/2013 - 09:32h

vc tem que postar o código para avaliar porque está acontecendo isso, se tua variável for int é algum bug, agora se for float ou double, pode ter alguma parte que está sendo omitida, mas que influencia no cálculo.

paulo1205
(usa Ubuntu)

Enviado em 11/09/2013 - 09:59h

Não só o código, mas também a plataforma (tipo de processador, sistema operacional e versão de compilador) usada.

Eu consigo imaginar um cenário em que a implementação de pow() não seja otimizada para operandos inteiros, em que eventuais erros de arredondamento, tanto dos operandos quanto dos resultados, pudesse produzir algo parecido (imagine o cenário: "quase cinco" elevado a "quase dois", dá um resultado que é "quase vinte e cinco", que ao ser convertido para inteiro sem arredondamento, produz vinte e quatro).

joao76
(usa Solaris)

Enviado em 11/09/2013 - 10:33h

Segue o codigo completo:

#include<stdio.h>
#include<stdlib.h>
#include<math.h>

int main(void)
{
int nro, quad;
system("cls");
puts("Qual e o numero? ");
scanf("%d",&nro);
quad=(pow(nro,2));
printf("Quadrado = %d\n",quad);
system("PAUSE");
return 0;
}

EnzoFerber
(usa FreeBSD)

Enviado em 11/09/2013 - 10:54h

Troca o quad para double.

...

int nro;

double quad;

...



quad = pow(nro, 2);



...

printf("Quadrado = %f\n", quad );

...

 

paulo1205
(usa Ubuntu)

Enviado em 11/09/2013 - 10:55h

Qual o compilador?

vikitor566
(usa Fedora)

Enviado em 11/09/2013 - 11:00h

Tenta limpar o buffer do teclado sempre ante de ler algo do usuário.Já aconteceu muita bizarrice comigo por causa disso.Use a função

getchar() 

logo após o scanf.

paulo1205
(usa Ubuntu)

Enviado em 11/09/2013 - 11:10h

Eu diria mais: além de trocar para double, mande imprimir com umas vinte casas decimais, para ver se está mesmo com erro de arredondamento.

double result;



/* ... */



result=pow(base, expoente);

printf("%#0.20g\n", result); 

joao76
(usa Solaris)

Enviado em 11/09/2013 - 11:40h

Deu certo mudando para double ou tambem definindo como float.

#include<stdio.h>
#include<stdlib.h>
#include<math.h>

int main(void)
{
int nro;
float quad;
system("cls");
puts("Qual e o numero? ");
scanf("%d",&nro);
quad=(pow(nro,2));
printf("Quadrado = %.0f\n",quad);
system("PAUSE");
return 0;
}

Mas por que?... uma vez que o quadrado de um numero
inteiro so pode gerar um numero inteiro.

EnzoFerber
(usa FreeBSD)

Enviado em 11/09/2013 - 11:54h

Pela forma como a função é declarada na biblioteca:

man pow

 

NAME

       pow, powf, powl - power functions



SYNOPSIS

       #include <math.h>



       double pow(double x, double y);

       float powf(float x, float y);

       long double powl(long double x, long double y);



       Link with -lm.



....

 

Ou seja, a função recebe dois argumentos double e retorna um double.

EnzoFerber
(usa FreeBSD)

Enviado em 11/09/2013 - 12:10h

Penso eu que o motivo pelo qual a função é declarada como double é para aumentar a gama de números
suportados pela função.

int	2 or 4 bytes	-32,768 to 32,767     or      -2,147,483,648 to 2,147,483,647

 

Já um double:

double	8 byte	   2.3E-308      to    1.7E+308	            15 decimal places

 

Um double pode chegar a números BEM maiores, e visto que a função pow() gera números MUITO grandes, nada mais justo.

Veja:

#include <stdio.h>

#include <stdlib.h>



int mypow ( int a, int b ) {

	

	return ( b == 0 ) ? 1 : mypow(a, b - 1) * a;

}



int main ( void ) {

	register int i;



	for ( i = 0; i < 100; i++ ) 

		printf ( "pow(%d,5): %d\n", i, mypow(i,5));



	return 0;

}



 

Gera:

enzo C $ ./mypow

pow(0,5): 0

pow(1,5): 1

pow(2,5): 32

pow(3,5): 243

pow(4,5): 1024

pow(5,5): 3125

pow(6,5): 7776

pow(7,5): 16807

pow(8,5): 32768

pow(9,5): 59049

pow(10,5): 100000

pow(11,5): 161051

pow(12,5): 248832

pow(13,5): 371293

pow(14,5): 537824

pow(15,5): 759375

pow(16,5): 1048576

pow(17,5): 1419857

pow(18,5): 1889568

pow(19,5): 2476099

pow(20,5): 3200000

pow(21,5): 4084101

pow(22,5): 5153632

pow(23,5): 6436343

pow(24,5): 7962624

pow(25,5): 9765625

pow(26,5): 11881376

pow(27,5): 14348907

pow(28,5): 17210368

pow(29,5): 20511149

pow(30,5): 24300000

pow(31,5): 28629151

pow(32,5): 33554432

pow(33,5): 39135393

pow(34,5): 45435424

pow(35,5): 52521875

pow(36,5): 60466176

pow(37,5): 69343957

pow(38,5): 79235168

pow(39,5): 90224199

pow(40,5): 102400000

pow(41,5): 115856201

pow(42,5): 130691232

pow(43,5): 147008443

pow(44,5): 164916224

pow(45,5): 184528125

pow(46,5): 205962976

pow(47,5): 229345007

pow(48,5): 254803968

pow(49,5): 282475249

pow(50,5): 312500000

pow(51,5): 345025251

pow(52,5): 380204032

pow(53,5): 418195493

pow(54,5): 459165024

pow(55,5): 503284375

pow(56,5): 550731776

pow(57,5): 601692057

pow(58,5): 656356768

pow(59,5): 714924299

pow(60,5): 777600000

pow(61,5): 844596301

pow(62,5): 916132832

pow(63,5): 992436543

pow(64,5): 1073741824

pow(65,5): 1160290625

pow(66,5): 1252332576

pow(67,5): 1350125107

pow(68,5): 1453933568

pow(69,5): 1564031349

pow(70,5): 1680700000

pow(71,5): 1804229351

pow(72,5): 1934917632

pow(73,5): 2073071593

pow(74,5): -2075960672

pow(75,5): -1921920421

pow(76,5): -1759441920

pow(77,5): -1588183139

pow(78,5): -1407792928

pow(79,5): -1217910897

pow(80,5): -1018167296

pow(81,5): -808182895

pow(82,5): -587568864

pow(83,5): -355926653

pow(84,5): -112847872

pow(85,5): 142085829

pow(86,5): 409302880

pow(87,5): 689241911

pow(88,5): 982351872

pow(89,5): 1289092153

pow(90,5): 1609932704

pow(91,5): 1945354155

pow(92,5): -1999119360

pow(93,5): -1633050899

pow(94,5): -1250894368

pow(95,5): -852125217

pow(96,5): -436207616

pow(97,5): -2594335

pow(98,5): 449273376

pow(99,5): 919965907

 

Viu os erros?

Este aqui:

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <math.h>



int main ( void ) { 

	register int i;



	for ( i = 0; i < 100; i++ ) printf ( "pow(%d,5): %f\n", i, pow(i,5));



	return 0;

}



 

Gera:

enzo C $ ./pow

pow(0,5): 0.000000

pow(1,5): 1.000000

pow(2,5): 32.000000

pow(3,5): 243.000000

pow(4,5): 1024.000000

pow(5,5): 3125.000000

pow(6,5): 7776.000000

pow(7,5): 16807.000000

pow(8,5): 32768.000000

pow(9,5): 59049.000000

pow(10,5): 100000.000000

pow(11,5): 161051.000000

pow(12,5): 248832.000000

pow(13,5): 371293.000000

pow(14,5): 537824.000000

pow(15,5): 759375.000000

pow(16,5): 1048576.000000

pow(17,5): 1419857.000000

pow(18,5): 1889568.000000

pow(19,5): 2476099.000000

pow(20,5): 3200000.000000

pow(21,5): 4084101.000000

pow(22,5): 5153632.000000

pow(23,5): 6436343.000000

pow(24,5): 7962624.000000

pow(25,5): 9765625.000000

pow(26,5): 11881376.000000

pow(27,5): 14348907.000000

pow(28,5): 17210368.000000

pow(29,5): 20511149.000000

pow(30,5): 24300000.000000

pow(31,5): 28629151.000000

pow(32,5): 33554432.000000

pow(33,5): 39135393.000000

pow(34,5): 45435424.000000

pow(35,5): 52521875.000000

pow(36,5): 60466176.000000

pow(37,5): 69343957.000000

pow(38,5): 79235168.000000

pow(39,5): 90224199.000000

pow(40,5): 102400000.000000

pow(41,5): 115856201.000000

pow(42,5): 130691232.000000

pow(43,5): 147008443.000000

pow(44,5): 164916224.000000

pow(45,5): 184528125.000000

pow(46,5): 205962976.000000

pow(47,5): 229345007.000000

pow(48,5): 254803968.000000

pow(49,5): 282475249.000000

pow(50,5): 312500000.000000

pow(51,5): 345025251.000000

pow(52,5): 380204032.000000

pow(53,5): 418195493.000000

pow(54,5): 459165024.000000

pow(55,5): 503284375.000000

pow(56,5): 550731776.000000

pow(57,5): 601692057.000000

pow(58,5): 656356768.000000

pow(59,5): 714924299.000000

pow(60,5): 777600000.000000

pow(61,5): 844596301.000000

pow(62,5): 916132832.000000

pow(63,5): 992436543.000000

pow(64,5): 1073741824.000000

pow(65,5): 1160290625.000000

pow(66,5): 1252332576.000000

pow(67,5): 1350125107.000000

pow(68,5): 1453933568.000000

pow(69,5): 1564031349.000000

pow(70,5): 1680700000.000000

pow(71,5): 1804229351.000000

pow(72,5): 1934917632.000000

pow(73,5): 2073071593.000000

pow(74,5): 2219006624.000000

pow(75,5): 2373046875.000000

pow(76,5): 2535525376.000000

pow(77,5): 2706784157.000000

pow(78,5): 2887174368.000000

pow(79,5): 3077056399.000000

pow(80,5): 3276800000.000000

pow(81,5): 3486784401.000000

pow(82,5): 3707398432.000000

pow(83,5): 3939040643.000000

pow(84,5): 4182119424.000000

pow(85,5): 4437053125.000000

pow(86,5): 4704270176.000000

pow(87,5): 4984209207.000000

pow(88,5): 5277319168.000000

pow(89,5): 5584059449.000000

pow(90,5): 5904900000.000000

pow(91,5): 6240321451.000000

pow(92,5): 6590815232.000000

pow(93,5): 6956883693.000000

pow(94,5): 7339040224.000000

pow(95,5): 7737809375.000000

pow(96,5): 8153726976.000000

pow(97,5): 8587340257.000000

pow(98,5): 9039207968.000000

pow(99,5): 9509900499.000000

 

Gera os números sem problemas...

Entendeu?

Enzo Ferber
[]'s