예제 #1
0
파일: sorting.c 프로젝트: nhatcher/lie
local void sort_matrix (entry** m,lie_Index n,lie_Index c)
{ if (n>=3)
  { lie_Index i=split_mat(m,n,c);
    sort_matrix(m,i,c); sort_matrix(&m[i+1],n-i-1,c);
  }
  else if (n==2 && (*compare)(m[0],m[1],c)<0) swap_rows(m,m+1);
}
예제 #2
0
  BASKER_INLINE
  int Basker<Int,Entry, Exe_Space>::InitMatrix(Int nrow, Int ncol, Int nnz, 
					       Int *col_ptr,
					       Int *row_idx, Entry *val)
  {
    A.init_matrix("Original Matrix",
		  nrow, ncol, nnz, col_ptr, row_idx, val);
    A.scol = 0;
    A.srow = 0;
    sort_matrix(A);
    matrix_flag = true;
    return 0;
  }//end InitMatrix (int, int , int, int *, int *, entry *)
예제 #3
0
  BASKER_INLINE
  int Basker<Int, Entry, Exe_Space>::Symbolic(Int nrow, Int ncol,
	         Int nnz, Int *col_ptr, Int *row_idx, Entry *val)
  {

    //Init Matrix A.
    if(matrix_flag == BASKER_TRUE)
      {
	printf("YOU CANNOT RERUN SYMBOLIC\n");
	return BASKER_ERROR;
      }
    else
      {
	A.init_matrix("Original Matrix",
		  nrow, ncol, nnz, col_ptr, row_idx, val);
	A.scol = 0;
	A.srow = 0;
	sort_matrix(A);
	matrix_flag = BASKER_TRUE;
      }

    //Init Ordering
    //Always will do btf_ordering
    //This should also call create tree
    if(order_flag == BASKER_TRUE)
      {
	printf("YOU CANNOT RERUN ORDER\n");
	return BASKER_ERROR;
      }
    else
      {
	printf("btf_order called \n");
	//btf_order();
	btf_order2();
	if(btf_tabs_offset != 0)
	  {
	    basker_barrier.init(num_threads, 16, tree.nlvls );
	  }
	order_flag = BASKER_TRUE;
	//printf("btf_order done \n");
      }



    //printf("\n\n+++++++++++++++BREAKER BREAKER++++++++\n\n");

    

    if(symb_flag == BASKER_TRUE)
      {
        printf("YOU CANNOT RERUN SFACTOR\n");
	return BASKER_ERROR;
      }
    else
      {
	sfactor();
	symb_flag = BASKER_TRUE;
      }

    
    
    //printf("\nTEST ALM\n");
    //ALM(0)(0).info();
    //printf("\n");

    
    return 0;
	
  }//end Symbolic()
