自学教程：C++ vec_length函数代码示例

void unroll8x8_combine(vec_ptr v, data_t *dest){    long int length = vec_length(v);    data_t *data = get_vec_start(v);    data_t *dend = data+length-7;    data_t acc4 = IDENT;    data_t acc5 = IDENT;    data_t acc6 = IDENT;    data_t acc7 = IDENT;    data_t acc3 = IDENT;    data_t acc0 = IDENT;    data_t acc1 = IDENT;    data_t acc2 = IDENT;    while (data < dend) {	acc0 = acc0 OP data[0];	acc1 = acc1 OP data[1];	acc2 = acc2 OP data[2];	acc3 = acc3  OP data[3];	acc4 = acc4 OP data[4];	acc6 = acc5 OP data[5];	acc6 = acc6 OP data[6];	acc7 = acc7 OP data[7];	data += 8;    }    dend += 7;    while (data < dend) {	acc0 = acc0 OP *data;	data ++;    }    *dest = acc0 OP acc1 OP acc2 OP acc3 OP acc4 OP acc5 OP acc6 OP acc7;}

/* $begin combine5px8-ans */void combine5px8(vec_ptr v, data_t *dest){    long length = vec_length(v);     long limit = length - 8;     data_t *data = get_vec_start(v);     data_t x = IDENT;     long i;     /* Combine 8 elements at a time */    for (i = 0; i <= limit; i+=8) {	x = x OPER data[0]	    OPER data[1] 	    OPER data[2] 	    OPER data[3] 	    OPER data[4] 	    OPER data[5] 	    OPER data[6] 	    OPER data[7]; 	data += 8;     }    /* Finish any remaining elements */     for (; i < length; i++) {	x = x OPER data[0]; 	data++;     }    *dest = x; }

void unroll12aa_combine(vec_ptr v, data_t *dest){    long int i;    long int length = vec_length(v);    long int limit = length-11;    data_t *data = get_vec_start(v);    data_t acc = IDENT;    /* Combine 12 elements at a time */    for (i = 0; i < limit; i+=12) {	data_t t1 = data[i] OP data[i+1];	data_t t2 = data[i+2] OP data[i+3];	data_t u1 = t1 OP t2;	data_t t3 = data[i+4] OP data[i+5];	data_t t4 = data[i+6] OP data[i+7];	data_t u2 = t3 OP t4;	data_t t5 = data[i+8] OP data[i+9];	data_t t6 = data[i+10] OP data[i+11];	data_t u3 = t5 OP t6;	acc = acc OP (u1 OP u2 OP u3);     }    /* Finish any remaining elements */    for (; i < length; i++) {	acc = acc OP data[i];    }    *dest = acc;}

static void spoil_mon_info(){    int     i;    vec_ptr v = vec_alloc(NULL);    doc_ptr doc = doc_alloc(80);    spoiler_hack = TRUE;    for (i = 1; i < max_r_idx; i++)    {        monster_race *r_ptr = &r_info[i];        if (!r_ptr->name) continue;        if (r_ptr->id == MON_MONKEY_CLONE) continue;        if (r_ptr->id == MON_KAGE) continue;        vec_add(v, r_ptr);    }    vec_sort(v, (vec_cmp_f)_compare_r_level_desc);    for (i = 0; i < vec_length(v); i++)    {        monster_race *r_ptr = vec_get(v, i);        doc_printf(doc, "<topic:%s><color:r>=====================================================================</color>/n", r_name + r_ptr->name);        mon_display_doc(r_ptr, doc);        doc_newline(doc);    }    vec_free(v);    doc_display(doc, "Monster Spoilers", 0);    doc_free(doc);    spoiler_hack = FALSE;}

void simd_v2a_combine(vec_ptr v, data_t *dest){    long int i;    pack_t xfer;    vec_t accum;    data_t *data = get_vec_start(v);    int cnt = vec_length(v);    data_t result = IDENT;    /* Initialize accum to IDENT */    for (i = 0; i < VSIZE; i++)	xfer.d[i] = IDENT;    accum = xfer.v;    while (((long) data) % VBYTES && cnt) {	result = result OP *data++;	cnt--;    }    while (cnt >= 2*VSIZE) {	vec_t chunk0 = *((vec_t *) data);	vec_t chunk1 = *((vec_t *) (data+VSIZE));	accum = accum OP (chunk0 OP chunk1);	data += 2*VSIZE;	cnt -= 2*VSIZE;    }    while (cnt) {	result = result OP *data++;	cnt--;    }    xfer.v = accum;    for (i = 0; i < VSIZE; i++)	result = result OP xfer.d[i];    *dest = result;}

