Holen Sie sich den durchschnittlichen Wert aus einem Vektor von Integer-zahlen

Habe ich nicht in der Lage war einen Weg zu finden, immer der Durchschnittliche Wert aus einem Vektor von Integer-zahlen in C++.

Kann ich vielleicht beginnen Sie mit dem einfügen alle Werte, da könnte ich mehr als die maximale integer-Wert angenommen.

Wie kann ich berechnen, diese effizient und schnell ? Gibt es irgendwelche standard-Bibliotheken in der Sprache C++ zu tun ?

Könnten Sie die Akkumulation in einem double. Da die Durchschnittliche ganzer zahlen muss keine ganze Zahl, es scheint, Sie gehen zu müssen, um floating-point sowieso.
Dann nicht sich zu eine int (verwenden Sie eine uint64_t statt, zum Beispiel).
Ich habe einen richtig großen Vektor von 23 Mio zahlen, ich denke nicht, dass dieser Weg funktionieren würde. Gibt es nicht eine Möglichkeit, dies zu tun, andere als manuell ?
Hängt davon ab, wie viele es sind -, wenn die Summe geht über 2^53, dann double führen zu ungenauen Ergebnissen. (Limit für uint64_t ist 2^64.)
23 Mio € ist wesentlich weniger als 2^64 / 2^32.
Was ist falsch mit std::accumulate( vector.begin(), vector.end(), 0.0) / vector.size();
Könnten Sie int64_t wenn der Vektor verfügt über 32-bit-Ganzzahlen. Wenn Sie 64-bit-Ganzzahlen, die Sie nutzen könnten __int128_t oder gleichwertig (vorausgesetzt, Ihr compiler bietet es).
Gemeinsame Jungs, wenn Sie zu tun haben durchschnittlich 1Mio zahlen, Veranstaltung mit langen (oder eher gesagt lange lange), er wird überlaufen. Und mit verdoppelt würde, er einen schrecklichen Verlust der Genauigkeit im Durchschnitt. Er muss wirklich etwas mehr...
1 million wird nicht überlaufen (vorausgesetzt, wir meinen int durch "integer").
wäre er fügt 1 million von Ganzzahlen, die jeweils um MAX_INT/2 er wird sicherlich überlaufen...
Nicht, wenn akkumulieren in einer 64-bit-Typ (vorausgesetzt, die ursprünglichen Vektor enthält 32-bit-Werte).
23 Millionen * int32_max passt problemlos in eine 64-bit-integer. Solange Sie nicht mehr als 4 Milliarden int (2^32 um genau zu sein) in den Vektor, der sich in eine int64_t wird gut tun.
Sie können auf jeden Fall tun, dass mit einer einfachen Formel so lange, wie Sie wissen, zählen der Elemente. Angenommen, ein Vektor ist eine. So Formel sein wird. S+= a[i]/n

InformationsquelleAutor dimitris93 | 2016-03-06

c++vector

25

Go-Ansatz ist nur Summierung mit einem ausreichend breiten integer-Typ mit std::accumulate:
```
double avg1(std::vector<int> const& v) {
    return 1.0 * std::accumulate(v.begin(), v.end(), 0LL) / v.size();
}
```
Wenn diese Summe überläufe (mit 23 Millionen int-Werte, der Durchschnitt müsste mindestens 4.01x10¹¹, das heißt, es wird nicht überlaufen da, die gar nicht passen in einem int32_t... also du bist so gut, aber auf der off-chance, die Sie bekommen ein Vielfaches mehr zahlen, oder haben eine breitere int - Typ), dann Sie können stattdessen die üblichen "online" - Algorithmus für die Berechnung der Mittelwerte:
```
double avg2(std::vector<int> const& v) {
    int n = 0;
    double mean = 0.0;
    for (auto x : v) {
        double delta = x - mean;
        mean += delta/++n;
    }
    return mean;
}
```
Diese nicht überlaufen, ist nicht sehr anfällig für den Verlust von Genauigkeit, aber möglicherweise teurer, da Sie wiederholt extra Abteilungen.
- Gibt es eine Ressource, wo eine Analyse der Fehlerfortpflanzung der avg2 ist gegeben? Ich finde es schwer zu verstehen, wo diese würde einen Unterschied machen, um die naiv, std::accumulate mit einem Doppel -T init. Mit Doppel-16-17 Ziffern; und 32-bit-int-10-Ziffern. 64-bit-int über 20 stellen.
- href="http://www.jstor.org/stable/2683386?seq=1#page_scan_tab_contents" >jstor oder tandf
- Stellen Sie sich einen Vektor mit 2^53 Einträge, jeder Wert 1 (könnte auch kommen mit Beispiele, die erfordern, dass Weise weniger Einträge...)
- Vector wäre rechnerisch untragbar. =)
- In der Tat! Aber zeigt das Problem - sobald die Eingabe-Werte liegen unter den ULP der Akku, werden Sie nicht beitragen.
InformationsquelleAutor Barry
1

Habe ich nicht in der Lage war einen Weg zu finden, immer der Durchschnittliche Wert aus einer
Vektor von Integer-zahlen in C++. Kann ich vielleicht beginnen Sie alle
Werte, da könnte ich mehr als die maximale integer-Wert angenommen. Wie
kann ich berechnen, diese effizient und schnell ? Gibt es irgendwelche standard
Bibliotheken in C++.

Viele Diskussionen finden, eine Summe, die vielleicht zu groß sogar für einen uint64_t.

So Folgen Sie diesen Vorschlag und aufhören, sich sorgen ...

Habe ich genutzt, kann es empfehlen und bin sehr zufrieden mit der multi-precision C++ Bibliothek namens "gmpxx.h".

