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

void matrix_set_many_on_column(matrix_type * matrix , int row_offset , int elements , const double * data , int column) {  if ((row_offset + elements) <= matrix->rows) {    if (matrix->row_stride == 1)  /* Memory is continous ... */      memcpy( &matrix->data[ GET_INDEX( matrix , row_offset , column) ] , data , elements * sizeof * data);    else {      int i;      for (i = 0; i < elements; i++)        matrix->data[ row_offset + GET_INDEX( matrix , i , column) ] = data[i];    }  } else    util_abort("%s: range violation /n" , __func__);}

double matrix_det2( const matrix_type * A) {  if ((A->rows == 2) && (A->columns == 2)) {    double a00 = A->data[GET_INDEX(A,0,0)];    double a01 = A->data[GET_INDEX(A,0,1)];    double a10 = A->data[GET_INDEX(A,1,0)];    double a11 = A->data[GET_INDEX(A,1,1)];    return a00 * a11 - a10 * a01;  } else {    util_abort("%s: hardcoded for 2x2 matrices A is: %d x %d /n",__func__, A->rows , A->columns);    return 0;  }}

double matrix_row_column_dot_product(const matrix_type * m1 , int row1 , const matrix_type * m2 , int col2) {  if (m1->columns != m2->rows)    util_abort("%s: size mismatch: m1:[%d,%d]   m2:[%d,%d] /n",__func__ , matrix_get_rows( m1 ) , matrix_get_columns( m1 ) , matrix_get_rows( m2 ) , matrix_get_columns( m2 ));  {    int k;    double sum = 0;    for( k = 0; k < m1->columns; k++)      sum += m1->data[ GET_INDEX(m1 , row1 , k) ] * m2->data[ GET_INDEX(m2, k , col2) ];    return sum;  }}

bool matrix_columns_equal( const matrix_type * m1 , int col1 , const matrix_type * m2 , int col2) {  if (m1->rows != m2->rows)    return false;  {    int row;    for (row=0; row < m1->rows; row++) {      if (memcmp( &m1->data[ GET_INDEX(m1 , row , col1)]  , &m2->data[ GET_INDEX(m2 , row , col2)] , sizeof * m1->data) != 0)        return false;    }  }  return true;}

void matrix_transpose(const matrix_type * A , matrix_type * T) {  if ((A->columns == T->rows) && (A->rows == T->columns)) {    int i,j;    for (i=0; i < A->rows; i++) {      for (j=0; j < A->columns; j++) {        size_t src_index    = GET_INDEX(A , i , j );        size_t target_index = GET_INDEX(T , j , i );        T->data[ target_index ] = A->data[ src_index ];      }    }  } else    util_abort("%s: size mismatch/n",__func__);}

int reset_pnodes(int curr, int pnode){	struct msm_bus_inode_info *info;	struct msm_bus_fabric_device *fabdev;	int index, next_pnode;	fabdev = msm_bus_get_fabric_device(GET_FABID(curr));	index = GET_INDEX(pnode);	info = fabdev->algo->find_node(fabdev, curr);	if (!info) {		MSM_BUS_ERR("Cannot find node info!/n");		return -ENXIO;	}	MSM_BUS_DBG("Starting the loop--remove/n");	do {		struct msm_bus_inode_info *hop;		fabdev = msm_bus_get_fabric_device(GET_FABID(curr));		if (!fabdev) {			MSM_BUS_ERR("Fabric not found/n");				return -ENXIO;		}		next_pnode = info->pnode[index].next;		info->pnode[index].next = -2;		curr = GET_NODE(next_pnode);		index = GET_INDEX(next_pnode);		if (IS_NODE(curr))			hop = fabdev->algo->find_node(fabdev, curr);		else			hop = fabdev->algo->find_gw_node(fabdev, curr);		if (!hop) {			MSM_BUS_ERR("Null Info found for hop/n");			return -ENXIO;		}		MSM_BUS_DBG("%d[%d] = %d/n", info->node_info->priv_id, index,			info->pnode[index].next);		MSM_BUS_DBG("num_pnodes: %d: %d/n", info->node_info->priv_id,			info->num_pnodes);		info = hop;	} while (GET_NODE(info->pnode[index].next) != info->node_info->priv_id);	info->pnode[index].next = -2;	MSM_BUS_DBG("%d[%d] = %d/n", info->node_info->priv_id, index,		info->pnode[index].next);	MSM_BUS_DBG("num_pnodes: %d: %d/n", info->node_info->priv_id,		info->num_pnodes);	return 0;}