예제 #4
0
파일: sorting.c 프로젝트: nhatcher/lie
void Qksortmat(matrix* m,cmpfn_tp criterion)
{ compare=set_ordering(criterion,m->ncols,defaultgrp);
  sort_matrix(m->elm,m->nrows,m->ncols);
}
예제 #5
0
  BASKER_INLINE
  int Basker<Int,Entry,Exe_Space>::test_solve()
  {
    ENTRY_1DARRAY  x_known;
    ENTRY_1DARRAY  x;
    ENTRY_1DARRAY  y;


    #ifdef BASKER_DEBUG_SOLVE_RHS
    printf("test_solve called \n");
    printf("Global pivot permuation\n");
    printVec(gperm, gn);
    printf("\n");
    printf("Global pivot permutation inverse\n");
    printVec(gpermi, gn);
    printf("\n");
    #endif


    BASKER_ASSERT(gn > 0, "solve testsolve gn");
    MALLOC_ENTRY_1DARRAY(x_known, gn);
    init_value(x_known, gn , (Entry)1.0);


    //temp
    for(Int i = 0; i < gn; i++)
      {
	//x_known(i) = (Entry)(i+1);
        x_known(i) = (Entry) 1.0;
      }
    //JDB: used for other test
    //permute(x_known, order_csym_array, gn);



    MALLOC_ENTRY_1DARRAY(x, gn);
    init_value(x, gn, (Entry) 0.0);
    BASKER_ASSERT(gm > 0, "solve testsolve gm");
    MALLOC_ENTRY_1DARRAY(y, gm);
    init_value(y, gm, (Entry) 0.0);
    
    if(btf_nblks > 0)
      {
	sort_matrix(BTF_C);
	//printMTX("C_BEFORE_SOLVE.mtx", BTF_C);
      }

    if(Options.btf == BASKER_TRUE)
      {
      
	//printf("btf_tabs_offset: %d ", btf_tabs_offset);
        //printf("btf_nblks: %d \n", btf_nblks);
	if(btf_tabs_offset != 0)
	  {
            //printf("BTF_A spmv\n");
	    spmv(BTF_A, x_known,y);
            if(btf_nblks> 1)
              {
                //printf("btf_B spmv \n");
                spmv(BTF_B, x_known, y);
              }
          }
        if(btf_nblks > 1)
          {
            
            //printf("btf_c spmv \n");
            spmv(BTF_C, x_known, y);
          }
	//return -1;
      }
    else
      {
        //printf("other\n");
	//spmv(BTF_A, x_known,y);
      }
    
    

    
    
    //printf("\n Before Test Points \n");
    //printf("i: %d x: %f y: %f \n", 0, x_known(0), y(0));
    //if(gn > 24)
    //  {
    //   printf("i: %d x: %f y: %f \n", 24, x_known(24), y(24));
    //  }
    
    //pivot permuation
    //printVec("gperm.csc", gpermi, gn);

    for(Int i = 0; i < gn; i++)
      {
        x(gpermi(i)) = y(i);
      }
    for(Int i = 0; i < gn; i++)
      {
        y(i) = x(i);
        x(i) = 0;
      }




    #ifdef BASKER_DEBUG_SOLVE_RHS
    printf("\n\n");
    //printf("Known Solution: \n");
    //for(Int i = 0; i < gn; i++)
    //  {
    //	printf("%f, " , x_known(i));
    //  }
    printf("\n\n");
    printf("RHS: \n");
    for(Int i =0; i < gm; i++)
      {
	printf("%d %f,\n ", i, y(i)); 
      }
    printf("\n\n");
    #endif

    

    if(Options.btf == BASKER_FALSE)
      {
        
        //printf("before serial solve\n");
	if(btf_tabs_offset != 0)
	  {
	    serial_solve(y,x);
	  }
	//printf("After serial solve\n");
	//printf("i: %d x: %f y: %f \n", 0, x(0), y(0));
	//printf("i: %d x: %f y: %f \n", 24, x(24), y(24));
      }
    else
      {
	//A\y -> y
	//serial_btf_solve(y,x);
        //printf("before btf serial solve\n");
	serial_btf_solve(y,x);
        
	//printf("After btf solve\n");
	//printf("i: %d x: %f y: %f \n", 0, x(0), y(0));
	//printf("i: %d x: %f y: %f \n", 24, x(24), y(24));
      }


    Entry diff =0.0;
  
    for(Int i = 0; i < gn; i++)
      {
	diff += (x_known(i) - x(i));
      }
    diff = diff/(Entry) gn;

    #ifdef BASKER_DEBUG_SOLVE_RHS
    printf("\n\n");
    printf("Solve Compare: \n");
    for(Int i = 0; i < gn; i++)
      {
	printf("%d %f %f \n", 
	       i, x_known(i), x(i));
 
      }
    printf("\n\n");
    #endif



    printf("\n Test Points \n");
    printf("i: %d x: %f %f \n", 0, x_known(0), x(0));
    if(gn > 24)
      {
        printf("i: %d x: %f %f \n", 10, x_known(10), x(10));
        printf("i: %d x: %f %f \n", 24, x_known(24), x(24));
      }
    printf("\n");
    printf("TEST_SOLVE: ||x-x||/||x| = %e", diff);
    printf("\n");

    if((diff > -1e-2) && (diff < 1e-2))
      {
        printf("TEST PASSED \n");
      }  

    return 0;
  }//end test_solve
