int main() { int n,m; while((scanf("%d %d",&n,&m))==2) { int i,j,A[105][105],S[105][105]={0}; for(i=0;i<n;++i) { for(j=0;j<m;++j) { scanf("%d",&A[i][j]); if(i==0) S[i][j]=A[i][j]; else if(i!=0&&j==0) S[i][j]=A[i][j]+min2(S[i-1][j+1],S[i-1][j]); else if(i!=0&&j==m-1) S[i][j]=A[i][j]+min2(S[i-1][j-1],S[i-1][j]); else S[i][j]=A[i][j]+min3(S[i-1][j-1],S[i-1][j],S[i-1][j+1]); } } i=n-1; int min=S[i][0]; for(j=1;j<m;++j) min=min2(min,S[i][j]); printf("%d\n",min); } return 0; }
// http://www.merriampark.com/ldc.htm int c_levenstein_distance(char *s, char *t) { int k, i, j, n, m, cost, *d, distance; n = strlen(s); m = strlen(t); if (n != 0 && m != 0) { d = (int*)malloc((sizeof(int)) * (m + 1) * (n + 1)); m++; n++; //Step 2 for (k = 0; k < n; k++) d[k] = k; for (k = 0; k < m; k++) d[k * n] = k; //Step 3 and 4 for (i = 1; i < n; i++) for (j = 1; j < m; j++) { //Step 5 if (s[i - 1] == t[j - 1]) cost = 0; else cost = 1; //Step 6 d[j * n + i] = min3(d[(j - 1) * n + i] + 1, d[j * n + i - 1] + 1, d[(j - 1) * n + i - 1] + cost); } distance = d[n * m - 1]; free(d); return distance; } //a negative return value means that one or both strings are empty. else return -1; }
int ydpDictionary::editDistance(const char*slowo1, const char*slowo2) { int *row0, *row1, *row; int cost,i,j,m,n; static int rowx[512]; // speedup! static int rowy[512]; n = strlen(slowo1); if (n>510) n=510; // n+1 is used m = strlen(slowo2); row0 = rowx; row1 = rowy; for (i=0;i<=n;i++) row0[i] = i; for (j=1;j<=m;j++) { row1[0] = j; for (i=1;i<=n;i++) { cost = (slowo1[i-1]==slowo2[j-1]) ? 0 : 1; // cost = (tolower(slowo1[i-1])==tolower(slowo2[j-1])) ? 0 : 1; /// za wolno!!! row1[i] = min3(row0[i]+1,row1[i-1]+1,row0[i-1]+cost); } row = row0; row0 = row1; row1 = row; } cost = row0[n]; return cost; }
int edit_dist_i2( char* str1, char* str2, int len_1, int len_2 ) { int i = 0; int j = 0; int max = ( ( len_1 > len_2 ) ? len_1 : len_2 ) + 1; int retv = 0; int lut[32][32] = { { 0 } }; /*build the table - first rows*/ for( i = 0; i < max; i ++ ) lut[0][i] = i; for( j = 0; j < max; j ++ ) lut[j][0] = j; for( i = 1; i < max; i ++ ) { for( j = 1; j < max; j ++ ) { /*no change*/ if( str1[i] == str2[j] ) lut[i][j] = lut[i-1][j-1]; /*otherwise get the minimum from the values*/ else lut[i][j] += min3( ( lut[i-1][j] ) + 1, //insert ( lut[i][j-1] ) + 1, //delete ( lut[i-1][j-1] ) + 1 ); //substitution } } retv = lut[len_1][len_2]; return retv; }
/** Perform sparc64-specific initialization before main_bsp() is called. */ void arch_pre_main(bootinfo_t *bootinfo) { /* Copy init task info. */ init.cnt = min3(bootinfo->taskmap.cnt, TASKMAP_MAX_RECORDS, CONFIG_INIT_TASKS); size_t i; for (i = 0; i < init.cnt; i++) { init.tasks[i].paddr = KA2PA(bootinfo->taskmap.tasks[i].addr); init.tasks[i].size = bootinfo->taskmap.tasks[i].size; str_cpy(init.tasks[i].name, CONFIG_TASK_NAME_BUFLEN, bootinfo->taskmap.tasks[i].name); } /* Copy physical memory map. */ memmap.total = bootinfo->memmap.total; memmap.cnt = min(bootinfo->memmap.cnt, MEMMAP_MAX_RECORDS); for (i = 0; i < memmap.cnt; i++) { memmap.zones[i].start = bootinfo->memmap.zones[i].start; memmap.zones[i].size = bootinfo->memmap.zones[i].size; } /* Copy boot allocations info. */ ballocs.base = bootinfo->ballocs.base; ballocs.size = bootinfo->ballocs.size; ofw_tree_init(bootinfo->ofw_root); }
// Low-memory version! int computeLevenshtein2(compare_t comp) { int **mat; int i, j; mat = (int **)malloc((2)*sizeof(int *)); for (i = 0; i < 2; ++i) { mat[i] = (int *)malloc((comp.lenA + 1)*sizeof(int)); mat[i][0] = i; } for (i = 0; i < comp.lenA + 1; ++i) { mat[0][i] = i; } for (i = 1; i < comp.lenB + 1; ++i) { for (j = 1; j < comp.lenA + 1; ++j) { if (comp.A[j-1] == comp.B[i-1]) mat[1][j] = mat[0][j-1]; else mat[1][j] = min3(mat[0][j] + 1, mat[1][j-1] + 1, mat[0][j-1] + 1); } for (j = 0; j < comp.lenA + 1; ++j) { mat[0][j] = mat[1][j]; } mat[1][0] = i+1; } int ret = mat[0][comp.lenA]; for (i = 0; i < 2; ++i) free(mat[i]); free(mat); return ret; }
// Fills the cost matrix, *cost, with respect to Sakoe & Chiba band constraint |i-j| < ks -- O(k*n) void fill_cost_matrix_with_sakoe_chiba_constraint(const double *x, const double *y, int n, int m, int n_dimensions, int distance_selector, double warping_penalty, double *cost, int sakoe_chiba_band_parameter) { double (*dist)(const double *, const double *, const int); dist = distance_function(distance_selector); int i, j; // Fill cost matrix with infinities first for (i = 0; i < n*m; i++) cost[i] = INFINITY; // Initialise cost[0] = (*dist)(&x[0], &y[0], n_dimensions); for (i=1; i<min2(n, sakoe_chiba_band_parameter+1); i++) cost[i*m] = (*dist)(&x[i*n_dimensions], &y[0], n_dimensions) + cost[(i-1)*m] + warping_penalty; for (j=1; j<min2(m, sakoe_chiba_band_parameter+1); j++) cost[j] = (*dist)(&x[0], &y[j*n_dimensions], n_dimensions) + cost[(j-1)] + warping_penalty; // Fill only the columns that satisfy |i-j| <= sakoe_chiba_band_parameter for (i=1; i<n; i++) for (j=max2(i-sakoe_chiba_band_parameter, 1); j<min2(m, i+sakoe_chiba_band_parameter+1); j++) cost[i*m+j] = (*dist)(&x[i*n_dimensions], &y[j*n_dimensions], n_dimensions) + min3(cost[(i-1)*m+j] + warping_penalty, cost[(i-1)*m+(j-1)], cost[i*m+(j-1)] + warping_penalty); }
struct ColorHSL RGBtoHSL (int R,int G, int B) { // Prototype double max3 (int , int , int); double min3 (int , int , int); struct ColorHSL hsl; double Cmax = max3(R,G,B); double Cmin = min3(R,G,B); double dif = Cmax - Cmin; int H; if( dif == 0 ) H = 0; else if ( Cmax == R ) H = 60 * fmod((G-B)/dif,6); else if ( Cmax == G ) H = 60 * ((B-R)/dif + 2); else if ( Cmax == B ) H = 60 * ((R-G)/dif + 4); double L = (Cmax + Cmin)/510; double S; if ( dif == 0 ) S = 0; else S = dif/255/(1-fabs(2*L-1)); hsl.H = H; hsl.S = S; hsl.L = L; return hsl; }
static inline double __plm_minmod(double ul, double u0, double ur) { const double a = plm_theta * (u0 - ul); const double b = 0.5 * (ur - ul); const double c = plm_theta * (ur - u0); const double fabc[3] = { fabs(a), fabs(b), fabs(c) }; return 0.25*fabs(SGN(a)+SGN(b))*(SGN(a)+SGN(c))*min3(fabc); }
double __weno5(const double *v, const double c[3][3], const double d[3]) // ----------------------------------------------------------------------------- // // // // Improvement of the WENO scheme smoothness estimator, Shen & Zha (2010) // ----------------------------------------------------------------------------- { double eps = 1e-6; double eps_prime = 1e-6; const double vs[3] = { c[0][0]*v[+0] + c[0][1]*v[+1] + c[0][2]*v[2], c[1][0]*v[-1] + c[1][1]*v[+0] + c[1][2]*v[1], c[2][0]*v[-2] + c[2][1]*v[-1] + c[2][2]*v[0], }; double B[3] = { // smoothness indicators (13./12.)*SQU(1*v[+0] - 2*v[+1] + 1*v[+2]) + ( 1./ 4.)*SQU(3*v[+0] - 4*v[+1] + 1*v[+2]), (13./12.)*SQU(1*v[-1] - 2*v[+0] + 1*v[+1]) + ( 1./ 4.)*SQU(1*v[-1] - 0*v[+0] - 1*v[+1]), (13./12.)*SQU(1*v[-2] - 2*v[-1] + 1*v[+0]) + ( 1./ 4.)*SQU(1*v[-2] - 4*v[-1] + 3*v[+0]) }; double w[3]; if (IS_mode == ImprovedBorges08) { eps = eps_prime = 1e-14; // Borges uses 1e-40, but has Matlab const double tau5 = fabs(B[0] - B[2]); // Calculate my weights with new smoothness indicators accoding to Borges w[0] = d[0] * (1.0 + (tau5 / (B[0] + eps))); w[1] = d[1] * (1.0 + (tau5 / (B[1] + eps))); w[2] = d[2] * (1.0 + (tau5 / (B[2] + eps))); } else if (IS_mode == ImprovedShenZha10) { eps = 1e-6; eps_prime = 1e-10; const double A = shenzha10_A; // [0 (less aggressive) -> ~100 (more aggressive)] const double minB = min3(B), maxB = max3(B); const double R0 = minB / (maxB + eps_prime); B[0] = R0*A*minB + B[0]; B[1] = R0*A*minB + B[1]; B[2] = R0*A*minB + B[2]; w[0] = d[0] / SQU(eps_prime + B[0]); w[1] = d[1] / SQU(eps_prime + B[1]); w[2] = d[2] / SQU(eps_prime + B[2]); } else { // Use OriginalJiangShu96 eps = eps_prime = 1e-6; // recommended value by Jiang and Shu w[0] = d[0] / SQU(eps_prime + B[0]); w[1] = d[1] / SQU(eps_prime + B[1]); w[2] = d[2] / SQU(eps_prime + B[2]); } const double wtot = w[0] + w[1] + w[2]; return (w[0]*vs[0] + w[1]*vs[1] + w[2]*vs[2])/wtot; }
int minCost(int **cost,int m,int n){ if(m<0 || n<0) return INT_MAX; else if(m==0 && n==0) return cost[m][n]; else return cost[m][n]+min3(minCost(cost,m,n-1),minCost(cost,m-1,n),minCost(cost,m-1,n-1)); }
/** calculate shortest path through matrix M. \param M is a n1 x n2 matrix \param p is the path, a nd x np matrix of corresponding matrix indices, nd=2 (else the typemaps do not work properly) \return 0 in case of success, 1 otherwise */ int cdtw( double *M, int n1, int n2, int *p, int nd, int np ){ int i,j; /* argument checks */ if( nd!=2 ){ printf("nd needs to be 2, found %i\n", nd); return 1; } if( np<n1+n2 ){ printf("path may be too short, %i<%i\n", np, n1+n2); return 1; } double *D=(double*)malloc( n1*n2*sizeof(double)); memcpy( D, M, n1*n2*sizeof(double)); for( i=0; i<n1; i++ ) for( j=0; j<n2; j++ ) matIDX(D,n1,i+1,j+1)= matIDX(M,n1,i,j)+min3(matIDX(D,n1,i,j+1), matIDX(D,n1,i+1,j), matIDX(D,n1,i+1,j+1)); i=n1-1; j=n2-1; pIDX( p, np, 0, 0 ) = i; pIDX( p, np, 0, 1 ) = j; int pi=1; while( i>0 || j>0 ){ if( i>0 && j>0 ){ if( matIDX(D,n1,i,j-1)<matIDX(D,n1,i-1,j-1) ){ if( matIDX(D,n1,i,j-1)<matIDX(D,n1,i-1,j) ){ j--; } else { i--; } } else { if( matIDX(D,n1,i-1,j-1)<matIDX(D,n1,i-1,j) ){ i--; j--; } else { j--; } } } else if( i>0 ){ // i>0, j==0 i--; } else { // i==0, j>0 j--; } pIDX( p, np, pi, 0) = i; pIDX( p, np, pi, 1) = j; pi++; } free( D ); return 0; }
void Init(int worldsize) { btVector3 min3(-worldsize,-worldsize,-worldsize); btVector3 max3( worldsize, worldsize, worldsize); collisionConfiguration = new btDefaultCollisionConfiguration(); dispatcher = new btCollisionDispatcher(collisionConfiguration); constraintSolver = new btSequentialImpulseConstraintSolver(); pairCache = new btAxisSweep3(min3, max3); dynamicsWorld = new btDiscreteDynamicsWorld(dispatcher,pairCache,constraintSolver,collisionConfiguration); dynamicsWorld->setGravity(btVector3(0,0.0f,-9.8f)); }
void Triangle::Compute_BBox() { Vector3d Min, Max, Epsilon; Epsilon = Vector3d(EPSILON); Min[X] = min3(P1[X], P2[X], P3[X]); Min[Y] = min3(P1[Y], P2[Y], P3[Y]); Min[Z] = min3(P1[Z], P2[Z], P3[Z]); Max[X] = max3(P1[X], P2[X], P3[X]); Max[Y] = max3(P1[Y], P2[Y], P3[Y]); Max[Z] = max3(P1[Z], P2[Z], P3[Z]); Min -= Epsilon; Max += Epsilon; Make_BBox_from_min_max(BBox, Min, Max); }
void Compute_Triangle_BBox(TRIANGLE *Triangle) { VECTOR Min, Max, Epsilon; Make_Vector(Epsilon, EPSILON, EPSILON, EPSILON); Min[X] = min3(Triangle->P1[X], Triangle->P2[X], Triangle->P3[X]); Min[Y] = min3(Triangle->P1[Y], Triangle->P2[Y], Triangle->P3[Y]); Min[Z] = min3(Triangle->P1[Z], Triangle->P2[Z], Triangle->P3[Z]); Max[X] = max3(Triangle->P1[X], Triangle->P2[X], Triangle->P3[X]); Max[Y] = max3(Triangle->P1[Y], Triangle->P2[Y], Triangle->P3[Y]); Max[Z] = max3(Triangle->P1[Z], Triangle->P2[Z], Triangle->P3[Z]); VSubEq(Min, Epsilon); VAddEq(Max, Epsilon); Make_BBox_from_min_max(Triangle->BBox, Min, Max); }
int common_prefix_length(int max, char *s, char *t, int ss, int st) { int i, n; n = min3(max, ss, st); for (i = 0; i < n; i++) { if (s[i] != t[i]) return i; } return n; }
int optimal_warping_path(double *dtwm, int n, int m, int *pathx, int *pathy, int startbc) { int i = n - 1; int j = m - 1; int k = 0; double min_ij, dtwm_i, dtwm_j, dtwm_ij; pathx[k] = i; pathy[k] = j; k++; while ((i > 0) || (j > 0)) { if ((i == 0) && (j > 0)) { if (startbc == 1) j -= 1; else break; } if ((j == 0) && (i > 0)) { if (startbc == 1) i -= 1; else break; } if ((i > 0) && (j > 0)) { dtwm_i = dtwm[(i - 1) * m + j]; dtwm_j = dtwm[i * m + (j - 1)]; dtwm_ij = dtwm[(i - 1) * m + (j - 1)]; min_ij = min3(dtwm_i, dtwm_j, dtwm_ij); if (dtwm_ij == min_ij) { i -= 1; j -= 1; } else if (dtwm_i == min_ij) i -= 1; else if (dtwm_j == min_ij) j -= 1; } pathx[k] = i; pathy[k] = j; k++; } return k; }
/*software rasterizer TODO could be more efficient*/ void render_triangle(Point2D v0, Point2D v1, Point2D v2, volatile unsigned char *fb, uint16_t colour) { int min_x = min3(v0.x, v1.x, v2.x); int min_y = min3(v0.y, v1.y, v2.y); int max_x = max3(v0.x, v1.x, v2.x); int max_y = max3(v0.y, v1.y, v2.y); Point2D p; for (p.y = min_y; p.y <= max_y; p.y++) { for (p.x = min_x; p.x <= max_x; p.x++) { float w0, w1, w2; get_barycentric(p, v0, v1, v2, &w0, &w1, &w2); // If p is on or inside all edges, render pixel. if (w0 >= 0 && w1 >= 0 && w2 >= 0) { /*TODO render nicely*/ draw_pixel(p.x, p.y, fb, colour); } } } }
static const char *ip_vs_dbg_callid(char *buf, size_t buf_len, const char *callid, size_t callid_len, int *idx) { size_t max_len = 64; size_t len = min3(max_len, callid_len, buf_len - *idx - 1); memcpy(buf + *idx, callid, len); buf[*idx+len] = '\0'; *idx += len + 1; return buf + *idx - len; }
int compute(int n) { int i; cost[n-1][0]+=cost[n-1][1]; cost[n-2][2]+=cost[n-1][1]; cost[n-2][1]+=min3(cost[n-1][1],cost[n-1][0],cost[n-2][2]); cost[n-2][0]+=min3(cost[n-1][1],cost[n-1][0],cost[n-2][1]); for(i=n-3; i>=0; i--) { cost[i][2]+=min2(cost[i+1][1],cost[i+1][2]); cost[i][1]+=min4(cost[i+1][0],cost[i+1][1],cost[i+1][2],cost[i][2]); cost[i][0]+=min3(cost[i+1][0],cost[i+1][1],cost[i][1]); } return cost[0][1]; }
/* Return the max entries we can fill into tx fifo */ static u32 pic32_tx_max(struct pic32_spi_priv *priv, int n_bytes) { u32 tx_left, tx_room, rxtx_gap; tx_left = (priv->tx_end - priv->tx) / n_bytes; tx_room = priv->fifo_n_word - pic32_spi_tx_fifo_level(priv); rxtx_gap = (priv->rx_end - priv->rx) - (priv->tx_end - priv->tx); rxtx_gap /= n_bytes; return min3(tx_left, tx_room, (u32)(priv->fifo_n_word - rxtx_gap)); }
int cercaMin(tree t) { int s, d, m; if (t == NULL) return 0;//eseguita solo se da subito l’albero è vuoto if (t->left == NULL && t->right == NULL) return t->info; if (t->left == NULL) return min(t->info, cercaMin(t->right)); if (t->right == NULL) return min(t->info, cercaMin(t->left)); return min3(cercaMin(t->right), cercaMin(t->left), t->info); }
double quasisymmetric0(double *x, double *y, int n, int m, double *dtwm, int **constr) { int i, j; double d; double dtwm_i, dtwm_j, dtwm_ij; for (i=0; i<n; i++) for (j=0; j<m; j++) dtwm[i * m + j] = DBL_MAX; dtwm[0] = euclidean(x[0], y[0]); // DP-algorithm (i - 1), (j - 1) for (j=constr[0][0] + 1; j<=constr[1][0]; j++) { d = euclidean(x[0], y[j]); dtwm_j = dtwm[0 * m + (j - 1)] + d; // DP-algorithm (j - 1) dtwm[0 * m + j] = dtwm_j; } for (i=1; i<n; i++) for (j=constr[0][i]; j<=constr[1][i]; j++) { d = euclidean(x[i], y[j]); if (j == 0) { dtwm_i = dtwm[(i - 1) * m + j] + d; // DP-algorithm (i - 1) dtwm[i * m + j] = dtwm_i; } else { dtwm_i = dtwm[(i - 1) * m + j]; dtwm_ij = dtwm[(i - 1) * m + (j - 1)]; dtwm_j = dtwm[i * m + (j - 1)]; if (dtwm_i != DBL_MAX) dtwm_i = dtwm_i + d; // DP-algorithm (i - 1) if (dtwm_ij != DBL_MAX) dtwm_ij = dtwm_ij + d; // DP-algorithm (i - 1), (j - 1) if (dtwm_j != DBL_MAX) dtwm_j = dtwm_j + d; // DP-algorithm (j - 1) dtwm[i * m + j] = min3(dtwm_i, dtwm_j, dtwm_ij); } } return dtwm[(m * n) - 1] / (double) (n + m); }
/* Compute Levenhstein distance - http://www.merriampark.com/ld.htm */ static int distance(const char *a, int al, const char *b, int bl, int cutoff, float *ratio) { int lst[MAXSIZE]; const char *t; int tl, last, nextlast; int ai, bi, minlstbi; int res; if (al > MAXSIZE) al = MAXSIZE; if (bl > MAXSIZE) bl = MAXSIZE; if (al == bl && memcmp(a, b, al) == 0) { if (ratio) *ratio = 1.0; return 0; } if (al > bl) { t = a; tl = al; a = b; al = bl; b = t; bl = tl; } for (bi = 0; bi != bl; bi++) lst[bi] = bi+1; for (ai = 0; ai != al; ai++) { last = lst[0]; lst[0] = minlstbi = min2(lst[0]+1, ai+(b[0] != a[ai]?1:0)); for (bi = 1; bi != bl; bi++) { nextlast = lst[bi]; lst[bi] = min3(lst[bi-1]+1, lst[bi]+1, last+(b[bi] != a[ai]?1:0)); last = nextlast; if (cutoff != -1 && lst[bi] < minlstbi) minlstbi = lst[bi]; } if (cutoff != -1 && minlstbi > cutoff) { if (ratio) *ratio = 0.0; return bl; } } res = lst[bl-1]; if (cutoff != -1 && res > cutoff) { if (ratio) *ratio = 0.0; return bl; } if (ratio) *ratio = ((float)bl-res)/bl; return res; }
void __init setup_log_buf(int early) { unsigned long flags; unsigned start, dest_idx, offset; char *new_log_buf; int free; if (!new_log_buf_len) return; if (early) { unsigned long mem; mem = memblock_alloc(new_log_buf_len, PAGE_SIZE); if (!mem) return; new_log_buf = __va(mem); } else { new_log_buf = alloc_bootmem_nopanic(new_log_buf_len); } if (unlikely(!new_log_buf)) { pr_err("log_buf_len: %ld bytes not available\n", new_log_buf_len); return; } raw_spin_lock_irqsave(&logbuf_lock, flags); log_buf_len = new_log_buf_len; log_buf = new_log_buf; new_log_buf_len = 0; free = __LOG_BUF_LEN - log_end; offset = start = min3(con_start, log_start, dev_start); dest_idx = 0; while (start != log_end) { unsigned log_idx_mask = start & (__LOG_BUF_LEN - 1); log_buf[dest_idx] = __log_buf[log_idx_mask]; start++; dest_idx++; } log_start -= offset; dev_start -= offset; con_start -= offset; log_end -= offset; raw_spin_unlock_irqrestore(&logbuf_lock, flags); pr_info("log_buf_len: %d\n", log_buf_len); pr_info("early log buf free: %d(%d%%)\n", free, (free * 100) / __LOG_BUF_LEN); }
TriangleIntType triangle_point_intersection_exact(const vec2 tri_a[3], const vec2 &pt_b) { CARVE_ASSERT(orient2d_exact(tri_a[0], tri_a[1], tri_a[2]) >= 0.0); int m = min3(dbl_sign(orient2d_exact(tri_a[0], tri_a[1], pt_b)), dbl_sign(orient2d_exact(tri_a[1], tri_a[2], pt_b)), dbl_sign(orient2d_exact(tri_a[2], tri_a[0], pt_b))); switch (m) { case -1: return TR_TYPE_NONE; case 0: return TR_TYPE_TOUCH; default: return TR_TYPE_INT; } }
void RGB_to_HSV(double var_R, double var_G, double var_B, double &H, double &S, double &V) { //http://www.easyrgb.com/math.php?MATH=M20#text20 var_R = round(var_R); var_G = round(var_G); var_B = round(var_B); double var_Min, var_Max, del_Max, del_R, del_G, del_B; var_R /= 255.0; //RGB values = From 0 to 255 var_G /= 255.0; var_B /= 255.0; var_Min = min3( var_R, var_G, var_B ); //Min. value of RGB var_Max = max3( var_R, var_G, var_B ); //Max. value of RGB del_Max = var_Max - var_Min; //Delta RGB value V = var_Max; if ( del_Max == 0 ) //This is a gray, no chroma... { H = 0; //HSV results = From 0 to 1 S = 0; } else //Chromatic data... { S = del_Max / var_Max; del_R = ( ( ( var_Max - var_R ) / 6.0 ) + ( del_Max / 2.0 ) ) / del_Max; del_G = ( ( ( var_Max - var_G ) / 6.0 ) + ( del_Max / 2.0 ) ) / del_Max; del_B = ( ( ( var_Max - var_B ) / 6.0 ) + ( del_Max / 2.0 ) ) / del_Max; if ( var_R == var_Max ) H = del_B - del_G; else if ( var_G == var_Max ) H = ( 1 / 3.0 ) + del_R - del_B; else if ( var_B == var_Max ) H = ( 2 / 3.0 ) + del_G - del_R; if ( H < 0 ) H += 1; if ( H > 1 ) H -= 1; } //H = fabs(H); H *= 255; S *= 255; V *= 255; H = round(H); S = round(S); V = round(V); }
int main() { int i, j, k, ans_idx = 0; for(i = 0; i < NR_DATA; i ++) { for(j = 0; j < NR_DATA; j ++) { for(k = 0; k < NR_DATA; k ++) { nemu_assert(min3(test_data[i], test_data[j], test_data[k]) == ans[ans_idx ++]); } } } HIT_GOOD_TRAP; return 0; }
int MCP(int cost[R][C]) { int i,j; for(i=1;i<R;i++) cost[i][0] += cost[i-1][0]; for(i=1;i<C;i++) cost[0][i] += cost[0][i-1]; for(i=1;i<R;i++) { for(j=1;j<C;j++) { cost[i][j] = min3(cost[i-1][j],cost[i][j-1],cost[i-1][j-1]) + cost[i][j]; } } return cost[R-1][C-1]; }
void gsc_set_prefbuf(struct gsc_dev *gsc, struct gsc_frame *frm) { u32 f_chk_addr, f_chk_len, s_chk_addr, s_chk_len; f_chk_addr = f_chk_len = s_chk_addr = s_chk_len = 0; f_chk_addr = frm->addr.y; f_chk_len = frm->payload[0]; if (frm->fmt->num_planes == 2) { s_chk_addr = frm->addr.cb; s_chk_len = frm->payload[1]; } else if (frm->fmt->num_planes == 3) { u32 low_addr, low_plane, mid_addr, mid_plane; u32 high_addr, high_plane; u32 t_min, t_max; t_min = min3(frm->addr.y, frm->addr.cb, frm->addr.cr); if (get_plane_info(frm, t_min, &low_plane, &low_addr)) return; t_max = max3(frm->addr.y, frm->addr.cb, frm->addr.cr); if (get_plane_info(frm, t_max, &high_plane, &high_addr)) return; mid_plane = 3 - (low_plane + high_plane); if (mid_plane == 0) mid_addr = frm->addr.y; else if (mid_plane == 1) mid_addr = frm->addr.cb; else if (mid_plane == 2) mid_addr = frm->addr.cr; else return; f_chk_addr = low_addr; if (mid_addr + frm->payload[mid_plane] - low_addr > high_addr + frm->payload[high_plane] - mid_addr) { f_chk_len = frm->payload[low_plane]; s_chk_addr = mid_addr; s_chk_len = high_addr + frm->payload[high_plane] - mid_addr; } else { f_chk_len = mid_addr + frm->payload[mid_plane] - low_addr; s_chk_addr = high_addr; s_chk_len = frm->payload[high_plane]; } } pr_debug("f_addr = 0x%08x, f_len = %d, s_addr = 0x%08x, s_len = %d\n", f_chk_addr, f_chk_len, s_chk_addr, s_chk_len); }