Perché "int pow (int base, int esponente)" non è nelle librerie C ++ standard?

Mi sento come se non dovessi riuscire a trovarlo. C'è qualche ragione che il C ++ powfunzione non implementa la funzione di "potere" per qualsiasi cosa, tranne floats e doubles?

So che l'implementazione è banale, mi sento come se stessi facendo un lavoro che dovrebbe essere in una libreria standard. Una robusta funzione di alimentazione (cioè gestisce l'overflow in modo coerente ed esplicito) non è divertente da scrivere.

A partire da C++11, casi speciali sono stati aggiunti alla suite di funzioni di alimentazione (e altre). C++11 [c.math] /11afferma, dopo aver elencato tutti i float/double/long doublesovraccarichi (la mia enfasi e parafrasata):

Inoltre, devono esserci sovraccarichi aggiuntivi sufficienti per garantire che, se qualsiasi argomento corrispondente a un doubleparametro ha un tipo doubleo un tipo intero, tutti gli argomenti corrispondenti ai doubleparametri siano effettivamente sottoposti a cast double.

Quindi, in pratica, i parametri interi verranno aggiornati al doppio per eseguire l'operazione.

Prima di C++11(che era quando è stata posta la tua domanda), non esistevano sovraccarichi di numeri interi.

Poiché non ero né strettamente associato ai creatori Cné C++ai tempi della loro creazione (anche se sono piuttosto vecchio), né facevo parte dei comitati ANSI / ISO che hanno creato gli standard, questa è necessariamente un'opinione da parte mia. Mi piacerebbe pensare che sia un'opinione informata ma, come ti dirà mia moglie (spesso e senza molto incoraggiamento necessario), mi sono sbagliato prima :-)

Supponiamo, per quello che vale, segue.

Ho il sospetto che il motivo per l'originale pre-ANSI Cnon ha avuto questa caratteristica è perché è stato tutto inutile. In primo luogo, c'era già un modo perfettamente buono per eseguire potenze intere (con doppie e poi semplicemente riconvertirle in un intero, controllando l'overflow e l'underflow degli interi prima della conversione).

In secondo luogo, un'altra cosa che devi ricordare è che l'intento originale Cera quello di un linguaggio di programmazione di sistema , ed è discutibile se il punto mobile sia desiderabile in quell'arena.

Poiché uno dei suoi casi d'uso iniziali era quello di codificare UNIX, il virgola mobile sarebbe stato quasi inutile. Anche BCPL, su cui si basava C, non aveva alcuna utilità per i poteri (non aveva affatto virgola mobile, dalla memoria).

Per inciso, un operatore di alimentazione integrale sarebbe probabilmente stato un operatore binario piuttosto che una chiamata di libreria. Non si aggiungono due numeri interi con x = add (y, z)ma con x = y + z- parte del linguaggio appropriato piuttosto che della libreria.

Terzo, poiché l'implementazione del potere integrale è relativamente banale, è quasi certo che gli sviluppatori del linguaggio userebbero meglio il loro tempo fornendo cose più utili (vedi sotto i commenti sul costo opportunità).

Ciò è rilevante anche per l'originale C++. Poiché l'implementazione originale era in effetti solo un traduttore che produceva Ccodice, trasportava molti degli attributi di C. Il suo intento originale era C-con-classi, non C-con-classi-più-un-po '-di-extra-matematica.

Per quanto riguarda il motivo per cui non è mai stato aggiunto agli standard prima C++11, è necessario ricordare che gli organismi di definizione degli standard hanno linee guida specifiche da seguire. Ad esempio, ANSI è Cstato specificamente incaricato di codificare la pratica esistente, non di creare un nuovo linguaggio. Altrimenti avrebbero potuto impazzire e darci Ada :-)

Anche le iterazioni successive di tale standard hanno linee guida specifiche e possono essere trovate nei documenti razionali (motivazione del motivo per cui il comitato ha preso determinate decisioni, non motivazione della lingua stessa).