Ich benutzte es für mehrere interessant Bemühungen, einschließlich code zu generieren, eine große fibonacci-ohne erkennbare Anstrengung. Es ist einfach zu bedienen und überraschend schnell, und ich habe auf dem web-Beispiele für die Verwendung.

Code-snippet:
```
mpz_class  n;   //a multi-precision integer, 
n = 1;          //easy initialize
size_t F = 1000; 
for (size_t i=1; i<=F; ++i)
   n = n * i;
//show
std::string Fstr = digiComma(n);  //inserts comma's
std::cout << "\n" << F << "! = " << Fstr
          << "\n" << digitCnt(Fstr) << " bytes " <<  std::endl;
```
Meine Ausgabe ist eine 2568-Zeichen (>1900-stellig), durch Komma getrennte, große int-Wert in < 20 ms.

1000! =
402,387,260,077,093,773,543,702,433,923,003,985,719,374,864,210,714,632,543,799,
910,429,938,512,398,629,020,592,044,208,486,969,404,800,479,988,610,197,196,058,
631,666,872,994,808,558,901,323,829,669,944,590,997,424,504,087,073,759,918,823,
627,727,188,732,519,779,505,950,995,276,120,874,975,462,497,043,601,418,278,094,
646,496,291,056,393,887,437,886,487,337,119,181,045,825,783,647,849,977,012,476,
632,889,835,955,735,432,513,185,323,958,463,075,557,409,114,262,417,474,349,347,
553,428,646,576,611,667,797,396,668,820,291,207,379,143,853,719,588,249,808,126,
867,838,374,559,731,746,136,085,379,534,524,221,586,593,201,928,090,878,297,308,
431,392,844,403,281,231,558,611,036,976,801,357,304,216,168,747,609,675,871,348,
312,025,478,589,320,767,169,132,448,426,236,131,412,508,780,208,000,261,683,151,
027,341,827,977,704,784,635,868,170,164,365,024,153,691,398,281,264,810,213,092,
761,244,896,359,928,705,114,964,975,419,909,342,221,566,832,572,080,821,333,186,
116,811,553,615,836,546,984,046,708,975,602,900,950,537,616,475,847,728,421,889,
679,646,244,945,160,765,353,408,198,901,385,442,487,984,959,953,319,101,723,355,
556,602,139,450,399,736,280,750,137,837,615,307,127,761,926,849,034,352,625,200,
015,888,535,147,331,611,702,103,968,175,921,510,907,788,019,393,178,114,194,545,
257,223,865,541,461,062,892,187,960,223,838,971,476,088,506,276,862,967,146,674,
697,562,911,234,082,439,208,160,153,780,889,893,964,518,263,243,671,616,762,179,
168,909,779,911,903,754,031,274,622,289,988,005,195,444,414,282,012,187,361,745,
992,642,956,581,746,628,302,955,570,299,024,324,153,181,617,210,465,832,036,786,
906,117,260,158,783,520,751,516,284,225,540,265,170,483,304,226,143,974,286,933,
061,690,897,968,482,590,125,458,327,168,226,458,066,526,769,958,652,682,272,807,
075,781,391,858,178,889,652,208,164,348,344,825,993,266,043,367,660,176,999,612,
831,860,788,386,150,279,465,955,131,156,552,036,093,988,180,612,138,558,600,301,
435,694,527,224,206,344,631,797,460,594,682,573,103,790,084,024,432,438,465,657,
245,014,402,821,885,252,470,935,190,620,929,023,136,493,273,497,565,513,958,720,
559,654,228,749,774,011,413,346,962,715,422,845,862,377,387,538,230,483,865,688,
976,461,927,383,814,900,140,767,310,446,640,259,899,490,222,221,765,904,339,901,
886,018,566,526,485,061,799,702,356,193,897,017,860,040,811,889,729,918,311,021,
171,229,845,901,641,921,068,884,387,121,855,646,124,960,798,722,908,519,296,819,
372,388,642,614,839,657,382,291,123,125,024,186,649,353,143,970,137,428,531,926,
649,875,337,218,940,694,281,434,118,520,158,014,123,344,828,015,051,399,694,290,
153,483,077,644,569,099,073,152,433,278,288,269,864,602,789,864,321,139,083,506,
217,095,002,597,389,863,554,277,196,742,822,248,757,586,765,752,344,220,207,573,
630,569,498,825,087,968,928,162,753,848,863,396,909,959,826,280,956,121,450,994,
871,701,244,516,461,260,379,029,309,120,889,086,942,028,510,640,182,154,399,457,
156,805,941,872,748,998,094,254,742,173,582,401,063,677,404,595,741,785,160,829,
230,135,358,081,840,096,996,372,524,230,560,855,903,700,624,271,243,416,909,004,
153,690,105,933,983,835,777,939,410,970,027,753,472,000,000,000,000,000,000,000,
000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,
000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,
000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,
000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000

2568 bytes

real 0m0.013s

user 0m0.004s

sys 0m0.000s

Also wie groß ist ein uint64_t? Ich denke, die größte Lüge, die passt in uint64_t ist Fib(93).
- Dieses tool ist integer präzise, keine float/double Annäherungen, und ich bezweifle das irgendwie zu beschränken, sondern dein ram.
- Es ist C++, aber mit ein paar Folgen von C Grundlagen. Ist es eine "standard-Bibliothek"? Ich denke auch so, aber stellen Sie sich die Frage.
- GMP-lib "GNU Multiprecision Library" -- erste Version 1991, 25 Jahre alt. Die Letzte stabile Version 6.1.0 (1. November 2015; 4 Monaten).
InformationsquelleAutor 2785528

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.