예제 #6
0
  BASKER_INLINE
  int Basker<Int,Entry,Exe_Space>::btf_order()
  {
    //1. Matching ordering on whole matrix
    //currently finds matching and permutes
    //found bottle-neck to work best with circuit problems
    sort_matrix(A);
    //printMTX("A_nonmatch.mtx", A);
    match_ordering(0);
    //printf("DEBUG1: done match\n");
    //for debuging
    sort_matrix(A);
    //printMTX("A_match.mtx", A);
   
    //2. BTF ordering on whole matrix
    // Gets estimate of work on all blocks
    //currently finds btf-hybrid and permutes
    //A -> [BTF_A, BTF_C; 0 , BTF B]


    printf("outter num_threads:%d \n", num_threads);
    MALLOC_INT_1DARRAY(btf_schedule, num_threads+1);
    init_value(btf_schedule, num_threads+1, 0);
    find_btf(A); 

   
    
    if(btf_tabs_offset != 0)
      {

        //  printf("A/B block stuff called\n");
	//3. ND on BTF_A
	//currently finds ND and permute BTF_A
	//Would like to change so finds permuation, 
	//and move into 2D-Structure
	//printMTX("A_BTF_FROM_A.mtx", BTF_A);
	sort_matrix(BTF_A);
	scotch_partition(BTF_A);
    
	//need to do a row perm on BTF_B too
	if(btf_nblks > 1)
	  {
	    permute_row(BTF_B, part_tree.permtab);
	  }
	//needed because  moving into 2D-Structure,
	//assumes sorted columns
	sort_matrix(BTF_A);
	if(btf_nblks > 1)
	  {
	    sort_matrix(BTF_B);
	    sort_matrix(BTF_C);
	  }
	//For debug
	//printMTX("A_BTF_PART_AFTER.mtx", BTF_A);
	
	//4. Init tree structure
	//This reduces the ND ordering into that fits,
	//thread counts
	init_tree_thread();
	

	//5. Permute BTF_A
	//Constrained symamd on A
	INT_1DARRAY cmember;
	MALLOC_INT_1DARRAY(cmember, BTF_A.ncol+1);
	init_value(cmember,BTF_A.ncol+1,(Int) 0);
	for(Int i = 0; i < tree.nblks; ++i)
	  {
	    for(Int j = tree.col_tabs(i); j < tree.col_tabs(i+1); ++j)
	      {
		cmember(j) = i;
	      }
	  }
	//INT_1DARRAY csymamd_perm = order_csym_array;
	MALLOC_INT_1DARRAY(order_csym_array, BTF_A.ncol+1);
	//MALLOC_INT_1DARRAY(csymamd_perm, BTF_A.ncol+1);
	init_value(order_csym_array, BTF_A.ncol+1,(Int) 0);
	//init_value(csymamd_perm, BTF_A.ncol+1,(Int) 0);
	
	csymamd_order(BTF_A, order_csym_array, cmember);
	//csymamd_order(BTF_A, csymamd_perm, cmember);
	
	//permute(BTF_A, csymamd_perm, csymamd_perm);
	permute_col(BTF_A, order_csym_array);
	sort_matrix(BTF_A);
	permute_row(BTF_A, order_csym_array);
	sort_matrix(BTF_A);
	//printMTX("A_BTF_AMD.mtx", BTF_A);
	
	
	if(btf_nblks > 1)
	  {
	    permute_row(BTF_B, order_csym_array);
	    sort_matrix(BTF_B);
	    //printMTX("B_BTF_AMD.mtx", BTF_B);
	    sort_matrix(BTF_C);
	    //printMTX("C_BTF_AMD.mtx", BTF_C);
	  }
    
    
	//6. Move to 2D Structure
	//finds the shapes for both view and submatrices,
	//need to be changed over to just submatrices
	matrix_to_views_2D(BTF_A);
	//finds the starting point of A for submatrices
	find_2D_convert(BTF_A);
	//now we can fill submatrices
        #ifdef BASKER_KOKKOS
	kokkos_order_init_2D<Int,Entry,Exe_Space> iO(this);
	Kokkos::parallel_for(TeamPolicy(num_threads,1), iO);
	Kokkos::fence();
        #else
	//Comeback
        #endif

	//printMTX("BTF_A.mtx", BTF_A); 
	
      }//if btf_tab_offset == 0

    
    if(btf_nblks > 1)
      {
	sort_matrix(BTF_C);
	//printMTX("C_TEST.mtx", BTF_C);
	//Permute C

	MALLOC_INT_1DARRAY(order_c_csym_array, BTF_C.ncol+1);
	init_value(order_c_csym_array, BTF_C.ncol+1,(Int) 0);
	
	printf("BEFORE \n");

	//csymamd_order(BTF_C, order_c_csym_array, cmember);

	blk_amd(BTF_C, order_c_csym_array);

	printf("After perm\n");
	
	permute_col(BTF_C, order_c_csym_array);
	sort_matrix(BTF_C);
	permute_row(BTF_C, order_c_csym_array);
	sort_matrix(BTF_C);

	if(btf_tabs_offset != 0)
	  {
	    permute_col(BTF_B, order_c_csym_array);
	    sort_matrix(BTF_B);
	    //printMTX("BTF_B.mtx", BTF_B);
	  }

	//printMTX("BTF_C.mtx", BTF_C);

      }
  
    
    //printf("Done with ordering\n");
    
    return 0;
  }//end btf_order