Ad esempio, il C99documento razionale porta avanti specificamente due dei C89principi guida che limitano ciò che può essere aggiunto:

• Mantieni la lingua piccola e semplice.
  
• Fornisci solo un modo per eseguire un'operazione.

Le linee guida (non necessariamente quelle specifiche ) sono stabilite per i singoli gruppi di lavoro e quindi limitano anche i C++comitati (e tutti gli altri gruppi ISO).

Inoltre, gli organismi di definizione degli standard si rendono conto che esiste un costo opportunità (un termine economico che significa ciò a cui devi rinunciare per una decisione presa) per ogni decisione che prendono. Ad esempio, il costo opportunità di acquistare quella macchina da super-gioco da $ 10.000 è costituito da relazioni cordiali (o probabilmente tutte le relazioni) con l'altra metà per circa sei mesi.

Eric Gunnerson lo spiega bene con la sua spiegazione -100 punti sul perché le cose non vengono sempre aggiunte ai prodotti Microsoft - fondamentalmente una funzionalità inizia da 100 punti nel buco quindi deve aggiungere un bel po 'di valore per essere considerata.

In altre parole, preferiresti avere un operatore di alimentazione integrato (che, onestamente, qualsiasi codificatore decente potrebbe montare in dieci minuti) o il multi-threading aggiunto allo standard? Per quanto mi riguarda, preferirei avere quest'ultimo e non dover perdere tempo con le diverse implementazioni in UNIX e Windows.

Vorrei anche vedere migliaia e migliaia di raccolte della libreria standard (hash, btrees, alberi rosso-neri, dizionario, mappe arbitrarie e così via) ma, come afferma la logica:

Uno standard è un trattato tra implementatore e programmatore.

E il numero di implementatori negli organismi di standardizzazione supera di gran lunga il numero di programmatori (o almeno di quei programmatori che non comprendono il costo opportunità). Se tutte queste cose fossero state aggiunte, il prossimo standard C++sarebbe C++215xe sarebbe probabilmente completamente implementato dagli sviluppatori di compilatori trecento anni dopo.

Comunque, questo è il mio pensiero (piuttosto voluminoso) sull'argomento. Se solo i voti venissero distribuiti in base alla quantità piuttosto che alla qualità, presto farei saltare tutti gli altri dall'acqua. Grazie per aver ascoltato :-)

Per qualsiasi tipo integrale a larghezza fissa, quasi tutte le possibili coppie di input superano comunque il tipo. A che serve standardizzare una funzione che non fornisce un risultato utile per la maggior parte dei suoi possibili input?

È praticamente necessario disporre di un tipo intero grande per rendere la funzione utile, e la maggior parte delle librerie di interi grandi fornisce la funzione.

Modifica: in un commento alla domanda, static_rtti scrive "La maggior parte degli input causa un overflow? Lo stesso vale per exp e double pow, non vedo nessuno che si lamenta." Questo non è corretto.

Lasciamo da parte exp, perché non è questo il punto (anche se in realtà rafforzerebbe il mio caso) e concentriamoci su double pow(double x, double y). Per quale porzione di coppie (x, y) questa funzione fa qualcosa di utile (cioè, non semplicemente overflow o underflow)?

In realtà mi concentrerò solo su una piccola porzione delle coppie di input per cui powha senso, perché sarà sufficiente per dimostrare il mio punto: se x è positivo e | y | <= 1, quindi pownon overflow o underflow. Questo comprende quasi un quarto di tutte le coppie in virgola mobile (esattamente la metà dei numeri in virgola mobile non NaN sono positivi e solo meno della metà dei numeri in virgola mobile non NaN hanno una grandezza inferiore a 1). Ovviamente, ci sono molte altre coppie di input per le quali powproduce risultati utili, ma abbiamo accertato che è almeno un quarto di tutti gli input.

Ora diamo un'occhiata a una funzione di potenza intera a larghezza fissa (cioè non bignum). Per quale porzione di input non trabocca semplicemente? Per massimizzare il numero di coppie di input significative, la base dovrebbe essere con segno e l'esponente senza segno. Supponiamo che la base e l'esponente siano entrambi nlarghi bit. Possiamo facilmente ottenere un limite sulla porzione di input che sono significativi:

• Se l'esponente 0 o 1, qualsiasi base è significativa.
• Se l'esponente è 2 o maggiore, nessuna base maggiore di 2 ^ (n / 2) produce un risultato significativo.

Pertanto, delle 2 ^ (2n) coppie di input, meno di 2 ^ (n + 1) + 2 ^ (3n / 2) producono risultati significativi. Se guardiamo a quello che è probabilmente l'uso più comune, gli interi a 32 bit, ciò significa che qualcosa nell'ordine di 1/1000 dell'uno percento delle coppie di input non va semplicemente in overflow.

Perché non c'è comunque modo di rappresentare tutte le potenze intere in un int:

>>> print 2**-4
0.0625

In realtà è una domanda interessante. Un argomento che non ho trovato nella discussione è la semplice mancanza di ovvi valori di ritorno per gli argomenti. Contiamo i modi in cui la int pow_int(int, int)funzione ipotetica potrebbe fallire.

1. straripamento
2. Risultato indefinito pow_int(0,0)
3. Il risultato non può essere rappresentato pow_int(2,-1)

La funzione ha almeno 2 modalità di guasto. I numeri interi non possono rappresentare questi valori, il comportamento della funzione in questi casi dovrebbe essere definito dallo standard e i programmatori dovrebbero essere consapevoli di come esattamente la funzione gestisce questi casi.

Nel complesso, lasciare la funzione fuori sembra l'unica opzione sensata. Il programmatore può utilizzare la versione in virgola mobile con tutte le segnalazioni di errori disponibili invece.

Risposta breve:

Una specializzazione di pow(x, n)dove nè un numero naturale è spesso utile per le prestazioni temporali . Ma il generico della libreria standard pow()funziona ancora abbastanza ( sorprendentemente! ) Bene per questo scopo ed è assolutamente fondamentale includerne il meno possibile nella libreria C standard in modo che possa essere reso il più portatile e il più facile da implementare possibile. D'altra parte, ciò non impedisce affatto che sia nella libreria standard C ++ o STL, che sono abbastanza sicuro che nessuno ha intenzione di utilizzare in una sorta di piattaforma incorporata.

Ora, per la risposta lunga.

pow(x, n)può essere reso molto più veloce in molti casi specializzandosi nsu un numero naturale. Ho dovuto utilizzare la mia implementazione di questa funzione per quasi tutti i programmi che scrivo (ma scrivo molti programmi matematici in C). L'operazione specializzata può essere eseguita in O(log(n))tempo, ma quando nè piccola, una versione lineare più semplice può essere più veloce. Ecco le implementazioni di entrambi:

    // Computes x^n, where n is a natural number.
    double pown(double x, unsigned n)
    {
        double y = 1;
        // n = 2*d + r. x^n = (x^2)^d * x^r.
        unsigned d = n >> 1;
        unsigned r = n & 1;
        double x_2_d = d == 0? 1 : pown(x*x, d);
        double x_r = r == 0? 1 : x;
        return x_2_d*x_r;
    }
    // The linear implementation.
    double pown_l(double x, unsigned n)
    {
        double y = 1;
        for (unsigned i = 0; i < n; i++)
            y *= x;
        return y;
    }

(Ho lasciato xe il valore restituito raddoppia perché il risultato di pow(double x, unsigned n)si adatterà a un doppio più o meno tutte le volte che pow(double, double)vorrà.)

(Sì, pownè ricorsivo, ma rompere lo stack è assolutamente impossibile poiché la dimensione massima dello stack sarà approssimativamente uguale log_2(n)ed nè un numero intero. Se nè un numero intero a 64 bit, si ottiene una dimensione massima dello stack di circa 64. Nessun hardware ha una dimensione così estrema limitazioni di memoria, ad eccezione di alcuni PIC ingannevoli con stack hardware che vanno solo da 3 a 8 chiamate di funzione in profondità.)