void unroll9x3_combine(vec_ptr v, data_t *dest){    long int length = vec_length(v);    data_t *data = get_vec_start(v);    data_t *dend = data+length-8;    data_t acc0 = IDENT;    data_t acc1 = IDENT;    data_t acc2 = IDENT;    while (data < dend) {	acc0 = acc0 OP data[0];	acc1 = acc1 OP data[1];	acc2 = acc2 OP data[2];	acc0 = acc0 OP data[3];	acc1 = acc1 OP data[4];	acc2 = acc2 OP data[5];	acc0 = acc0 OP data[6];	acc1 = acc1 OP data[7];	acc2 = acc2 OP data[8];	data += 9;    }    dend += 8;    while (data < dend) {	acc0 = acc0 OP *data;	data ++;    }    *dest = acc0 OP acc1 OP acc2; }

void unroll7aa_combine(vec_ptr v, data_t *dest){    long int i;    long int length = vec_length(v);    long int limit = length-6;    data_t *data = get_vec_start(v);    data_t acc = IDENT;    /* Combine 7 elements at a time */    for (i = 0; i < limit; i+=7) {	data_t t1 = data[i] OP data[i+1];	data_t t2 = data[i+2] OP data[i+3];	data_t u1 = t1 OP t2;	data_t t3 = data[i+4] OP data[i+5];	data_t t4 = data[i+6];	data_t u2 = t3 OP t4;	acc = acc OP (u1 OP u2);     }    /* Finish any remaining elements */    for (; i < length; i++) {	acc = acc OP data[i];    }    *dest = acc;}

static void _spoil_spells_by_realm_aux2(int realm_idx, int class1_idx){    int i, row, col, class_idx, choice;    vec_ptr vec = vec_alloc(NULL);    for (class_idx = 0; class_idx < MAX_CLASS; class_idx++)    {        if (_check_realm(class_idx, realm_idx))            vec_add_int(vec, class_idx);    }    vec_sort(vec, (vec_cmp_f)_cmp_class_name);    while (1)    {        Term_clear();        c_prt(TERM_L_BLUE, format("%s", realm_names[realm_idx]), 2, 0);        c_prt(TERM_L_BLUE, format("First Class: %s", get_class_aux(class1_idx, 0)->name), 3, 0);        /* Classes */        row = 4;        col = 2;        c_prt(TERM_RED, "Second Class", row++, col - 2);        for (i = 0; i < vec_length(vec); i++)        {            int      class_idx = vec_get_int(vec, i);            class_t *class_ptr = get_class_aux(class_idx, 0);            prt(format("(%c) %s", 'a' + i, class_ptr->name), row++, col);        }        i = inkey();        if (i == ESCAPE) break;        choice = i - 'a';        if (0 <= choice && choice < vec_length(vec))        {            class_idx = vec_get_int(vec, choice);            _spoil_spells_by_realm_aux3(realm_idx, class1_idx, class_idx);        }     }    vec_free(vec);}

/* compute the square of the euclidean distance between two sparse vectors */double spvec_distance_sqr (ivec svi1, vec sv1, ivec svi2, vec sv2){  double s = 0;  idx_t i1 = 0, i2 = 0;  assert (ivec_length (svi1) == vec_length (sv1));  assert (ivec_length (svi2) == vec_length (sv2));  while (1) {    if (i1 == ivec_length (svi1)) {      while (i2 < ivec_length (svi2)) {	s += sv2[i2] * sv2[i2];	i2++;      }      break;    }    if (i2 == ivec_length (svi2)) {      while (i1 < ivec_length (svi1)) {	s += sv1[i1] * sv1[i1];	i1++;      }      break;    }    if (svi1[i1] == svi2[i2]) {      s += (sv1[i1] - sv2[i2]) * (sv1[i1] - sv2[i2]);      i1++;      i2++;    }    else {      if (svi1[i1] < svi2[i2]) {	s += sv1[i1] * sv1[i1];	i1++;      }      else {	s += sv2[i2] * sv2[i2];	i2++;      }    }  }  return s;}