예제 #7
0
  BASKER_INLINE
  int Basker<Int,Entry, Exe_Space>::find_btf2
  (
   BASKER_MATRIX &M
  )
  {
    Int          nblks = 0;

    strong_component(M,nblks,order_btf_array,btf_tabs);

    btf_nblks = nblks;

    btf_flag = BASKER_TRUE;

    //#ifdef BASKER_DEBUG_ORDER_BTF
    printf("BTF nblks returned: %d \n", nblks);
    //BASKER_ASSERT(nblks>1, "NOT ENOUGH BTF BLOCKS");
    //#endif

    #ifdef BASKER_DEBUG_ORDER_BTF
    if(nblks<2)
      {
	printf("BTF did not find enough blks\n");
      }
    #endif


    //#ifdef BASKER_DEBUG_ORDER_BTF
    /*
    printf("\nBTF perm: \n");
    for(Int i=0; i <M.nrow; i++)
      {
	printf("%d, ", order_btf_array(i));
	//printf("%d, ", btf_perm(i));
      }
    */
    printf("num_threads: %d \n", num_threads);
    printf("\n\nBTF tabs: \n");
    for(Int i=0; i < nblks+1; i++)
      {
	printf("%d, ", btf_tabs(i));
      }
    printf("\n");
    // #endif

    permute_col(M, order_btf_array);
    permute_row(M, order_btf_array);

    MALLOC_INT_1DARRAY(order_blk_amd_array, M.ncol);
    init_value(order_blk_amd_array, M.ncol, (Int)0);
    MALLOC_INT_1DARRAY(btf_blk_nnz, nblks+1);
    init_value(btf_blk_nnz, nblks+1, (Int) 0);
    MALLOC_INT_1DARRAY(btf_blk_work, nblks+1);
    init_value(btf_blk_work, nblks+1, (Int) 0);


    //Find AMD blk ordering, get nnz, and get work
    btf_blk_amd( M, order_blk_amd_array,
		 btf_blk_nnz, btf_blk_work);


    #ifdef BASKER_DEBUG_ORDER_BTF
    printf("blk_perm:\n");
    for(Int i = 0; i < M.ncol; i++)
      {
	printf("(%d,%d) ", i, order_blk_amd_array(i));
      }
    printf("\n");
    printf("id/blk_size/blk_nnz/work: \n");
    for(Int i = 0; i < nblks; i++)
      {
	printf("(%d, %d, %d, %d) ", i,
	       btf_tabs(i+1)-btf_tabs(i), 
	       btf_blk_nnz(i), btf_blk_work(i));
      }
    printf("\n");
    #endif

    //printMTX("A_BEFORE.mtx", M);
    //printVec("AMD.txt", order_blk_amd_array, M.ncol);
    

    permute_col(M, order_blk_amd_array);
    permute_row(M, order_blk_amd_array);
    sort_matrix(M);

    //changed col to row, error.
    //print to see issue
    //printMTX("A_AMD.mtx", M);
    
       
    break_into_parts2(M, nblks, btf_tabs);

    //find schedule
    find_btf_schedule(M, nblks, btf_tabs);


    #ifdef BASKER_DEBUG_ORDER_BTF
    printf("------------BTF CUT: %d --------------\n", 
	   btf_tabs(btf_tabs_offset));
    #endif

    return 0;
  }//end find BTF(nnz)
