struct rational determinant(struct matrix M){
set_error(NONE);
struct rational det = int_to_r(0);
if (M.rows == M.columns) {
if(M.rows > 2) {
for(int i=1; i<= M.rows; i++) {
//alternate adding and subtracting
if ((i%2) == 1 ) {
struct matrix pos_subm = submatrix(M,i,1);
det = r_add(det, r_multiply(get_element(M,i,1), determinant(pos_subm)));
free_matrix(pos_subm);
} else {
struct matrix neg_subm = submatrix(M,i,1);
det = r_subtract(det, r_multiply(get_element(M,i,1), determinant(neg_subm)));
free_matrix(neg_subm);
}
}
}
if(M.rows == 2) {
det = r_subtract ( r_multiply(get_element(M,1,1), get_element(M,2,2)),
r_multiply(get_element(M,1,2), get_element(M,2,1)));
}
if(M.rows == 1) {
det = get_element(M,1,1);
}
} else {
det = int_to_r(-1);
set_error(INCOMPATIBLE_MATRIX);
}
return det;
}
struct rational row_times_column(struct matrix A, int row, struct matrix B, int column){
int i;
struct rational sum = new_rational(0,1);
//sum A[row][i]*B[j][column]
if (A.columns == B.rows){
for (i=1; i<=A.columns; i++) {
sum = r_add(sum, r_multiply( get_element(A,row,i), get_element(B,i,column)));
}
}
return sum;
}
void _add_multiple(struct matrix M, struct rational factor, int input_row, int modified_row){
set_error(NONE);
if(input_row > 0 && modified_row > 0 && input_row <= M.rows && modified_row <= M.rows){
struct rational temp;
int col;
for(col=1; col<=M.columns; col++){
temp = r_multiply(factor, get_element(M,input_row,col));
temp = r_add(temp, get_element(M,modified_row,col));
set_element(M,modified_row,col,temp);
}
} else
set_error(INCOMPATIBLE_MATRIX);
}
void test_bi_find(int n)
{
BiTree_s tree = { 0 };
Rec_s rec;
unint i;
if (FALSE) seed_random();
for (i = 0; i < n; i++) {
rec.key = fixed_lump(7);
rec.val = rnd_lump();
r_add(rec);
bi_insert(&tree, rec);
}
r_for_each(find_find, &tree);
bi_audit(&tree);
}
struct matrix add(struct matrix A, struct matrix B){ //A + B
set_error(NONE);
struct matrix C;
int i,j;
if (A.rows == B.rows && A.columns == B.columns){
C = new_matrix(A.rows, B.columns);
for (i=1; i<=C.rows; i++) {
for (j=1; j<=C.columns; j++) {
set_element(C, i, j, r_add(get_element(A,i,j), get_element(B,i,j)));
}
}
} else {
C = new_matrix(0,0);
set_error(INCOMPATIBLE_MATRIX);
}
return C;
}
void add_test() {
int p,q,s,t;
for ( p = -100; p <= 100; p+=10) {
for ( q = -100; q <= 100; q+=10) {
for ( s = -100; s <= 100; s+=10) {
for ( t = -100; t <= 100; t+=10) {
if (q != 0 && t != 0) {
struct rational r = new_rational(p,q);
struct rational u = new_rational(s,t);
struct rational sum = r_add(r,u);
if ((sum.p*1.0)/(sum.q*1.0) < (p*1.0/q*1.0+s*1.0/t*1.0)-1e-6 || (sum.p*1.0)/(sum.q*1.0) > (p*1.0/q*1.0+s*1.0/t*1.0)+1e-6) {
printf("\nAdd failed: %d/%d %d/%d\n",p,q,s,t);
printf("%.19g %.19g\n",(sum.p*1.0)/(sum.q*1.0),(p*1.0/q*1.0+s*1.0/t*1.0));
return;
}
if (r.q ==0) {
printf("0 denominator failure\n");
return;
}
}
}
if(s%500 == 0){
printf(".");
fflush(stdout);
}
}
if(q%500 == 0){
printf(".");
fflush(stdout);
}
}
if(p%500 == 0){
printf(".");
fflush(stdout);
}
}
}
static int BuildRegions( rectangle_t *p_region, int i_max_region, ASS_Image *p_img_list, int i_width, int i_height )
{
ASS_Image *p_tmp;
int i_count;
#ifdef DEBUG_REGION
int64_t i_ck_start = mdate();
#endif
for( p_tmp = p_img_list, i_count = 0; p_tmp != NULL; p_tmp = p_tmp->next )
if( p_tmp->w > 0 && p_tmp->h > 0 )
i_count++;
if( i_count <= 0 )
return 0;
ASS_Image **pp_img = calloc( i_count, sizeof(*pp_img) );
if( !pp_img )
return 0;
for( p_tmp = p_img_list, i_count = 0; p_tmp != NULL; p_tmp = p_tmp->next )
if( p_tmp->w > 0 && p_tmp->h > 0 )
pp_img[i_count++] = p_tmp;
/* */
const int i_w_inc = __MAX( ( i_width + 49 ) / 50, 32 );
const int i_h_inc = __MAX( ( i_height + 99 ) / 100, 32 );
int i_maxh = i_w_inc;
int i_maxw = i_h_inc;
int i_region;
rectangle_t region[i_max_region+1];
i_region = 0;
for( int i_used = 0; i_used < i_count; )
{
int n;
for( n = 0; n < i_count; n++ )
{
if( pp_img[n] )
break;
}
assert( i_region < i_max_region + 1 );
region[i_region++] = r_img( pp_img[n] );
pp_img[n] = NULL; i_used++;
bool b_ok;
do {
b_ok = false;
for( n = 0; n < i_count; n++ )
{
ASS_Image *p_img = pp_img[n];
if( !p_img )
continue;
rectangle_t r = r_img( p_img );
int k;
int i_best = -1;
int i_best_s = INT_MAX;
for( k = 0; k < i_region; k++ )
{
if( !r_overlap( ®ion[k], &r, i_maxw, i_maxh ) )
continue;
int s = r_surface( &r );
if( s < i_best_s )
{
i_best_s = s;
i_best = k;
}
}
if( i_best >= 0 )
{
r_add( ®ion[i_best], &r );
pp_img[n] = NULL; i_used++;
b_ok = true;
}
}
} while( b_ok );
if( i_region > i_max_region )
{
int i_best_i = -1;
int i_best_j = -1;
int i_best_ds = INT_MAX;
/* merge best */
for( int i = 0; i < i_region; i++ )
{
for( int j = i+1; j < i_region; j++ )
{
rectangle_t n = region[i];
r_add( &n, ®ion[j] );
int ds = r_surface( &n ) - r_surface( ®ion[i] ) - r_surface( ®ion[j] );
if( ds < i_best_ds )
{
i_best_i = i;
i_best_j = j;
i_best_ds = ds;
}
}
}
#ifdef DEBUG_REGION
msg_Err( p_spu, "Merging %d and %d", i_best_i, i_best_j );
#endif
if( i_best_j >= 0 && i_best_i >= 0 )
{
r_add( ®ion[i_best_i], ®ion[i_best_j] );
if( i_best_j+1 < i_region )
memmove( ®ion[i_best_j], ®ion[i_best_j+1], sizeof(*region) * ( i_region - (i_best_j+1) ) );
i_region--;
}
}
}
/* */
for( int n = 0; n < i_region; n++ )
p_region[n] = region[n];
#ifdef DEBUG_REGION
int64_t i_ck_time = mdate() - i_ck_start;
msg_Err( p_spu, "ASS: %d objects merged into %d region in %d micros", i_count, i_region, (int)(i_ck_time) );
#endif
free( pp_img );
return i_region;
}
rsexp r_minus (RState* r, rsexp lhs, rsexp rhs)
{
rsexp rhs_neg;
ensure (rhs_neg = r_negate (r, rhs));
return r_add (r, lhs, rhs_neg);
}