// Commentvoid matrix_inplace_diag_sqrt(matrix_type *Cd){  int nrows = Cd->rows;  if (Cd->rows != Cd->columns) {    util_abort("%s: size mismatch /n",__func__);  }  else{    int i;    for ( i=0; i<nrows; i++)      {        Cd->data[GET_INDEX(Cd , i , i)] = sqrt(Cd->data[GET_INDEX(Cd , i , i)]);      }  }}

double matrix_column_column_dot_product(const matrix_type * m1 , int col1 , const matrix_type * m2 , int col2) {  if (m1->rows != m2->rows)    util_abort("%s: size mismatch /n",__func__);  if (col1 >= m1->columns || col2 >= m2->columns)    util_abort("%s: size mismatch /n",__func__);  {    int row;    double sum = 0;    for( row = 0; row < m1->rows; row++)      sum += m1->data[ GET_INDEX(m1 , row , col1) ] * m2->data[ GET_INDEX(m2, row , col2) ];    return sum;  }}

/* Updates matrix A by subtracting matrix B - elementwise. */void matrix_inplace_sub(matrix_type * A , const matrix_type * B) {  if ((A->rows == B->rows) && (A->columns == B->columns)) {    int i,j;    for (j = 0; j < A->columns; j++)      for (i=0; i < A->rows; i++)        A->data[ GET_INDEX(A,i,j) ] -= B->data[ GET_INDEX(B,i,j) ];  } else    util_abort("%s: size mismatch  A:[%d,%d]   B:[%d,%d]/n",__func__ ,               matrix_get_rows(A),               matrix_get_columns(A),               matrix_get_rows(B),               matrix_get_columns(B));}

/***************************************** * Read nappe characterization in a file * *****************************************/GEO *file_geo_nappe (BYTE Type, FILE *File){  GEO_NAPPE  *Geo;  PNT        *Pnt, *PntA, *PntB, *PntC, *PntD;  FCT        *Fct;  VECTOR     U, V;  REAL       Real;  INDEX      Index;  INIT_MEM (Geo, 1, GEO_NAPPE);  Geo->Type = Type;  GET_INDEX (Geo->NbrPnt);  INIT_MEM (Geo->TabPnt, Geo->NbrPnt, PNT);  GET_INDEX (Geo->NbrFct);  INIT_MEM (Geo->TabFct, Geo->NbrFct, FCT);  Geo->Min.x = Geo->Min.y = Geo->Min.z =  INFINITY;  Geo->Max.x = Geo->Max.y = Geo->Max.z = -INFINITY;  for (Index = 0, Pnt = Geo->TabPnt; Index < Geo->NbrPnt; Index++, Pnt++) {    GET_VECTOR (Pnt->Point);    VEC_MIN (Geo->Min, Pnt->Point);    VEC_MAX (Geo->Max, Pnt->Point);  }  for (Index = 0, Fct = Geo->TabFct; Index < Geo->NbrFct; Index++, Fct++) {    if (fscanf (File, " ( %d %d %d %d )", &Fct->i, &Fct->j, &Fct->k, &Fct->l) < 4)      return (FALSE);    Fct->NumFct = Index;    PntA = Geo->TabPnt + Fct->i;     PntB = Geo->TabPnt + Fct->j;    PntC = Geo->TabPnt + Fct->k;    PntD = Geo->TabPnt + Fct->l;    VEC_SUB (U, PntC->Point, PntA->Point);    VEC_SUB (V, PntD->Point, PntB->Point);    VEC_CROSS (Fct->Normal, U, V);    VEC_UNIT (Fct->Normal, Real);    VEC_INC (PntA->Normal, Fct->Normal);    VEC_INC (PntB->Normal, Fct->Normal);    VEC_INC (PntC->Normal, Fct->Normal);    VEC_INC (PntD->Normal, Fct->Normal);  }  for (Index = 0, Pnt = Geo->TabPnt; Index < Geo->NbrPnt; Index++, Pnt++)    VEC_UNIT (Pnt->Normal, Real);  return ((GEO *) Geo);}