예제 #8
0
  BASKER_INLINE
  int Basker<Int,Entry,Exe_Space>::Factor(Int nrow, Int ncol,
	        Int nnz, Int *col_ptr, Int *row_idx, Entry *val) 
  {
    int err = 0;

    if (Options.verbose == BASKER_TRUE)
    {
      std::cout << "Basker Factor Called" << std::endl;
      std::cout << "Matrix: " << nrow << " " << ncol << " " << nnz << std::endl;
    }

    /*
       int err = A.copy_values(nrow, ncol, nnz, col_ptr, 
       row_idx, val);
    */

    if((Options.same_pattern == BASKER_TRUE) && (Options.no_pivot == BASKER_FALSE))
    {
      printf("Warning: Same Pattern will not allow pivoting\n");
      Options.no_pivot = BASKER_TRUE;
    }


    if(Options.transpose == BASKER_FALSE)
    {
      //printf("=======NO TRANS=====\n");
      //A.init_matrix("Original Matrix",
      //	      nrow, ncol, nnz, col_ptr, row_idx, val);
      //A.scol = 0;
      //A.srow = 0;
      A.copy_values(nrow, ncol, nnz, col_ptr,
          row_idx, val);
      //printf("Copy done\n");
      //printMTX("A_LOAD.mtx", A);
    }
    else
    {
      //printf("======TRANS=====\n");
      //Will transpose and put in A using little extra
      matrix_transpose(0, 
          nrow,
          0, 
          ncol,
          nnz,
          col_ptr,
          row_idx,
          val,
          A);
    }
    sort_matrix(A);
    if(Options.verbose_matrix_out == BASKER_TRUE)
    {
      printMTX("A_Factor.mtx", A);
    }

    matrix_flag = BASKER_TRUE;

    if(err == BASKER_ERROR)
    {
      return BASKER_ERROR;
    }
    //err = sfactor_copy();
    err = sfactor_copy2();
    if (Options.verbose == BASKER_TRUE)
    {
      printf("Basker Copy Structure Done \n");
    }

    //printf("Done with sfactor_copy: %d \n", err);
    if(err == BASKER_ERROR)
    {
      return BASKER_ERROR;
    }
    //printf("before notoken\n");

    //Kokkos::Impl::Timer timer;

    if(Options.incomplete == BASKER_FALSE)    
    {
      err = factor_notoken(0);
      //printf("Notoken called\n");
    }
    else
    {
      err = factor_inc_lvl(0);
    }
    if(err == BASKER_ERROR)
    {
      return BASKER_ERROR;
    }

    if(Options.verbose == BASKER_TRUE)
    {
      printf("Basker Factor Done \n");
    }

    /*
       std::cout << "Raw Factor Time: "
       << timer.seconds()
       << std::endl;
       */

    //DEBUG_PRINT();

    // NDE
    MALLOC_ENTRY_1DARRAY(x_view_ptr_copy, gn); //used in basker_solve_rhs - move alloc
    MALLOC_ENTRY_1DARRAY(y_view_ptr_copy, gm);
    MALLOC_INT_1DARRAY(perm_inv_comp_array , gm); //y
    MALLOC_INT_1DARRAY(perm_comp_array, gn); //x

    MALLOC_INT_1DARRAY(perm_comp_iworkspace_array, gn);
    MALLOC_ENTRY_1DARRAY(perm_comp_fworkspace_array, gn);
    permute_composition_for_solve();

    factor_flag = BASKER_TRUE;

    return 0;
  }//end Factor()
