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);
}