Per quanto riguarda le prestazioni, rimarrai sorpreso da ciò di cui pow(double, double)è capace una varietà da giardino . Ho testato un centinaio di milioni di iterazioni sul mio Thinkpad IBM di 5 anni con xuguale al numero di iterazioni e nuguale a 10. In questo scenario, ha pown_lvinto. glibc ha pow()impiegato 12,0 secondi utente, pown7,4 secondi utente e pown_lsolo 6,5 secondi utente. Quindi non è troppo sorprendente. Più o meno ce lo aspettavamo.

Quindi, ho lasciato xessere costante (l'ho impostato a 2,5) e ho ripetuto nda 0 a 19 cento milioni di volte. Questa volta, del tutto inaspettatamente, glibc ha powvinto, e con una frana! Ci sono voluti solo 2,0 secondi utente. Il mio ha pownimpiegato 9,6 secondi e pown_l12,2 secondi. Cos'è successo qua? Ho fatto un altro test per scoprirlo.

Ho fatto la stessa cosa di sopra solo con xpari a un milione. Questa volta, ha pownvinto a 9.6 secondi. pown_lha preso 12.2s e glibc pow ha preso 16.3s. Ora è chiaro! glibc powfunziona meglio dei tre quando xè basso, ma peggio quando xè alto. Quando xè alto, pown_lfunziona al meglio quando nè basso e pownfunziona meglio quando xè alto.

Quindi ecco tre diversi algoritmi, ciascuno in grado di funzionare meglio degli altri nelle giuste circostanze. Quindi, in definitiva, quale utilizzare molto probabilmente dipende da come si sta pensando di usare pow, ma usando la versione corretta è valsa la pena, e aventi tutte le versioni è bello. In effetti, potresti persino automatizzare la scelta dell'algoritmo con una funzione come questa:

double pown_auto(double x, unsigned n, double x_expected, unsigned n_expected) {
    if (x_expected < x_threshold)
        return pow(x, n);
    if (n_expected < n_threshold)
        return pown_l(x, n);
    return pown(x, n);
}

Fintanto che x_expectede n_expectedsono costanti decise in fase di compilazione, insieme a eventuali altri avvertimenti, un compilatore di ottimizzazione degno di questo nome rimuoverà automaticamente l'intera pown_autochiamata di funzione e la sostituirà con la scelta appropriata dei tre algoritmi. (Ora, se hai davvero intenzione di tentare di usarlo , probabilmente dovrai giocarci un po ', perché non ho esattamente provato a compilare ciò che avevo scritto sopra.;))

D'altra parte, glibc pow funziona e glibc è già abbastanza grande. Lo standard C dovrebbe essere portabile, anche su vari dispositivi embedded (infatti gli sviluppatori embedded ovunque generalmente concordano sul fatto che glibc è già troppo grande per loro), e non può essere portabile se per ogni semplice funzione matematica deve includere ogni algoritmo alternativo che potrebbe essere utile. Quindi, ecco perché non è nello standard C.

nota a piè di pagina: Durante il test delle prestazioni temporali, ho fornito alle mie funzioni flag di ottimizzazione relativamente generosi ( -s -O2) che potrebbero essere paragonabili, se non peggiori, a ciò che è stato probabilmente usato per compilare glibc sul mio sistema (archlinux), quindi i risultati sono probabilmente giusto. Per un test più rigoroso, dovrei compilare glibc da solo e davvero non ho voglia di farlo. Usavo Gentoo, quindi ricordo quanto tempo ci vuole, anche quando l'attività è automatizzata . I risultati sono abbastanza conclusivi (o piuttosto inconcludenti) per me. Ovviamente sei il benvenuto a farlo da solo.

Bonus round: una specializzazione di pow(x, n)tutti i numeri interi è fondamentale se è richiesto un output intero esatto, cosa che accade. Considera l'allocazione della memoria per un array N-dimensionale con p ^ N elementi. Ottenere p ^ N fuori anche solo da uno risulterà in un possibile segfault che si verifica in modo casuale.