U_CAPI UBiDiDirection U_EXPORT2ubidi_getVisualRun(UBiDi *pBiDi, int32_t runIndex,                   int32_t *pLogicalStart, int32_t *pLength){    int32_t start;    UErrorCode errorCode = U_ZERO_ERROR;    RETURN_IF_NOT_VALID_PARA_OR_LINE(pBiDi, errorCode, UBIDI_LTR);    ubidi_getRuns(pBiDi, &errorCode);    if(U_FAILURE(errorCode)) {        return UBIDI_LTR;    }    RETURN_IF_BAD_RANGE(runIndex, 0, pBiDi->runCount, errorCode, UBIDI_LTR);    start=pBiDi->runs[runIndex].logicalStart;    if(pLogicalStart!=NULL) {        *pLogicalStart=GET_INDEX(start);    }    if(pLength!=NULL) {        if(runIndex>0) {            *pLength=pBiDi->runs[runIndex].visualLimit-                     pBiDi->runs[runIndex-1].visualLimit;        } else {            *pLength=pBiDi->runs[0].visualLimit;        }    }    return (UBiDiDirection)GET_ODD_BIT(start);}

static void output_line(FILE *out_file, DATA *data, DPOINT *where, 		double *est, int n_outfl) {	int i;	assert(out_file != NULL);	assert(out_file != stdout);	if (data->mode & X_BIT_SET) {		fprintf(out_file, " ");		fprintf(out_file, gl_format, where->x);	}	if (data->mode & Y_BIT_SET) {		fprintf(out_file, " ");		fprintf(out_file, gl_format, where->y);	}	if (data->mode & Z_BIT_SET) {		fprintf(out_file, " ");		fprintf(out_file, gl_format, where->z);	}	if (data->mode & S_BIT_SET)		fprintf(out_file, " %d", where->u.stratum + strata_min);	if (data->colnvalue > 0) {		fprintf(out_file, " ");		fprintf(out_file, gl_format, where->attr);	}	for (i = 0; i < n_outfl; i++)		fprintf(out_file, " %s", my_dtoa(gl_format, &(est[i])));    if (data->point_ids)        fprintf(out_file, " %s",data->point_ids[GET_INDEX(where)]);    	fprintf(out_file, "/n");	return;}

double matrix_get_column_abssum(const matrix_type * matrix , int column) {  double sum = 0;  int i;  for (i=0; i < matrix->rows; i++)    sum += fabs( matrix->data[ GET_INDEX( matrix , i , column ) ] );  return sum;}

double matrix_get_row_sum(const matrix_type * matrix , int row) {  double sum = 0;  int j;  for (j=0; j < matrix->columns; j++)    sum += matrix->data[ GET_INDEX( matrix , row , j ) ];  return sum;}

double run_experiment_ji ( mtype_t * matrix , mtype_t scalar , int buffer_size ) {    int i, j, iter;    hptimer_t start , end;    double final_time ;        start = get_time ();    for ( iter = 0; iter < MAX_ITERS ; ++ iter ) {        for (j = 0; j < buffer_size ; ++j ) {            for (i = 0; i < buffer_size ; ++i ) {                matrix [ GET_INDEX (i, j, buffer_size ) ] = scalar * matrix [ GET_INDEX (i, j, buffer_size ) ];            }        }    }    end = get_time ();    return final_time = diff_timers (start , end) / MAX_ITERS ;}