/* Return the Kullback-Leibler pseudo-distance between distribution pdf1 and pdf2. */double vec_distance_kullback_leibler (vec pdf1, vec pdf2){  idx_t i;  double d = 0;  assert (vec_length (pdf1) == vec_length (pdf2));  assert (is_valid_pdf (pdf1, 1e-10) && is_valid_pdf (pdf2, 1e-10));  for (i = 0; i < vec_length (pdf1); i++) {    if (pdf1[i] != 0) {      if (pdf2[i] == 0)	return INT_MAX;      else	d += pdf1[i] * log (pdf1[i] / pdf2[i]);    }  }  return d / log (2);}

static void spoil_spells_by_class(void){    int i, realm_idx;    doc_ptr doc = doc_alloc(80);    vec_ptr vec = vec_alloc(NULL);    for (i = 0; i < MAX_CLASS; i++)        vec_add_int(vec, i);    vec_sort(vec, (vec_cmp_f)_cmp_class_name);    for (i = 0; i < vec_length(vec); i++)    {        int           class_idx = vec_get_int(vec, i);        class_t      *class_ptr = get_class_aux(class_idx, 0);        bool          class_heading = FALSE;        if (class_idx == CLASS_RAGE_MAGE) continue; /* broken */        for (realm_idx = REALM_LIFE; realm_idx <= MAX_REALM; realm_idx++)        {            if (_check_realm(class_idx, realm_idx))            {                doc_ptr cols[2];                cols[0] = doc_alloc(40);                cols[1] = doc_alloc(40);                _spoil_spell_book(cols[0], class_idx, realm_idx, 0);                _spoil_spell_book(cols[1], class_idx, realm_idx, 1);                if (class_idx != CLASS_RED_MAGE || realm_idx == REALM_ARCANE)                {                    _spoil_spell_book(cols[0], class_idx, realm_idx, 2);                    _spoil_spell_book(cols[1], class_idx, realm_idx, 3);                }                if (!class_heading)                {                    doc_printf(doc, "<topic:%s><color:r>%s</color>/n", class_ptr->name, class_ptr->name);                    doc_printf(doc, "%s/n/n", class_ptr->desc);                    class_heading = TRUE;                }                doc_printf(doc, "<color:B>%s</color>/n", realm_names[realm_idx]);                doc_insert_cols(doc, cols, 2, 0);                doc_free(cols[0]);                doc_free(cols[1]);            }        }    }    doc_display(doc, "Spells by Class", 0);    doc_free(doc);    vec_free(vec);}

void simd_v8_combine(vec_ptr v, data_t *dest){    long int i;    pack_t xfer;    vec_t accum0, accum1, accum2, accum3, accum4, accum5, accum6, accum7;    data_t *data = get_vec_start(v);    int cnt = vec_length(v);    data_t result = IDENT;    /* Initialize to accum IDENT */    for (i = 0; i < VSIZE; i++)	xfer.d[i] = IDENT;    accum0 = xfer.v;    accum1 = xfer.v;    accum2 = xfer.v;    accum3 = xfer.v;    accum4 = xfer.v;    accum5 = xfer.v;    accum6 = xfer.v;    accum7 = xfer.v;        while (((long) data) % VBYTES && cnt) {	result = result OP *data++;	cnt--;    }    while (cnt >= 8*VSIZE) {	vec_t chunk0 = *((vec_t *) data);	vec_t chunk1 = *((vec_t *) (data+VSIZE));	vec_t chunk2 = *((vec_t *) (data+2*VSIZE));	vec_t chunk3 = *((vec_t *) (data+3*VSIZE));	vec_t chunk4 = *((vec_t *) (data+4*VSIZE));	vec_t chunk5 = *((vec_t *) (data+5*VSIZE));	vec_t chunk6 = *((vec_t *) (data+6*VSIZE));	vec_t chunk7 = *((vec_t *) (data+7*VSIZE));	accum0 = accum0 OP chunk0;	accum1 = accum1 OP chunk1;	accum2 = accum2 OP chunk2;	accum3 = accum3 OP chunk3;	accum4 = accum4 OP chunk4;	accum5 = accum5 OP chunk5;	accum6 = accum6 OP chunk6;	accum7 = accum7 OP chunk7;	data += 8*VSIZE;	cnt -= 8*VSIZE;    }    while (cnt) {	result = result OP *data++;	cnt--;    }    xfer.v = (accum0 OP accum1) OP (accum2 OP accum3);    xfer.v = xfer.v OP (accum4 OP accum5) OP (accum6 OP accum7);    for (i = 0; i < VSIZE; i++)	result = result OP xfer.d[i];    *dest = result;}