Uno dei motivi per cui C ++ non ha sovraccarichi aggiuntivi è essere compatibile con C.

C ++ 98 ha funzioni simili double pow(double, int), ma queste sono state rimosse in C ++ 11 con l'argomento che C99 non le includeva.

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3286.html#550

Ottenere un risultato leggermente più accurato significa anche ottenere un risultato leggermente diverso .

Il mondo è in continua evoluzione e così sono i linguaggi di programmazione. La quarta parte del decimale C TR ¹ aggiunge altre funzioni a <math.h>. Due famiglie di queste funzioni possono essere di interesse per questa domanda:

• Le pownfunzioni, che prendono un numero in virgola mobile e un intmax_tesponente.
• Le powrfunzioni, che prendono due numeri in virgola mobile ( xe y) e calcolano xalla potenza ycon la formula exp(y*log(x)).

Sembra che i ragazzi standard alla fine abbiano ritenuto queste funzionalità abbastanza utili da essere integrate nella libreria standard. Tuttavia, la logica è che queste funzioni sono consigliate dallo standard ISO / IEC / IEEE 60559: 2011 per i numeri binari e decimali in virgola mobile. Non posso dire con certezza quale "standard" sia stato seguito al tempo di C89, ma le future evoluzioni di <math.h>saranno probabilmente fortemente influenzate dalle future evoluzioni dello standard ISO / IEC / IEEE 60559 .

Si noti che la quarta parte del TR decimale non sarà inclusa in C2x (la prossima revisione C principale) e sarà probabilmente inclusa in seguito come funzionalità opzionale. Non ho avuto intenzione di includere questa parte del TR in una futura revisione C ++.

¹ È possibile trovare una documentazione in fase di elaborazione qui .

Forse perché l'ALU del processore non ha implementato una tale funzione per gli interi, ma esiste un'istruzione FPU di questo tipo (come sottolinea Stephen, in realtà è una coppia). Quindi è stato effettivamente più veloce eseguire il cast per raddoppiare, chiamare pow con il doppio, quindi testare l'overflow e il cast indietro, piuttosto che implementarlo usando l'aritmetica dei numeri interi.

(per prima cosa, i logaritmi riducono i poteri alla moltiplicazione, ma i logaritmi degli interi perdono molta precisione per la maggior parte degli input)

Stephen ha ragione che sui processori moderni questo non è più vero, ma lo standard C quando sono state selezionate le funzioni matematiche (C ++ ha usato solo le funzioni C) ora ha 20 anni?

Ecco un'implementazione O (log (n)) di pow () davvero semplice che funziona per qualsiasi tipo numerico, inclusi gli interi :

template<typename T>
static constexpr inline T pown(T x, unsigned p) {
    T result = 1;

    while (p) {
        if (p & 0x1) {
            result *= x;
        }
        x *= x;
        p >>= 1;
    }

    return result;
}

È meglio dell'implementazione O (log (n)) di enigmaticPhysicist perché non usa la ricorsione.

È anche quasi sempre più veloce della sua implementazione lineare (purché p> ~ 3) perché:

• non richiede memoria aggiuntiva
• fa solo ~ 1,5 volte più operazioni per ciclo
• fa solo ~ 1,25 volte più aggiornamenti di memoria per ciclo

È un dato di fatto, lo fa.

Poiché C ++ 11 esiste un'implementazione basata su modelli di pow(int, int)--- e casi ancora più generali, vedere (7) in http://en.cppreference.com/w/cpp/numeric/math/pow

EDIT: i puristi potrebbero obiettare che questo non è corretto, poiché in realtà viene utilizzata la digitazione "promossa". In un modo o nell'altro, si ottiene un intrisultato corretto o un errore sui intparametri.

Un motivo molto semplice:

5^-2 = 1/25

Tutto nella libreria STL si basa sulle cose più accurate e robuste che si possano immaginare. Certo, l'int tornerebbe a zero (da 1/25) ma questa sarebbe una risposta imprecisa.

Sono d'accordo, è strano in alcuni casi.