[ANSI C] spaghetti pow()

[andr3a]

salve

siccome ho scoperto che alcuni compilatori GCC , se si include math.h a inizio file, funzionano mentre altri no e siccome su quelli che funzionano ( ad esempio la versione 4 ) se metto -lm per forzare l' inclusione della libreria mi danno errore, ho deciso di evitare di perdere tempo con il GCC e di farmi a manina la funzione per elevare a potenza.

Quella che mi serve di fatto e' una potenza di interi, ovvero base intera unsigned e potenza intera unsigned, che ovviamente tornera' sempre e solo interi unsigned ... mi dite cosa ne pensate ?

grazie

#include <stdio.h>

/********************************/
/* Dichiarazione delle funzioni */
/********************************/

unsigned int potenza_interi(
	unsigned int numero,
	unsigned int potenza
); /* funzione per elevare a potenza di tipo intero 
      positivo o uguale a zero un numero anch' esso 
      di tipo intero e positivo o uguale a zero */



/******************************/
/* Definizione delle funzioni */
/******************************/

/* Definizione della funzione main */
int main(
	int 	argc, 
	char 	*argv[]
)
{
	
	printf("Risultato: %i", potenza_interi(4, 2));
	
	/* fine funzione main */
	return 0;
}

/* Definizione della funzione potenza_interi */
unsigned int potenza_interi(
	unsigned int numero,       /* Lavoro: numero da elevare a potenza */
	unsigned int potenza       /* Lavoro: valore della potenza */
)
{
	/* dichiarazione delle variabili locali alla funzione */
	unsigned int elevato = 1;  /* Lavoro: numero da restituire 
				      dopo l' elevazione a potenza */
	
	/* ciclo di controllo per 
	   moltiplicare N(potenza) volte il numero 
	   solo se N e' diverso e maggiore di zero */
	while(potenza != 0 && potenza-- > 0)
	{
		elevato *= numero;
	}
	
	/* fine funzione potenza_interi
	   ritorno l' elevazione a potenza */
	return elevato;
}

[kentaromiura]

mmm..
anche cosi':

long pow(unsigned int base,unsigned int exp)
{
//0^0 non esiste
if (base==exp==0)return -1;

unsigned int res=1;

for(i=1;i<exp;i++)res*=base;
return res;
}

naturalmente devi gestire l'overflow..

edit:
non puoi usare unsigned int come valore di ritorno perche' in caso di 0^0 non puoi gestirti il -1

[andr3a]

0 alla 0 non fa 1 ?
oppure non e' vero che qualunque numero elevato alla zero da 1 ?

comunque sia hai scritto tutto tranne che ANSI C secondo il prof

1 solo return per funzione
la variabili vanno dichiarate a inizio funzione
l' indentatura e' fondamentale

[kentaromiura]

Originariamente inviato da andr3a
0 alla 0 non fa 1 ?

assolutissimamente no.

oppure non e' vero che qualunque numero elevato alla zero da 1 ?

qualunque tranne 0.

comunque sia hai scritto tutto tranne che ANSI C secondo il prof

1 solo return per funzione
la variabili vanno dichiarate a inizio funzione
l' indentatura e' fondamentale

ma chi se ne frega,ti ho dato un consiglio..
poi spetta a te migliorarlo..

[andr3a]

Originariamente inviato da kentaromiura
assolutissimamente no.

qualunque tranne 0.

<?php
echo ''.pow(0,0);
?>

#include <math.h>
int main(
int argc,
char *argv[]
)
{
printf("Risultato: %f", pow(0.00, 0.00));
return 0;
}


ti scrivo i risultati o le testi da solo ?
dai , te li scrivo:
1
1.0000000

Originariamente inviato da kentaromiura
ma chi se ne frega,ti ho dato un consiglio..
poi spetta a te migliorarlo..

ok, calma



[editato]
ok, potrebbe essere come dici un risultato di convenzione, quella convenzione e' utile anche a me al fine dell' applicativo, se pow mi andava bene, questa funzione mi va bene altrettanto, sara' mia premura, grazie alle tue delucidazioni, spiegare che la funzione non considera appositamente la casistica 0^0 poiche' questa non e' necessaria ai fini dell' applicativo.

quindi, detto questo, va bene quella che ho scritto ???

[kentaromiura]

http://www.linuxquestions.org/questi...003/04/2/53893

qui spiegano meglio il perche' da' 1, e' stata
la IEEE 854
a definire pow(0,0) =1
ma matematicamente parlando non esiste.


ad occhio sembra giusta, pero' ti consiglio di calcolare con un long il risultato,
castare l'unsigned int a long e se i risultati non differiscono
(cosi' gestisci l'overflow)
restituire il dato (ti serve comunque long per via del -1)

[Ilmalcom]

Ricorsiva non ti piace? Forse è il modo più naturale per definire le potenze...

int potenza (int base, int esponente) {
        int risultato;
        if (esponente == 0)
                risultato = 1;
        else
                risultato = base * potenza (base,esponente-1);
        return risultato;
}

Per basi intere unsigned ed esponenti interi unsigned dovrebbe andare bene...