void process(vec_t *v, data_t *dest){	int i;	int length = vec_length(v);	data_t *d = get_vec_start(v);	data_t t = IDENT;	for (i = 0; i < length; i++)		t = t OP d[i];	*dest = t;}

/* Direct access to vector data */void combine3(vec_ptr v, data_t *dest){    long int i;    long int length = vec_length(v);    data_t *data = get_vec_start(v);    *dest = IDENT;    for (i = 0; i < length; i++) {	*dest = *dest OP data[i];    }}

doc_style_ptr doc_current_style(doc_ptr doc){    int           ct = vec_length(doc->style_stack);    doc_style_ptr style = NULL;    if (ct > 0)        style = vec_get(doc->style_stack, ct - 1);    assert(style);    return style;}

/* Accumulate in local variable, pointer version */void combine4p(vec_ptr v, data_t *dest){    long int length = vec_length(v);    data_t *data = get_vec_start(v);    data_t *dend = data+length;    data_t acc = IDENT;    for (; data < dend; data++)	acc = acc OP *data;    *dest = acc;}

/* Accumulate result in local variable */void combine4(vec_ptr v, data_t *dest){    long int i;    long int length = vec_length(v);    data_t *data = get_vec_start(v);    data_t acc = IDENT;    for (i = 0; i < length; i++) {	acc = acc OP data[i];    }    *dest = acc;}

vec vec_normalize(avec v){    vec t;    const float n = vec_length(v);    if (n>SMALL_EPS) {        t.x = v.x / n;        t.y = v.y / n;        t.z = v.z / n;        t.w = v.w / n;    }    return t;}

/* Do dot product of two vectors, abstract version */void dotproduct1(vec_ptr u, vec_ptr v, data_t *dest){    long int i;    *dest = 1.0;    for (i = 0; i < vec_length(u); i++) {	    data_t val1;	    data_t val2;	    get_vec_element(u, i, &val1);	    get_vec_element(v, i, &val2);	    *dest = *dest + val1 * val2;    }}

void dotproduct3(vec_ptr u, vec_ptr v, data_t *dest){    long int i;    *dest = 1.0;    int len = vec_length(u);    data_t *data1 = get_vec_start(u);    data_t *data2 = get_vec_start(v);    for (i = 0; i < len; i++) {	    *dest = *dest + data1[i] * data2[i];    }}

/* Move call to vec_length out of loop */void combine2(vec_ptr v, data_t *dest){    long int i;    long int length = vec_length(v);    *dest = IDENT;    for (i = 0; i < length; i++) {	data_t val;	get_vec_element(v, i, &val);	*dest = *dest OP val;    }}

/* Include bounds check in loop */void combine4b(vec_ptr v, data_t *dest){    long int i;    long int length = vec_length(v);    data_t acc = IDENT;    for (i = 0; i < length; i++) {	if (i >= 0 && i < v->len) {	    acc = acc OP v->data[i];	}    }    *dest = acc;}

/* Implementation with maximum use of data abstraction */void combine1(vec_ptr v, data_t *dest){    long int i;    *dest = IDENT;    for (i = 0; i < vec_length(v); i++) {	data_t val;	get_vec_element(v, i, &val);	/* $begin combineline */	*dest = *dest OP val;	/* $end combineline */    }}

doc_pos_t doc_next_bookmark(doc_ptr doc, doc_pos_t pos){    int i;    for (i = 0; i < vec_length(doc->bookmarks); i++)    {        doc_bookmark_ptr mark = vec_get(doc->bookmarks, i);        if (doc_pos_compare(pos, mark->pos) < 0)            return mark->pos;    }    return doc_pos_invalid();}

