[C/C++] long double + pow() = @#$%!!!

no więc cały mój problem polega na tym że nie potrafie dobrze zapisać wyniku z: 2^(-16445) zapisać do zmiennej typu "long doube", a potem jej wyświetlić

a tutaj mój kod

   printf("\n\nDla long double \n");
    long double epsilon3=1;
    int q3=0;
    long double suma3;
    long double pam;
    suma3=1+epsilon3;
    while(suma3>1)
    {
      epsilon3/=2;
      suma3=1+epsilon3;
      q3--;
    }
    printf("epsilon wynosi: 2^%d\n",q3+1);
    
    while(epsilon3>0)
    {epsilon3/=2;
    q3--;
    }
    q3++;
    
    suma3=pow(2,q3);
    printf("najmniejsza liczba wynosi: 2^%d = %Le\n",q3,suma3);

z góry dzieki za pomoc

A gdzie w tym kodzie jest funkcja pow()?

juz jest :P
próbowałem pow() zastąpić przez ^, i przypadkowo wkleiłem zmienioną wersje

Powiedz z jakiego kompilatora korzystasz?
long double w gcc (dla windows) ma 12 bajtów i printfa nie wiem jak zrobić żeby ruszył.

Przyznam, że chętnie poznałbym odpowiedź :) jak za pomocą printfa wyświetlić long double (12 bajtów) w gcc.

Dorzuce jeszcze kodzik:

#include <cstdlib>
#include <cstdio>
#include <cmath>
using namespace std;
int main()
{
    long double zmienna1 = pow((long double)2, (long double)-1);
    printf("%Le %Le\n", zmienna1, pow((long double)2, (long double)-1));
    system("pause");
    return 0;
}

Wynik:

0.000000e+000 8.093783e-320

Mógłby więc ktoś wyjaśnić long double 12 bajtów i printf, bo ja nie kumam i nic nie udało mi się znaleźć?

kompilowałem i pod windą i Linuxem

w końcu się wnerwiłem i zrobiłem po prostu pętle która dzieli 1 prz 2 "q3" razy.
i mam wynik :D

Używam linuksa i mam gcc 4.1, a powyższy pogram daje mi poprawny wynik(LD mam 12 bajtowego):

5.000000e-01 5.000000e-01

Może spróbuj "%Lf".

#include <cstdio>
#include <algorithm>
using namespace std;

#define LD long double

int main()
{
	printf("double\nrozmiar: %d\nmax: %lf\n\nlong double\nrozmiar: %d\nmax: %Lf\n", sizeof(double), numeric_limits<double>::max(), sizeof(LD), numeric_limits<LD>::max());
	return 0;
}

Daje:

double
rozmiar: 8
max: <179769313... - liczba na około 3 linie>

long double
rozmiar: 12
max:<118973149... - liczba na około 30 linii>

__krzysiek85 te przełączniki to ja już wszystkie sprawdziłem z ciekawości, a na googlach nic nie znalazłem :).

To jest gcc pod win, ono ma niektóre inne rzeczy. Jesli pod lin ci chodzi, to teraz pytanie jak zrobić to pod windows.

Przykład różnicy między lin a win:
lin -> %lld
win -> %I64d
nie wiem czy nie pomyliłem formatu dla linuksa, ale chyba nie. Może coś takiego jest dla LD?

Spradzałem na BCB6, ale tam nie ma co sprawdzać, bo sizeof(long double)==10

No, ciekawa sprawa. quetzalcoatl, deus, pomożecie?

Na windzie printf jest z msvcrt - używa long double maszynowego - 80bitów, gcc używa zaś software'owego long double - 12bajtów.

deus no właśnie, ale jak na gcc to wyświetlić przy pomocy printf?

hm.. to Ci sie moze niespodobac, ale:

#include <iostream>

int main()
{
    long double lx = -9.999e-100;
    std::cout << sizeof(lx) << std::endl;
    printf("Lf\t%Lf\n",lx);
    printf("lf\t%lf\n",lx);
    printf("f\t%f\n",lx);
    std::cout << "ostream:\t" << lx << std::endl;
}