예제 #9
0
  BASKER_INLINE
  int Basker<Int, Entry, Exe_Space>::Symbolic(Int nrow, Int ncol,
	         Int nnz, Int *col_ptr, Int *row_idx, Entry *val)
  {
    // printf("befor symbolic\n");
    if(Options.verbose == BASKER_TRUE)
    {
      std::cout << "Basker Symbolic" << std::endl;
      std::cout << "Matrix: " << nrow << " " << ncol << " " << nnz << std::endl;
    }
    //Init Matrix A.
    if(matrix_flag == BASKER_TRUE)
    {
      printf("YOU CANNOT RERUN SYMBOLIC\n");
      return BASKER_ERROR;
    }
    else
    {
      //Kokkos::Impl::Timer timer_move;

      if(Options.transpose == BASKER_FALSE)
      {
        //printf("=======NO TRANS=====\n");
        A.init_matrix("Original Matrix",
            nrow, ncol, nnz, col_ptr, row_idx, val);
        A.scol = 0;
        A.srow = 0;

      }
      else
      {
        //printf("======TRANS=====\n");
        //Will transpose and put in A using little extra
        matrix_transpose(0, nrow,
            0, ncol,
            nnz,
            col_ptr,
            row_idx,
            val,
            A);
      }
      sort_matrix(A);

      if(Options.verbose == BASKER_TRUE)
      {
        printf("Basker Matrix Loaded \n");
      }

      if(Options.verbose_matrix_out == BASKER_TRUE)
      {
        printMTX("A_Symbolic.mtx", A);
      }

      matrix_flag = BASKER_TRUE;

      //std::cout << "Transpose A: " << timer_move.seconds()
      //	  << std::endl;
    }

    //Init Ordering
    //Always will do btf_ordering
    //This should also call create tree
    if(order_flag == BASKER_TRUE)
    {
      printf("YOU CANNOT RERUN ORDER\n");
      return BASKER_ERROR;
    }
    else
    {
      //printf("btf_order called \n");
      //btf_order();

      Kokkos::Impl::Timer timer_order;
      /*
         if(Options.incomplete == BASKER_TRUE)
         {
           order_incomplete();
         }
         else
         {
           btf_order2();
         }
      */
      btf_order2();

      if(Options.verbose == BASKER_TRUE)
      {
        printf("Basker Ordering Found \n");
      }

      //if(btf_tabs_offset != 0)
      if((Options.btf == BASKER_TRUE) && (btf_tabs_offset != 0))
      {
        basker_barrier.init(num_threads, 16, tree.nlvls );
      }
      order_flag = BASKER_TRUE;

      if(Options.verbose == BASKER_TRUE)
      {
        printf("Basker P2P Thread Barriers Init\n");
      }

      //std::cout << "Time Order/Init arrays " 
      //	  << timer_order.seconds()
      //	  << std::endl;

      //printf("btf_order done \n");
    }

    //printf("\n\n+++++++++++++++BREAKER BREAKER++++++++\n\n");

    if(symb_flag == BASKER_TRUE)
    {
      printf("YOU CANNOT RERUN SFACTOR\n");
      return BASKER_ERROR;
    }
    else
    {
      if(Options.incomplete == BASKER_FALSE)
      {
        sfactor();
      }
      else
      {
        sfactor_inc();
      }

      if(Options.verbose == BASKER_TRUE)
      {
        printf("Basker Nonzero Counts Found \n");
      }
      symb_flag = BASKER_TRUE;
    }


    if(Options.verbose == BASKER_TRUE)
    {
      printf("Basker Symbolic Done \n");
    }

    //printf("\nTEST ALM\n");
    //ALM(0)(0).info();
    //printf("\n");

    return 0;

  }//end Symbolic()