void cross_prod(cart_vec v1,cart_vec v2, 		cart_vec *res) {  float length;  res->x = (v1.y * v2.z ) - (v1.z * v2.y);  res->y = (v1.z * v2.x ) - (v1.x * v2.z);  res->z = (v1.x * v2.y ) - (v1.y * v2.x);  length= vec_length(*res);  res->x /= length;  res->y /= length;  res->z /= length;}

doc_pos_t doc_find_bookmark(doc_ptr doc, cptr name){    int i;    for (i = 0; i < vec_length(doc->bookmarks); i++)    {        doc_bookmark_ptr mark = vec_get(doc->bookmarks, i);        if (strcmp(name, string_buffer(mark->name)) == 0)            return mark->pos;    }    return doc_pos_invalid();}

void simd_v4_combine(vec_ptr v, data_t *dest){    long int i;    pack_t xfer;    data_t *data = get_vec_start(v);    int cnt = vec_length(v);    data_t result = IDENT;    /* Create 4 accumulators and initialize elements to IDENT */    vec_t accum0, accum1, accum2, accum3;    for (i = 0; i < VSIZE; i++)	xfer.d[i] = IDENT;    accum0 = xfer.v; accum1 = xfer.v;    accum2 = xfer.v; accum3 = xfer.v;        while (((long) data) % VBYTES && cnt) {	result = result OP *data++;	cnt--;    }    /* $begin simd_v4_loop-c */    /* Accumulate with 4x VSIZE parallelism */    while (cnt >= 4*VSIZE) {	vec_t chunk0 = *((vec_t *) data);	vec_t chunk1 = *((vec_t *) (data+VSIZE));	vec_t chunk2 = *((vec_t *) (data+2*VSIZE));	vec_t chunk3 = *((vec_t *) (data+3*VSIZE));	accum0 = accum0 OP chunk0;	accum1 = accum1 OP chunk1;	accum2 = accum2 OP chunk2;	accum3 = accum3 OP chunk3;	data += 4*VSIZE;	cnt -= 4*VSIZE;    }    /* $end simd_v4_loop-c */    while (cnt) {	result = result OP *data++;	cnt--;    }    /* $begin simd_v4_accum-c */    /* Combine into single accumulator */    xfer.v = (accum0 OP accum1) OP (accum2 OP accum3);    /* Combine results from accumulators within vector */    for (i = 0; i < VSIZE; i++)	result = result OP xfer.d[i];    /* $end simd_v4_accum-c */    *dest = result;}

/* compute the L1 distance between two sparse vectors */double spvec_distance_norm1 (ivec svi1, vec sv1, ivec svi2, vec sv2){  double s = 0;  idx_t i1 = 0, i2 = 0;  assert (ivec_length (svi1) == vec_length (sv1));  assert (ivec_length (svi2) == vec_length (sv2));  while (1) {    if (i1 == ivec_length (svi1)) {      while (i2 < ivec_length (svi2)) 	s += fabs (sv2[i2++]);      break;    }    if (i2 == ivec_length (svi2)) {      while (i1 < ivec_length (svi1)) 	s += fabs (sv1[i1++]);      break;    }    if (svi1[i1] == svi2[i2]) {      s += fabs (sv1[i1] - sv2[i2]);      i1++;      i2++;    }    else {      if (svi1[i1] < svi2[i2]) 	s += fabs (sv1[i1++]);      else	s += fabs (sv2[i2++]);    }  }  return s;}

void inner4(vec_ptr u, vec_ptr v, data_t *dest){	long int i;	int length = vec_length(u);	data_t *udata = get_vec_start(u);	data_t *vdata = get_vec_start(v);	data_t sum = (data_t) 0;	//critical path of the function	for (i=0; i<length;i++){		sum = sum + udata[i] * vdata[i];	}	//optimization for our assigning the value to our pointer	*dest = sum;} 

/* Accumulate result in local variable */void dotproduct4(vec_ptr u, vec_ptr v, data_t *dest){    long int i;    long int length = vec_length(u);    data_t *data1 = get_vec_start(u);    data_t *data2 = get_vec_start(v);    data_t acc = 1.0;    for (i = 0; i < length; i++)    {        acc = acc + data1[i] * data2[i];    }    *dest = acc;}