staticintchoice( void ){    int i, n;    rb->yield();    for( n = i = 0 ; i < 81 ; ++i )        if( IS_EMPTY( i ) )        {            possible[ n ] = SET_INDEX( i ) | SET_DIGIT( numset( board[ i ] ) );            /* Inconsistency if square unknown, but nothing possible */            if( 9 == GET_DIGIT( possible[ n ] ) )                return -2;            ++n;        }    if( 0 == n )        return -1;      /* All squares known */    rb->qsort( possible, n, sizeof( possible[ 0 ] ), cmp );    return GET_INDEX( possible[ 0 ] );}

/*************************************************************** * Ensures the velocity field is non divergent i.e. incompressible: * Solves a poisson equation to compute a gradient field and then * subtracts this from the current velocity field to obtain an * incompressible field. When solving for pressure it sets the * cells pressure field. ***************************************************************/void FGS_Fluid_Solver2DS :: project (FLUID_DATA ux, FLUID_DATA uy, FLUID_DATA pressure, FLUID_DATA divergence){    double h           = 1.0 / N * -0.5;    double half_width  = width   * 0.5;    double half_height = height  * 0.5;    int    cell;    double north, south, east, west;        for (int i=1 ; i <= width; i++ )        for (int j=1 ; j <= height; j++ ){            cell  = GET_INDEX(i,j);            north = grid[GET_INDEX(i,j-1)].data[uy];            south = grid[GET_INDEX(i,j+1)].data[uy];            east  = grid[GET_INDEX(i+1,j)].data[ux];            west  = grid[GET_INDEX(i-1,j)].data[ux];                        grid[cell].data[divergence] = h * (east-west+south-north);            grid[cell].data[pressure]   = 0;        }        set_boundary (SET_FOR_NON_VELOCITY_COMPONENT, divergence);    set_boundary (SET_FOR_NON_VELOCITY_COMPONENT, pressure);        computing_pressure = true;    linear_solve (SET_FOR_NON_VELOCITY_COMPONENT, pressure, divergence, 1, 0.25);    computing_pressure = false;        for (int i = 1; i <= width; i++)        for (int j = 1; j <= height; j++){                        cell  = GET_INDEX(i,j);            north = grid[GET_INDEX(i,j-1)].data[pressure];            south = grid[GET_INDEX(i,j+1)].data[pressure];            east  = grid[GET_INDEX(i+1,j)].data[pressure];            west  = grid[GET_INDEX(i-1,j)].data[pressure];                        double u_in_cell = grid[cell].data[ux],                   v_in_cell = grid[cell].data[uy];                        grid[cell].data[ux] = u_in_cell - (half_width  * (east  - west));            grid[cell].data[uy] = v_in_cell - (half_height * (south - north));                    }    set_boundary(SET_FOR_HORIZONTAL_COMPONENT, ux);    set_boundary(SET_FOR_VERTICAL_COMPONENT,   uy);}

/*************************************************************** * Computes a Gauss seidel relaxation to solve AX=B for the * unknowns X using forward substitution (the higher the number * of iterations the closer the resultant vector X will be * to convergence).  ***************************************************************/void FGS_Fluid_Solver2DS :: linear_solve (BOUNDARY_CONDITION  b, FLUID_DATA to, FLUID_DATA from, double a, double coef){    for (int k = 0 ; k < iterations; k++){        for (int i = 1 ; i <= width; i++){            for (int j = 1 ; j <= height; j++){                int    cell_ij_index = GET_INDEX(i, j);                double w             = grid[GET_INDEX(i-1, j)].data[to], e = grid[GET_INDEX(i+1, j)].data[to],                       n             = grid[GET_INDEX(i, j-1)].data[to], s = grid[GET_INDEX(i, j+1)].data[to],                       c0            = grid[cell_ij_index].data[from];                                grid[cell_ij_index].data[to] = coef * (c0 + a * (w+e+s+n));                                if (computing_pressure) grid[cell_ij_index].data[PRESSURE] = grid[cell_ij_index].data[to];            }        }        set_boundary(b, to);    }}

