Potęgowanie rekurencyjne ułamków. Źle zwraca wynik

Witam,
mam do stworzenia program potęgujący ułamki, rekurencyjnie. Założeniem jest wpisanie licznika, mianownika i potęgi.
Niestety o ile przy liczbie całkowitej wynik wychodzi poprawnie to przy ułamkowym zwraca niepoprawny wynik.

Kod do obliczania potęgi liczby całkowitej (poprawny)

 
funkcja1(int l, int p)
{
int wynik;
    if (p==0) return 1;
       else
       {
       wynik=l*funkcja1(l, p-1);
       return wynik;
       }
}

int main(int argc, char *argv[])
{
  int liczba, potega, wynik=0, x;
       printf("podaj liczbe ktora potegujemy\n");
       scanf("%d", &liczba);
       
       printf("podaj jej potege\n");
       scanf("%d", &potega);

            x=funkcja1(liczba, potega);
            wynik=x+wynik;
            printf("wynik %d ", wynik);
            
  system("PAUSE");	
  return 0;
}

Kod do obliczania potęgi na ułamkach (ten już nie działa)
przerabiałem go na podstawie kodu do liczb całkowitych. Zwraca 0 albo 1.

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



funkcja2(int l, int m, int p)
{
 float wynik, dziel;
 dziel=1.0*l/m;

              if (p==1) return dziel;
              if (p==0) return 1;
                 else
                 {
                 wynik=dziel*funkcja2(l, m, p-1);
                 return 1.0*wynik;    
                 }     
}

int main(int argc, char *argv[])
{
  int mianownik, potega, licznik;
  float x, wynik=0;
       printf("podaj licznik ktory potegujemy\n");
       scanf("%d", &licznik);
       
       printf("podaj mianownik ktory potegujemy\n");
       scanf("%d", &mianownik);
       
       printf("podaj jej potege\n");
       scanf("%d", &potega);

            x=funkcja2(licznik, mianownik, potega);
            wynik=x+wynik;
            printf("wynik %f ", wynik);
            
  system("PAUSE");	
  return 0;
}

Dodwałem 1.0* do zmiennych z myślą ze możne return jakoś złe zwraca wartość, ale nic nie pomogło :/

funkcja2 zwraca int
ile razy liczysz 1.0*l/m i w jakim celu?

Poprawione:

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

float funkcja2(int l, int m, int p)
{
 float wynik, dziel;
 dziel=1.0*l/m;

              if (p==1) return dziel;
              if (p==0) return 1;
                 else
                 {
                 wynik=dziel*funkcja2(l, m, p-1);
                 return 1.0*wynik;    
                 }     
}

int main(int argc, char *argv[])
{
  int mianownik, potega, licznik;
  float x, wynik=0;
       printf("podaj licznik ktory potegujemy\n");
       scanf("%d", &licznik);
       
       printf("podaj mianownik ktory potegujemy\n");
       scanf("%d", &mianownik);
       
       printf("podaj jej potege\n");
       scanf("%d", &potega);

            x=funkcja2(licznik, mianownik, potega);
            wynik=x+wynik;
            printf("wynik %f ", wynik);
            
  system("PAUSE");	
  return 0;
}

}

funkcja dziel wywołuje się tylko raz?
sugerujesz żebym ustawił ją jako zmienną globalną? (o ile się da)

zapisałbym tak:

double rPow(double x, int n){
        if( n < 0 ) { 
                n = -n; x = 1/x; }
        if( n== 0 ) return 1;
        if( n & 1 ) return x*rPow( x, n - 1 );
        else {
                double a = rPow( x, n/2 ); 
                return a*a; }} 

albo iteracyjnie

double Pow(double x, int n){
        double r=1;
        if( n<0 ) {
                n = -n;   // bywa, że n == -n
                x = 1/x; }
        while( 1 ){
                if( n & 1 )
                        r *= x;
                if( n>>=1 )
                        x *= x;
                else 
                        return r; }}

ale...

czyli 2.71828182845904523536028747...
typ double to około 14 cyfr, ile dokładnych cyfr potrafisz obliczyć?
http://ideone.com/h4w4b
Prosta iteracja (gPow) uzyskasz
+30 2.7182818271932 w czasie 3.7 sekundy zamiast
e = 2.71828182845904523536028747... moim (iPow lub Rpow) uzyskałem
+30 2.7182818271932 ale w czasie 0.01 sekundy. Ale po dość prostej zmianie
+52 2.7182818284590 też w czasie 0.01 skundy