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