daje wynik:

./a -sh-3.00# ./a.out
12
Lf -0.000000
lf -0.000000
f -0.000000
ostream: -9.999e-100

co jest zastanawaijace.. gdzies-tam na jakims usenetowym watku z 2005r znalazlem stwierdzenie, ze printf nie obsluguje typu logn double w ogole, i zeby zaczal - tzreba sobie wlasnego %cos handlera napisac i zarejestrowac.. tak wiec, wydaje mi sie, ze lepiej uzywac strumieni - one jak widac sobei pieknie radza

PS. sizeofa specjalnei wyswietlilem. tak naprawde, long double jest 10 bajtowy, tyle ze g++ sobie go alignuje do 4B (dostawia 2 zerowe bajty na koniec).. siedzielismy z deusem i darkjamesem ladne ze dwie godziny i udalo nam sie wyszperac dwie flagi:
-mno-align-double
-malign-double
ktore, no, powinny sterowac tym mechanizmem. podobno z -mno-align powinno byc sizeof(logndouble) = 10... ale tak nie jest... czy jest -mno-align czy -malign, long double i tak wazy 12B.. bug?

No to ciekawa sprawa. A zaczęło się tak niepozornie ;)
Wiem, że przy 10 bajtowym na BCB6 przeszło.
To ze strumieniami też zauważyłem, ale ciekawość pozostała :).
Też znalazłem jakiś wątek że printf sobie nie radzi, ale to chyba tylko w GCC pod windows. Cieakawe właśnie jak to pod linuksem. __krzysiek85 twierdzi, że jemu pod linuksem działało, więc...

Jeszcze jutro sam poszperam z ciekawości :), chyba że cosik odkryjecie...

Żeby w C się nie dało wyświetlić :)? hehe, a to pewnie sprintf itd też nie działają. To dość nieładne :(.

#include <stdio.h>
int main() {
    long double lx = -9.999e-100;
    printf("Lg\t%Lg\n", lx);
    printf("Lf\t%.300Lf\n", lx);
}

daje wynik:

Lg -9.999e-100
Lf -0.000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000099990000000000000598046167064023961881318046427070
56257742086952859544292201649400290031486354985641768987918155014996256998750739
10733983622775388068248082645948418592077693948941371033796988632764740

Nocy.

__krzysiek85 napisał(a)

Używam linuksa i mam gcc 4.1, a powyższy pogram daje mi poprawny wynik(LD mam 12 bajtowego):

5.000000e-01 5.000000e-01

a podnieś do -16445 , chyba mi nie powiesz że też ci wychodzi?

darkjames czym swoje kompilowałeś i jaki system?

na gcc z mingw mam:

Lg      -5.31015e-251
Lf      -0.000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000053101463237404001000000000000000000000000000000000

a borland to już w ogóle sobie uprościł :):

Lg      -9.999e-100
Lf      -0.000000000000000000000000000000000000000

vha napisał(a)

a podnieś do -16445 , chyba mi nie powiesz że też ci wychodzi?

Wyniki:
Le: 3.645200e-4951
%.10000Lf: 0.(jakieś 5000 zer)3645199531882474602528405933619....

W obu przypadkach wygląda na dobry wynik.</quote>

RR napisał(a)

darkjames czym swoje kompilowałeś i jaki system?

glibc-2.6.1, gcc-4.1.2 ogolnie Linux. To byl kod dla quetzalcoatl, ze na linuksie z uzyciem printf() (bez strumieni C++) sie jednak da. A nie ze wyswietla -0.000000

To co udało się komuś to uruchomić. Ja już mam dość :).
Kurcze, jak zainstalować gcc 4.x.x z mingw.

http://sourceforge.net/project/showfiles.php?group_id=2435

Przyznam, że nie znam dobrze tego projektu mingw. gcc4 da się zainstalować i uruchomić? Jeśli tak to jak, bo mi jakoś nie idzie :). Może tam by działało.

ozesz w morde.. przeiciez ja LF pisalem a nie LG.. eeeh.. wycofuje oskarzenia wysuniete w kierunku libc/printf :)