Complessità degli operatori di confronto

Question

Perché la funzione y[i] < x[i] impiega il doppio del tempo quando l'array x ha sempre un valore superiore a y (per ex 1<x<2 e). Inoltre, quando si confrontano 0.5<x<1.5 e 0<y<1, il tempo di esecuzione è di circa 1,5 volte il caso in cui 0<x<1 e 0<y<1. Ciò presuppone che sia x che y siano array lunghi.

Aggiungo il codice per provare e ottenere ciò che intendo. è possibile compensare la matrice x aumentando e diminuendo la variabile "offset (provare offset = 1 e offset = 0); Il codice memorizzerà il tempo di esecuzione per i loop nel file Beta

codice

è:

.

#include <iostream> 
#include <array> 
#include <time.h> 
#include <math.h> 
using namespace std; 
#define MAX(x,y) ((x) > (y) ? (x) : (y)) 

int main() 
{ 
ofstream myfile_Beta; 
myfile_Beta.open ("Beta.txt"); 
clock_t begin_time = clock(); 
clock_t total_time; 
srand (time(NULL)); 

double offset =0.0; 

int m=0; 
for(int k=0;k<10000;k++) 
    { 
    m=1; 
    double M[75720],x[75720],y[75720]; 

    for (int i=0;i<75720;i++) 
    { 

     x[i]=+(rand()%1024)/1024.0* 1.0 + offset ; 
     y[i]=+(rand()%1024)/1024.0* 1.0 + 0.00; 
    } 
    begin_time = clock(); 
    for (int j=0;j<75720;j++) 
    { 
     M[j]=MAX(x[j],y[j]); 
    } 
    total_time =clock() - begin_time; 
    myfile_Beta <<float(total_time )<<" "<<endl; 
} 
myfile_Beta.close(); 
} 

Answer 1

una spiegazione è che ci sono meno salti se la prima condizione si applica,

la seconda spiegazione riguarda ramo predicazione, in fondo, dove potrebbe 'indovinare' la '<' risultato e applicare il codice successivo a prescindere il risultato, e muck su fallimento, quindi quando si verifica la stessa condizione relativamente relativamente, il compilatore può indovinarlo correttamente più spesso. Si può leggere di più su di esso qui: http://en.wikipedia.org/wiki/Branch_predication