void matrix_copy_row(matrix_type * target_matrix, const matrix_type * src_matrix , int target_row, int src_row) {  matrix_assert_equal_columns( target_matrix , src_matrix );  {    int col;    for(col = 0; col < target_matrix->columns; col++)      target_matrix->data[ GET_INDEX( target_matrix , target_row , col)] = src_matrix->data[ GET_INDEX( src_matrix, src_row, col)];  }}

void matrix_copy_column(matrix_type * target_matrix, const matrix_type * src_matrix , int target_column, int src_column) {  matrix_assert_equal_rows( target_matrix , src_matrix );  {    int row;    for(row = 0; row < target_matrix->rows; row++)      target_matrix->data[ GET_INDEX( target_matrix, row , target_column)] = src_matrix->data[ GET_INDEX( src_matrix, row, src_column)];  }}

/** * add_path_node: Adds the path information to the current node * @info: Internal node info structure * @next: Combination of the id and index of the next node * Function returns: Number of pnodes (path_nodes) on success, * error on failure. * * Every node maintains the list of path nodes. A path node is * reached by finding the node-id and index stored at the current * node. This makes updating the paths with requested bw and clock * values efficient, as it avoids lookup for each update-path request. */static int add_path_node(struct msm_bus_inode_info *info, int next){	struct path_node *pnode;	int i;	if (ZERO_OR_NULL_PTR(info)) {		MSM_BUS_ERR("Cannot find node info!: id :%d/n",				info->node_info->priv_id);		return -ENXIO;	}	for (i = 0; i <= info->num_pnodes; i++) {		if (info->pnode[i].next == -2) {			MSM_BUS_DBG("Reusing pnode for info: %d at index: %d/n",				info->node_info->priv_id, i);			info->pnode[i].clk[DUAL_CTX] = 0;			info->pnode[i].clk[ACTIVE_CTX] = 0;			info->pnode[i].bw[DUAL_CTX] = 0;			info->pnode[i].bw[ACTIVE_CTX] = 0;			info->pnode[i].next = next;			MSM_BUS_DBG("%d[%d] : (%d, %d)/n",				info->node_info->priv_id, i, GET_NODE(next),				GET_INDEX(next));			return i;		}	}	info->num_pnodes++;	pnode = krealloc(info->pnode,		((info->num_pnodes + 1) * sizeof(struct path_node))		, GFP_KERNEL);	if (ZERO_OR_NULL_PTR(pnode)) {		MSM_BUS_ERR("Error creating path node!/n");		info->num_pnodes--;		return -ENOMEM;	}	info->pnode = pnode;	info->pnode[info->num_pnodes].clk[DUAL_CTX] = 0;	info->pnode[info->num_pnodes].clk[ACTIVE_CTX] = 0;	info->pnode[info->num_pnodes].bw[DUAL_CTX] = 0;	info->pnode[info->num_pnodes].bw[ACTIVE_CTX] = 0;	info->pnode[info->num_pnodes].next = next;	MSM_BUS_DBG("%d[%d] : (%d, %d)/n", info->node_info->priv_id,		info->num_pnodes, GET_NODE(next), GET_INDEX(next));	return info->num_pnodes;}

double matrix_get_row_abssum(const matrix_type * matrix , int row) {  double sum_abs = 0;  int j;  for ( j=0; j < matrix->columns; j++) {    double m = matrix->data[ GET_INDEX( matrix , row , j ) ];    sum_abs += fabs( m );  }  return sum_abs;}

