Na ez mi ?

Kezdőlap Fórumok Programozás Na ez mi ?

10 bejegyzés megtekintése - 11-20 / 33
  • Szerző
    Bejegyzés
  • #2010692
    Micsoda
    Felhasználó

      Szerintem a c/c++ ezt inkább double-á konvertálja, mivel az ‘a’ változó olyan típusú (és a kiértékelési sorrend miatt).
      A hiba tényleg a számábrázolásból adódik, és platform (mármint pl intel/motorola) és valószínûleg fordító függõ is.  🙂
      [align=right][snapback]126880[/snapback][/align]

      #2010693
      uzsolt
      Felhasználó

        Szerintem itt nem lehet hülyeséget mondani amíg a megoldás nincs meg.
        Az tény, ha két egész számmal végezzük a mûveletet akkor minden OK, viszont ha belép egy tört akkor van a hiba.
        [align=right][snapback]126875[/snapback][/align]

        Akkor mondok valamit: b*a -t próbáltad már? Nem feltétlenül biztos, hogy a szorzás kommutatív, amikor valami géppel számolsz.

        #2010694
        Micsoda
        Felhasználó

          Akkor mondok valamit: b*a -t próbáltad már? Nem feltétlenül biztos, hogy a szorzás kommutatív, amikor valami géppel számolsz.
          [align=right][snapback]126886[/snapback][/align]

          Igen sõt a: (a*B) – c != 0 -t is.

          #2010695
          kelemengabor
          Felhasználó

            uzsolt: erre tudnál példát hozni? Elég meredeken hangzik, hogy a szorzás nem mindig
            kommutatív :ph34r:
            micsoda: akkor ennek:

            Code:
            int main(int argc, char * argv[]) {

            double a,b,c;
            a=65.13;
            b=21160;
            c=a*b;
            printf („a=%lf, b=%lf, c=%lf, a*b=%lf „,a,b,c,(a*b));
            if((a*b)!=c)
            printf(„nMost hibáztam!na:t%14.4fnb:t%14.4fnc:t%14.4fna*b:t%14.4fnn”,a,b,c,(a*b));
            else
            printf(„nMost eltaláltam!na:t%1fnb:t%1fnc:t%1fnn”,a,b,c);
            return 0;
            }

            a teljes kimenetét tudnád postolni? Nálam rendben van, de kíváncsi lennék. Valamint egy gcc -v -t is.

            #2010696
            Micsoda
            Felhasználó

              uzsolt: erre tudnál példát hozni? Elég meredeken hangzik, hogy a szorzás nem mindig
              kommutatív  :ph34r:
              micsoda: akkor ennek:

              Code:
              int main(int argc, char * argv[]) {

              double a,b,c;
              a=65.13;
              b=21160;
              c=a*b;
              printf („a=%lf, b=%lf, c=%lf, a*b=%lf „,a,b,c,(a*b));
              if((a*b)!=c)
              printf(„nMost hibáztam!na:t%14.4fnb:t%14.4fnc:t%14.4fna*b:t%14.4fnn”,a,b,c,(a*b));
              else
              printf(„nMost eltaláltam!na:t%1fnb:t%1fnc:t%1fnn”,a,b,c);
              return 0;
              }

              a teljes kimenetét tudnád postolni? Nálam rendben van, de kíváncsi lennék. Valamint egy gcc -v -t is.
              [align=right][snapback]126888[/snapback][/align]

              Kedves Mindenki !

              #2010697
              kelemengabor
              Felhasználó
                #2010698
                ds
                Felhasználó

                  -Wfloat-equal
                  Warn if floating point values are used in equality comparisons.

                  The idea behind this is that sometimes it is convenient (for the
                  programmer) to consider floating-point values as approximations to
                  infinitely precise real numbers. If you are doing this, then you
                  need to compute (by analyzing the code, or in some other way) the
                  maximum or likely maximum error that the computation introduces,
                  and allow for it when performing comparisons (and when producing
                  output, but thatâs a different problem). In particular, instead of
                  testing for equality, you would check to see whether the two values
                  have ranges that overlap; and this is done with the relational
                  operators, so equality comparisons are probably mistaken.

                  $ gcc t.c
                  $ ./a.out

                  Most hibáztam!
                  a: 65.1400
                  b: 21160.0000
                  c: 1378362.4000
                  a*b: 1378362.4000

                  $ gcc -fsingle-precision-constant t.c
                  $ ./a.out

                  Most eltaláltam!
                  a: 65.1400
                  b: 21160.0000
                  c: 1378362.3871

                  -fsingle-precision-constant
                  Treat floating point constant as single precision constant instead
                  of implicitly converting it to double precision constant.

                  $ gcc -v
                  Reading specs from /usr/lib/gcc-lib/i386-redhat-linux/3.3.2/specs
                  Configured with: ../configure –prefix=/usr –mandir=/usr/share/man –infodir=/usr/share/info –enable-shared –enable-threads=posix –disable-checking –with-system-zlib –enable-__cxa_atexit –host=i386-redhat-linux
                  Thread model: posix
                  gcc version 3.3.2 20031022 (Red Hat Linux 3.3.2-1)

                  #2010699
                  kelemengabor
                  Felhasználó

                    Az én megoldásom:

                    Code:
                    int main(int argc, char * argv[]) {

                    long double a,b,c;
                    a=65.13;
                    b=21160;
                    c=a*b;
                    printf („a=%Lf, b=%Lf, c=%Lf, a*b=%Lf „,a,b,c,(a*b));
                    if((long double)(a*b)!=c)
                    printf(„nMost hibáztam!na:t%L4.4fnb:t%L4.4fnc:t%L4.4fna*b:t%L4.4dnn”,a,b,c,(a*b));
                    else
                    printf(„nMost eltaláltam!na:t%Lfnb:t%Lfnc:t%Lfnn”,a,b,c);
                    return 0;
                    }

                    gabor@ubuntu:/mnt/uhuhomehda3/gabor $ ./teszt
                    a=65.130000, b=21160.000000, c=1378150.800000, a*b=1378150.800000
                    Most eltal

                    #2010700
                    Micsoda
                    Felhasználó

                      -Wfloat-equal
                                Warn if floating point values are used in equality comparisons.

                                The idea behind this is that sometimes it is convenient (for the
                                programmer) to consider floating-point values as approximations to
                                infinitely precise real numbers.  If you are doing this, then you
                                need to compute (by analyzing the code, or in some other way) the
                                maximum or likely maximum error that the computation introduces,
                                and allow for it when performing comparisons (and when producing
                                output, but thatâs a different problem).  In particular, instead of
                                testing for equality, you would check to see whether the two values
                                have ranges that overlap; and this is done with the relational
                                operators, so equality comparisons are probably mistaken.
                      $ gcc  t.c
                      $ ./a.out

                      Most hibáztam!
                      a:            65.1400
                      b:          21160.0000
                      c:        1378362.4000
                      a*b:      1378362.4000

                      $ gcc  -fsingle-precision-constant t.c
                      $ ./a.out

                      Most eltaláltam!
                      a:            65.1400
                      b:          21160.0000
                      c:        1378362.3871
                      -fsingle-precision-constant
                                Treat floating point constant as single precision constant instead
                                of implicitly converting it to double precision constant.
                      $ gcc -v
                      Reading specs from /usr/lib/gcc-lib/i386-redhat-linux/3.3.2/specs
                      Configured with: ../configure –prefix=/usr –mandir=/usr/share/man –infodir=/usr/share/info –enable-shared –enable-threads=posix –disable-checking –with-system-zlib –enable-__cxa_atexit –host=i386-redhat-linux
                      Thread model: posix
                      gcc version 3.3.2 20031022 (Red Hat Linux 3.3.2-1)
                      [align=right][snapback]126898[/snapback][/align]

                      Kösz, de evvel szerintem még nem oldódott meg a probléma, mivel c értéke kissé eltér a normálistól ( nem merem azt írni, hogy a végeredménytõl, mert manapság az már nem tudható biztosan :-)) ).
                      Sajnos most én nem tudom kipróbálni az általam talált doksiban említett két módszert:
                      1)

                      #2010701
                      kelemengabor
                      Felhasználó

                        2) A változót áttenni: long double-ba.

                        De ha valaki meg tudja tenni, kérem mondja megh sikerült-e ?
                        [align=right][snapback]126903[/snapback][/align]

                        Ld fenti hozzászólásom. Az 1.-t meg lásd ds hozzászólásában. Válogathatsz 🙂

                      10 bejegyzés megtekintése - 11-20 / 33
                      • Be kell jelentkezni a hozzászóláshoz.