예제 #10
0
//unsigned long long fm_elim(int rows, int cols, int** A, int* c)
unsigned long long fm_elim(Arena* arena, int rows, int cols, fix_p** A, fix_p* c)
{
//1
    int r;
    int s;
    fix_p** t;
    fix_p* q;
    int n1;
    int n2;
    int i;
    int j;
    long br;
    long Br;
    int qj_lt_0;
    int s_p;
    fix_p** old_t;
    fix_p* old_q;
    int k;
    int l;
    int curr_row;

    fix_p tjr;
    fix_p* qj;
    fix_p* tj;

    r = cols;
    s = rows;

    t = check_out_matrix_copy(arena, A, rows, cols);
    q = check_out_vector_copy(arena, c, rows);
    
    printf("\n\nNew system\n");
    // print_system(s, r, t, q);
    // printf("\n");
    

    while(1){
    //2
        sort_matrix(s, r-1, &n1, &n2, t, q);

        printf("s: %d\nn1: %d\nn2: %d\n", s, n1, n2);
        printf("\n");
        printf("After sort:\n");
        print_system(s, r, t, q);
        printf("\n");

    // 3
    
    qj = q;
    for(j = 0; j < n2; j++){
        tjr = fix_p_div(65536, t[j][r-1]); //65536 = 1
        *qj = fix_p_mul(*qj, tjr);
        qj++;
        tj = t[j];
        for(i = 0; i < r; i++){
            *tj = fix_p_mul(*tj, tjr);
            tj++;
        }
    }

    printf("After div:\n");
    print_system(s, r, t, q);
    printf("\n");

    

//     printf("br: %f\tBr: %f\n", fix_p2double(br), fix_p2double(Br));
// printf("r == %d\n", r);
    // 5
    if(r == 1){
        // printf("r == 1\n");

        // 4
        br = 0;
    // printf("brs:\n");
        if(n2 > n1){
            for(j = n1; j < n2; j++){
                if(q[j] > br){
                    br = q[j];
                }
            }
        }else{
            br = LONG_MIN;
        }

        Br = LONG_MAX;
    // printf("\nBrs:\n");
        if(n1 > 0){
            for(j = 0; j < n1; j++){
                if(q[j] < Br){
                    Br = q[j];
                }
            }
        }else{
            Br = LONG_MAX;
        }

        qj_lt_0 = 0;
        for(i = n2; i < s; i++){
            if(q[i] < 0){
                qj_lt_0 = 1;
                break;
            }
        }


        // printf("br > Br: %d\nqj_lt_0: %d\n", br > Br, qj_lt_0);

        if(br > Br || qj_lt_0){
            // printf("br > Br || qj_lt_0\n");
            hand_back_matrix(arena, &t);
            hand_back_vector(arena, &q);
            return 0;
        }else{
            // printf("not br > Br || qj_lt_0\n");
            hand_back_matrix(arena, &t);
            hand_back_vector(arena, &q);
            return 1;
        }
    }

    // 6
    s_p = s - n2 + n1 * (n2 - n1);
    if(s_p == 0){
        // printf("s_p == 0\n");

        // print_system(s, r, t, q);

        for(j = 0; j < n1; j++){
            fix_p sum = 0;
            for(i = 0; i < r; i++){
                sum += t[j][i];
            }
            if(sum != q[j]){
                // printf("i:%d j:%d sum:%f q:%f\n", i,j,fix_p2double(sum),fix_p2double(q[j]));
                // free_up_t_q(s,t,q);
                hand_back_matrix(arena, &t);
                hand_back_vector(arena, &q);
                return 0;
            }
            // printf("+ %f\n",fix_p2double(q[j]));
        }

        hand_back_matrix(arena, &t);
        hand_back_vector(arena, &q);
        return 1;
    }

        // printf("\n");

    // 7
    old_t = t;
    old_q = q;
    // t = init_matrix(s_p, r - 1);
    // q = init_vector(s_p);
    t = check_out_matrix(arena, s_p);
    q = check_out_vector(arena, s_p);

        // printf("s_p: %d\n", s_p);

    // printf("\n");
    //     print_system(s, r, old_t, old_q);
    //     printf("\n");

    curr_row = 0;
    fix_p old_qk;
    fix_p* old_tk;
    fix_p* old_tl;
    for(k = 0; k < n1; k++){
        old_qk = old_q[k];
        old_tk = old_t[k];
        for(l = n1; l < n2; l++){
            old_tl = old_t[l];
            for(i = 0; i < r-1; i++){
                // printf("%ld\n",t[curr_row][i]);
                // printf("k:%d i:%d l:%d\n", k ,i, l);
                t[curr_row][i] = old_tk[i] - old_tl[i];
            }
            q[curr_row] = old_qk - old_q[l];
            curr_row++;
        }
    }

    for(j = n2; j < s; j++){
        for(i = 0; i < r-1; i++){
            t[curr_row][i] = old_t[j][i];
        }
        q[curr_row] = old_q[j];
        curr_row++;
    }

    hand_back_matrix(arena, &old_t);
    hand_back_vector(arena, &old_q);

    r = r - 1;
    s = s_p;

    // printf("\n");
    // print_system(s, r, t, q);
    // printf("\n");

}


}