double matrix_get_row_sum2(const matrix_type * matrix , int row) {  double sum2 = 0;  int j;  for ( j=0; j < matrix->columns; j++) {    double m = matrix->data[ GET_INDEX( matrix , row , j ) ];    sum2 += m*m;  }  return sum2;}

void matrix_diag_set_scalar(matrix_type * matrix , double value) {  if (matrix->rows == matrix->columns) {    int i;        matrix_set(matrix , 0);    for ( i=0; i < matrix->rows; i++)      matrix->data[ GET_INDEX(matrix , i , i) ] = value;  } else    util_abort("%s: size mismatch /n",__func__);}

/************************************************************************************************* * Inlines */INLINE struct rs_resource* rs_resource_get(reshandle_t hdl) {    uint idx = GET_INDEX(hdl);    ASSERT(idx < (uint)g_rs.ress.item_cnt);    struct rs_resource* r = &((struct rs_resource*)g_rs.ress.buffer)[idx];    ASSERT(r->hdl != INVALID_HANDLE);    ASSERT(GET_ID(r->hdl) == GET_ID(hdl));    return r;}

/**   Return the sum of the squares on column.*/double matrix_get_column_sum2(const matrix_type * matrix , int column) {  double sum2 = 0;  int i;  for ( i=0; i < matrix->rows; i++) {    double m = matrix->data[ GET_INDEX( matrix , i , column ) ];    sum2 += m*m;  }  return sum2;}

void matrix_diag_set(matrix_type * matrix , const double * diag) {  if (matrix->rows == matrix->columns) {    int i;        matrix_set(matrix , 0);    for ( i=0; i < matrix->rows; i++)      matrix->data[ GET_INDEX(matrix , i , i) ] = diag[i];  } else    util_abort("%s: size mismatch /n",__func__);}

extern intmem_blocks_pool_get_block_index(const MEMORY_BLOCKS_POOL *pool, int id) {    int real_id = GET_ID(id);    int index = GET_INDEX(id);    if (pool->ids[index] == real_id)        return index;    return -1;}

/*************************************************************** * Computes for each cell a backwards particle trace: Linearly * interpolates a virtual particle from the center of each cell * backwards in time (dt) using the velocity in the cell (Uxy) * and copies the value (density or velocity) from this * 'previous' position into the cell. Also computes the average * density if called from the density step. ***************************************************************/void FGS_Fluid_Solver2DS :: advect (BOUNDARY_CONDITION  b,  FLUID_DATA to, FLUID_DATA from, FLUID_DATA ux, FLUID_DATA uy){        int      i0, j0, i1, j1;        double   x,  y,  s0, t0,             s1, t1, deltaT0,             nw, ne, se, sw;        deltaT0 = deltaT*N;        for (int i = 1; i <= width; i++) {        for (int j = 1; j <= height; j++) {                        int cell_ij_index = GET_INDEX(i,j);                        x = i-deltaT0 * grid[cell_ij_index].data[ux];            y = j-deltaT0 * grid[cell_ij_index].data[uy];                        if      (x < 0.5         )   x = 0.5;            else if (x > width + 0.5 )   x = width+0.5;            if      (y < 0.5         )   y = 0.5;            else if (y > height + 0.5)   y = height+0.5;                        i0 = ((int) x); j0 = ((int) y);            i1 = i0 + 1;    j1 = j0 + 1;                        s1 = x-i0;      s0 = 1-s1;            t1 = y-j0;      t0 = 1-t1;                        nw = grid[GET_INDEX(i0, j0)].data[from];            ne = grid[GET_INDEX(i1, j0)].data[from];            se = grid[GET_INDEX(i1, j1)].data[from];            sw = grid[GET_INDEX(i0, j1)].data[from];                        grid[cell_ij_index].data[to] = s0 * (t0 * nw + t1 * sw) + s1 * (t0 * ne + t1 * se);            if(computing_density)                d_av += grid[cell_ij_index].data[to];        }    }    if(computing_density)        d_av *= inv_dims;    set_boundary (b, to);}