Exemplo n.º 1
0
int main(void)
{
	unsigned long i,j,msize,*ija;
	float **a,*sa,*ax,*b;
	static float ainit[NP][NP]={
		3.0,0.0,1.0,0.0,0.0,
		0.0,4.0,0.0,0.0,0.0,
		0.0,7.0,5.0,9.0,0.0,
		0.0,0.0,0.0,0.0,2.0,
		0.0,0.0,0.0,6.0,5.0};
	static float x[NP+1]={0.0,1.0,2.0,3.0,4.0,5.0};

	ija=lvector(1,NMAX);
	ax=vector(1,NP);
	b=vector(1,NP);
	sa=vector(1,NMAX);
	a=convert_matrix(&ainit[0][0],1,NP,1,NP);
	sprsin(a,NP,0.5,NMAX,sa,ija);
	msize=ija[1]-2;
	sprstx(sa,ija,x,b,msize);
	for (i=1;i<=msize;i++)
		for (ax[i]=0.0,j=1;j<=msize;j++) ax[i] += a[j][i]*x[j];
	printf("\tReference\tsprstx result\n");
	for (i=1;i<=msize;i++) printf("\t%5.2f\t\t%5.2f\n",ax[i],b[i]);
	free_convert_matrix(a,1,NP,1,NP);
	free_vector(sa,1,NMAX);
	free_vector(b,1,NP);
	free_vector(ax,1,NP);
	free_lvector(ija,1,NMAX);
	return 0;
}
Exemplo n.º 2
0
HYPRE_Int hypre_ParaSailsSetupValues(hypre_ParaSails obj,
                                     HYPRE_DistributedMatrix *distmat, HYPRE_Real filter, HYPRE_Real loadbal,
                                     HYPRE_Int logging)
{
   Matrix *mat;
   hypre_ParaSails_struct *internal = (hypre_ParaSails_struct *) obj;
   HYPRE_Int err;

   mat = convert_matrix(internal->comm, distmat);

   internal->ps->loadbal_beta = loadbal;
   internal->ps->setup_pattern_time = 0.0;

   err = ParaSailsSetupValues(internal->ps, mat, filter);

   if (logging)
      ParaSailsStatsValues(internal->ps, mat);

   MatrixDestroy(mat);

   if (err)
   {
      hypre_error(HYPRE_ERROR_GENERIC);
   }
   return hypre_error_flag;
}
Exemplo n.º 3
0
static inline
int writemm( char const* const filename, matrix_t* AA, char const * const comment, enum sparse_matrix_file_format_t ext ) {
  // make sure we're in the right format (COO) and base 0
  int ret;
  if (( ret = convert_matrix( AA, SM_COO, FIRST_INDEX_ZERO ) ) != 0 )
    return ret;
  assert( AA->format == SM_COO );
  assert( AA->base == FIRST_INDEX_ZERO );

  assert( AA->sym == SM_UNSYMMETRIC );
  assert( AA->data_type == REAL_DOUBLE );

  // copy data into the BeBOP format
  struct sparse_matrix_t A;
  struct coo_matrix_t Acoo;
  A.format = COO;
  A.repr = &Acoo;
  Acoo.m = AA->m;
  Acoo.n = AA->n;
  Acoo.nnz = AA->nz;
  Acoo.II = ( signed int* ) AA->ii;
  Acoo.JJ = ( signed int* ) AA->jj;
  Acoo.val = AA->dd;
  Acoo.index_base = ZERO;
  Acoo.symmetry_type = UNSYMMETRIC;
  Acoo.value_type = REAL;
  Acoo.ownership = USER_DEALLOCATES; // don't let BeBOP blow away our data

  save_sparse_matrix( filename, &A, ext );
  return 0; // success
}
Exemplo n.º 4
0
/*
 * Invert the matrix if x = -1 
 * use gaussj
 */
FMatrix FMatrix::operator^( int x ) const
{
  assert( x == -1 );      /* may want to extend to 2... in the future */

  // check dimension
  assert( XDim() == YDim() );

  // convience variables
  int n = XDim();
  int size = n*n;

  // make a copy of the matrix for nrc routine to work on
  float *copy = new float[ size ];
  memcpy( copy, elem, size*sizeof(float) );

  float **a = convert_matrix( copy, 1, n, 1, n );
  float **b = matrix( 1, n, 1, 1 );
  b[1][1] = 1.0F;
  for( int i = 2; i <= n; i++ )
    b[i][1] = 0.0F;

  gaussj( a, n, b, 1 );

  FMatrix ret( n, n );
  for( int iy = 0; iy < n; iy++ )
    for( int ix = 0; ix < n; ix++ )
      ret.Elem( iy, ix ) = copy[ iy*n + ix ];

  delete [] copy;
  free_matrix( b, 1, n, 1, 1 );
  free_convert_matrix( a, 1, n, 1, n );

  return( ret );
}
Exemplo n.º 5
0
int main(void)
{
	int i,j;
	static float c[NP][NP]=
		{1.0,2.0,0.0,0.0,0.0,
		-2.0,3.0,0.0,0.0,0.0,
		3.0,4.0,50.0,0.0,0.0,
		-4.0,5.0,-60.0,7.0,0.0,
		-5.0,6.0,-70.0,8.0,-9.0};
	float *wr,*wi,**a;

	wr=vector(1,NP);
	wi=vector(1,NP);
	a=convert_matrix(&c[0][0],1,NP,1,NP);
	printf("matrix:\n");
	for (i=1;i<=NP;i++) {
		for (j=1;j<=NP;j++) printf("%12.2f",a[i][j]);
		printf("\n");
	}
	balanc(a,NP);
	elmhes(a,NP);
	hqr(a,NP,wr,wi);
	printf("eigenvalues:\n");
	printf("%11s %16s \n","real","imag.");
	for (i=1;i<=NP;i++) printf("%15f %14f\n",wr[i],wi[i]);
	free_convert_matrix(a,1,NP,1,NP);
	free_vector(wi,1,NP);
	free_vector(wr,1,NP);
	return 0;
}
Exemplo n.º 6
0
// save a .mat matlab matrix
// will store a single matrix (sparse or dense) in a .mat file
// returns 0 on success
static
  int write_mat(char const *const filename,
               matrix_t *const A) {
#ifndef HAVE_MATIO
  return 1;
#else
  const char created_by[] = "created by " PACKAGE_STRING; // "created by Meagre-Crowd x.y.z"
  mat_t* matfp;
  matfp = Mat_Create(filename, created_by);
  if(matfp == NULL)
    return 1; // failed to open file

  // create a matrix convert into
  matvar_t* t = NULL;
  int ret = 0;
  if(A->format == DCOL || A->format == DROW) { // dense
    ret = convert_matrix(A, DCOL, FIRST_INDEX_ZERO); // DROW -> DCOL if DROW
    if(ret != 0)
      ret = 2; // conversion failure

    if(ret == 0) {
      // TODO check for integer overflow in cast from unsigned int -> int
      size_t dims[] = { A->m, A->n };
      t = Mat_VarCreate( "x",
			 MAT_C_DOUBLE,
			 MAT_T_DOUBLE,
			 2, // always at least rank 2
			 dims,
			 A->dd,
			 0 // MAT_F_COMPLEX if complex, could avoid copying data: MAT_F_DONT_COPY_DATA if not sparse
		       );

      if(t == NULL) {
	ret = 3; // failed to malloc data for storage
      }
      else {
	ret = Mat_VarWrite(matfp, t, 1); // compress
	if(ret != 0)
	  ret = 4; // failed data write
      }
    }
  }
  else { // sparse
    assert(0); // do we ever get sparse results?
  }

  Mat_Close(matfp);
  Mat_VarFree(t);
  return ret; // success?
#endif
}
Exemplo n.º 7
0
int main(void)
{
	int i,j,nrot;
	static float c[NP][NP]=
		{5.0,4.3,3.0,2.0,1.0,0.0,-1.0,-2.0,-3.0,-4.0,
		4.3,5.1,4.0,3.0,2.0,1.0,0.0,-1.0,-2.0,-3.0,
		3.0,4.0,5.0,4.0,3.0,2.0,1.0,0.0,-1.0,-2.0,
		2.0,3.0,4.0,5.0,4.0,3.0,2.0,1.0,0.0,-1.0,
		1.0,2.0,3.0,4.0,5.0,4.0,3.0,2.0,1.0,0.0,
		0.0,1.0,2.0,3.0,4.0,5.0,4.0,3.0,2.0,1.0,
		-1.0,0.0,1.0,2.0,3.0,4.0,5.0,4.0,3.0,2.0,
		-2.0,-1.0,0.0,1.0,2.0,3.0,4.0,5.0,4.0,3.0,
		-3.0,-2.0,-1.0,0.0,1.0,2.0,3.0,4.0,5.0,4.0,
		-4.0,-3.0,-2.0,-1.0,0.0,1.0,2.0,3.0,4.0,5.0};
	float *d,**v,**e;

	d=vector(1,NP);
	v=matrix(1,NP,1,NP);
	e=convert_matrix(&c[0][0],1,NP,1,NP);
	printf("****** Finding Eigenvectors ******\n");
	jacobi(e,NP,d,v,&nrot);
	printf("unsorted eigenvectors:\n");
	for (i=1;i<=NP;i++) {
		printf("eigenvalue %3d = %12.6f\n",i,d[i]);
		printf("eigenvector:\n");
		for (j=1;j<=NP;j++) {
			printf("%12.6f",v[j][i]);
			if ((j % 5) == 0) printf("\n");
		}
		printf("\n");
	}
	printf("\n****** Sorting Eigenvectors ******\n\n");
	eigsrt(d,v,NP);
	printf("sorted eigenvectors:\n");
	for (i=1;i<=NP;i++) {
		printf("eigenvalue %3d = %12.6f\n",i,d[i]);
		printf("eigenvector:\n");
		for (j=1;j<=NP;j++) {
			printf("%12.6f",v[j][i]);
			if ((j % 5) == 0) printf("\n");
		}
		printf("\n");
	}
	free_convert_matrix(e,1,NP,1,NP);
	free_matrix(v,1,NP,1,NP);
	free_vector(d,1,NP);
	return 0;
}
Exemplo n.º 8
0
int main(void)
{
	int i,icase,j,*izrov,*iposv;
	static float c[MP][NP]=
		{0.0,1.0,1.0,3.0,-0.5,
		740.0,-1.0,0.0,-2.0,0.0,
		0.0,0.0,-2.0,0.0,7.0,
		0.5,0.0,-1.0,1.0,-2.0,
		9.0,-1.0,-1.0,-1.0,-1.0,
		0.0,0.0,0.0,0.0,0.0};
	float **a;
	static char *txt[NM1M2+1]=
		{" ","x1","x2","x3","x4","y1","y2","y3"};

	izrov=ivector(1,N);
	iposv=ivector(1,M);
	a=convert_matrix(&c[0][0],1,MP,1,NP);
	simplx(a,M,N,M1,M2,M3,&icase,izrov,iposv);
	if (icase == 1)
		printf("\nunbounded objective function\n");
	else if (icase == -1)
		printf("\nno solutions satisfy constraints given\n");
	else {
		printf("\n%11s"," ");
		for (i=1;i<=N;i++)
			if (izrov[i] <= NM1M2) printf("%10s",txt[izrov[i]]);
		printf("\n");
		for (i=1;i<=M+1;i++) {
			if (i == 1 || iposv[i-1] <= NM1M2) {
				if (i > 1)
					printf("%s",txt[iposv[i-1]]);
				else
					printf("  ");
				printf("%10.2f",a[i][1]);
				for (j=2;j<=N+1;j++)
					if (izrov[j-1] <= NM1M2)
						printf("%10.2f",a[i][j]);
				printf("\n");
			}
		}
	}
	free_convert_matrix(a,1,MP,1,NP);
	free_ivector(iposv,1,M);
	free_ivector(izrov,1,N);
	return 0;
}
Exemplo n.º 9
0
int main(void)
{
	int i,j,*indx;
	long idum=(-13);
	float d,*x,**a,**aa;
	static float ainit[NP][NP]=
		{1.0,2.0,3.0,4.0,5.0,
		2.0,3.0,4.0,5.0,1.0,
		1.0,1.0,1.0,1.0,1.0,
		4.0,5.0,1.0,2.0,3.0,
		5.0,1.0,2.0,3.0,4.0};
	static float b[N+1]={0.0,1.0,1.0,1.0,1.0,1.0};

	indx=ivector(1,N);
	x=vector(1,N);
	a=convert_matrix(&ainit[0][0],1,N,1,N);
	aa=matrix(1,N,1,N);
	for (i=1;i<=N;i++) {
		x[i]=b[i];
		for (j=1;j<=N;j++)
			aa[i][j]=a[i][j];
	}
	ludcmp(aa,N,indx,&d);
	lubksb(aa,N,indx,x);
	printf("\nSolution vector for the equations:\n");
	for (i=1;i<=N;i++) printf("%12.6f",x[i]);
	printf("\n");
	/* now phoney up x and let mprove fix it */
	for (i=1;i<=N;i++) x[i] *= (1.0+0.2*ran3(&idum));
	printf("\nSolution vector with noise added:\n");
	for (i=1;i<=N;i++) printf("%12.6f",x[i]);
	printf("\n");
	mprove(a,aa,N,indx,b,x);
	printf("\nSolution vector recovered by mprove:\n");
	for (i=1;i<=N;i++) printf("%12.6f",x[i]);
	printf("\n");
	free_matrix(aa,1,N,1,N);
	free_convert_matrix(a,1,N,1,N);
	free_vector(x,1,N);
	free_ivector(indx,1,N);
	return 0;
}
Exemplo n.º 10
0
/*this function takes as a parameter the Laplacian matrix
  and returns the array of its eigenvalues*/
float eig2Value(float **matrix1){
  int i,j;
  float *d, *r, **v, **e;
  float matrix2[sizeOfLaplacianMatrix][sizeOfLaplacianMatrix];
  
  for (i=0; i<sizeOfLaplacianMatrix; i++)
    for (j=0; j<sizeOfLaplacianMatrix; j++)
      matrix2[i][j] = matrix1[i][j];


  d = vector(1,sizeOfLaplacianMatrix);
  r = vector(1,sizeOfLaplacianMatrix);
  v = matrix(1,sizeOfLaplacianMatrix,1,sizeOfLaplacianMatrix);
  e = convert_matrix(&matrix2[0][0],1,sizeOfLaplacianMatrix,
                     1,sizeOfLaplacianMatrix);


  jacobi(e,sizeOfLaplacianMatrix,d,v,&nrot);
  eigsrt(d,v,sizeOfLaplacianMatrix);
  return d[sizeOfLaplacianMatrix-1];
}
Exemplo n.º 11
0
HYPRE_Int hypre_ParaSailsSetup(hypre_ParaSails obj,
                               HYPRE_DistributedMatrix *distmat, HYPRE_Int sym, HYPRE_Real thresh, HYPRE_Int nlevels,
                               HYPRE_Real filter, HYPRE_Real loadbal, HYPRE_Int logging)
{
   /* HYPRE_Real cost; */
   Matrix *mat;
   hypre_ParaSails_struct *internal = (hypre_ParaSails_struct *) obj;
   HYPRE_Int err;

   mat = convert_matrix(internal->comm, distmat);

   ParaSailsDestroy(internal->ps);

   internal->ps = ParaSailsCreate(internal->comm, 
                                  mat->beg_row, mat->end_row, sym);

   ParaSailsSetupPattern(internal->ps, mat, thresh, nlevels);

   if (logging)
      /* cost = */ ParaSailsStatsPattern(internal->ps, mat);

   internal->ps->loadbal_beta = loadbal;

   err = ParaSailsSetupValues(internal->ps, mat, filter);

   if (logging)
      ParaSailsStatsValues(internal->ps, mat);

   MatrixDestroy(mat);

   if (err)
   {
      hypre_error(HYPRE_ERROR_GENERIC);
   }
   return hypre_error_flag;
}
Exemplo n.º 12
0
HYPRE_Int hypre_ParaSailsSetupPattern(hypre_ParaSails obj,
                                      HYPRE_DistributedMatrix *distmat, HYPRE_Int sym, HYPRE_Real thresh, HYPRE_Int nlevels,
                                      HYPRE_Int logging)
{
   /* HYPRE_Real cost; */
   Matrix *mat;
   hypre_ParaSails_struct *internal = (hypre_ParaSails_struct *) obj;

   mat = convert_matrix(internal->comm, distmat);

   ParaSailsDestroy(internal->ps);

   internal->ps = ParaSailsCreate(internal->comm, 
                                  mat->beg_row, mat->end_row, sym);

   ParaSailsSetupPattern(internal->ps, mat, thresh, nlevels);

   if (logging)
      /* cost = */ ParaSailsStatsPattern(internal->ps, mat);

   MatrixDestroy(mat);

   return hypre_error_flag;
}
Exemplo n.º 13
0
int main(void)
{
	int i,j,k,kk,l,ll,nrot;
	static float a[3][3]=
		{1.0,2.0,3.0,
		2.0,2.0,3.0,
		3.0,3.0,3.0};
	static float b[5][5]=
		{-2.0,-1.0,0.0,1.0,2.0,
		-1.0,-1.0,0.0,1.0,2.0,
		0.0,0.0,0.0,1.0,2.0,
		1.0,1.0,1.0,1.0,2.0,
		2.0,2.0,2.0,2.0,2.0};
	static float c[NP][NP]=
		{5.0,4.3,3.0,2.0,1.0,0.0,-1.0,-2.0,-3.0,-4.0,
		4.3,5.1,4.0,3.0,2.0,1.0,0.0,-1.0,-2.0,-3.0,
		3.0,4.0,5.0,4.0,3.0,2.0,1.0,0.0,-1.0,-2.0,
		2.0,3.0,4.0,5.0,4.0,3.0,2.0,1.0,0.0,-1.0,
		1.0,2.0,3.0,4.0,5.0,4.0,3.0,2.0,1.0,0.0,
		0.0,1.0,2.0,3.0,4.0,5.0,4.0,3.0,2.0,1.0,
		-1.0,0.0,1.0,2.0,3.0,4.0,5.0,4.0,3.0,2.0,
		-2.0,-1.0,0.0,1.0,2.0,3.0,4.0,5.0,4.0,3.0,
		-3.0,-2.0,-1.0,0.0,1.0,2.0,3.0,4.0,5.0,4.0,
		-4.0,-3.0,-2.0,-1.0,0.0,1.0,2.0,3.0,4.0,5.0};
	float *d,*r,**v,**e;
	static int num[4]={0,3,5,10};

	d=vector(1,NP);
	r=vector(1,NP);
	v=matrix(1,NP,1,NP);
	for (i=1;i<=NMAT;i++) {
		if (i == 1) e=convert_matrix(&a[0][0],1,num[i],1,num[i]);
		else if (i == 2) e=convert_matrix(&b[0][0],1,num[i],1,num[i]);
		else if (i == 3) e=convert_matrix(&c[0][0],1,num[i],1,num[i]);
		jacobi(e,num[i],d,v,&nrot);
		printf("matrix number %2d\n",i);
		printf("number of JACOBI rotations: %3d\n",nrot);
		printf("eigenvalues: \n");
		for (j=1;j<=num[i];j++) {
			printf("%12.6f",d[j]);
			if ((j % 5) == 0) printf("\n");
		}
		printf("\neigenvectors:\n");
		for (j=1;j<=num[i];j++) {
			printf("%9s %3d \n","number",j);
			for (k=1;k<=num[i];k++) {
				printf("%12.6f",v[k][j]);
				if ((k % 5) == 0) printf("\n");
			}
			printf("\n");
		}
		/* eigenvector test */
		printf("eigenvector test\n");
		for (j=1;j<=num[i];j++) {
			for (l=1;l<=num[i];l++) {
				r[l]=0.0;
				for (k=1;k<=num[i];k++) {
					if (k > l) {
						kk=l;
						ll=k;
					} else {
						kk=k;
						ll=l;
					}
					r[l] += (e[ll][kk]*v[k][j]);
				}
			}
			printf("vector number %3d\n",j);
			printf("%11s %14s %10s\n",
				"vector","mtrx*vec.","ratio");
			for (l=1;l<=num[i];l++)
				printf("%12.6f %12.6f %12.6f\n",
					v[l][j],r[l],r[l]/v[l][j]);
		}
		printf("press RETURN to continue...\n");
		(void) getchar();
		free_convert_matrix(e,1,num[i],1,num[i]);
	}
	free_matrix(v,1,NP,1,NP);
	free_vector(r,1,NP);
	free_vector(d,1,NP);
	return 0;
}
Exemplo n.º 14
0
static int
PySip_init(
    PySip* self,
    PyObject* args,
    /*@unused@*/ PyObject* kwds) {

  PyObject*      py_a     = NULL;
  PyObject*      py_b     = NULL;
  PyObject*      py_ap    = NULL;
  PyObject*      py_bp    = NULL;
  PyObject*      py_crpix = NULL;
  PyArrayObject* a        = NULL;
  PyArrayObject* b        = NULL;
  PyArrayObject* ap       = NULL;
  PyArrayObject* bp       = NULL;
  PyArrayObject* crpix    = NULL;
  double*        a_data   = NULL;
  double*        b_data   = NULL;
  double*        ap_data  = NULL;
  double*        bp_data  = NULL;
  unsigned int   a_order  = 0;
  unsigned int   b_order  = 0;
  unsigned int   ap_order = 0;
  unsigned int   bp_order = 0;
  int            status   = -1;

  if (!PyArg_ParseTuple(args, "OOOOO:Sip.__init__",
                        &py_a, &py_b, &py_ap, &py_bp, &py_crpix)) {
    return -1;
  }

  if (convert_matrix(py_a, &a, &a_data, &a_order) ||
      convert_matrix(py_b, &b, &b_data, &b_order) ||
      convert_matrix(py_ap, &ap, &ap_data, &ap_order) ||
      convert_matrix(py_bp, &bp, &bp_data, &bp_order)) {
    goto exit;
  }

  crpix = (PyArrayObject*)PyArray_ContiguousFromAny(py_crpix, PyArray_DOUBLE,
                                                    1, 1);
  if (crpix == NULL) {
    goto exit;
  }

  if (PyArray_DIM(crpix, 0) != 2) {
    PyErr_SetString(PyExc_ValueError, "CRPIX wrong length");
    goto exit;
  }

  status = sip_init(&self->x,
                    a_order, a_data,
                    b_order, b_data,
                    ap_order, ap_data,
                    bp_order, bp_data,
                    PyArray_DATA(crpix));

 exit:
  Py_XDECREF(a);
  Py_XDECREF(b);
  Py_XDECREF(ap);
  Py_XDECREF(bp);
  Py_XDECREF(crpix);

  if (status == 0) {
    return 0;
  } else if (status == -1) {
    /* Exception already set */
    return -1;
  } else {
    wcserr_to_python_exc(self->x.err);
    return -1;
  }
}
Exemplo n.º 15
0
int main(void)
{
	unsigned long i,j,k,*ija,*ijb,*ijbt,*ijc;
	float *sa,*sb,*sbt,*sc,**a,**b,**c,**ab;
	static float ainit[NP][NP]={
		1.0,0.5,0.0,0.0,0.0,
		0.5,2.0,0.5,0.0,0.0,
		0.0,0.5,3.0,0.5,0.0,
		0.0,0.0,0.5,4.0,0.5,
		0.0,0.0,0.0,0.5,5.0};
	static float binit[NP][NP]={
		1.0,1.0,0.0,0.0,0.0,
		1.0,2.0,1.0,0.0,0.0,
		0.0,1.0,3.0,1.0,0.0,
		0.0,0.0,1.0,4.0,1.0,
		0.0,0.0,0.0,1.0,5.0};

	ija=lvector(1,NMAX);
	ijb=lvector(1,NMAX);
	ijbt=lvector(1,NMAX);
	ijc=lvector(1,NMAX);
	sa=vector(1,NMAX);
	sb=vector(1,NMAX);
	sbt=vector(1,NMAX);
	sc=vector(1,NMAX);
	c=matrix(1,NP,1,NP);
	ab=matrix(1,NP,1,NP);
	a=convert_matrix(&ainit[0][0],1,NP,1,NP);
	b=convert_matrix(&binit[0][0],1,NP,1,NP);
	sprsin(a,NP,0.5,NMAX,sa,ija);
	sprsin(b,NP,0.5,NMAX,sb,ijb);
	sprstp(sb,ijb,sbt,ijbt);
	/* specify tridiagonal output, using fact that a is tridiagonal */
	for (i=1;i<=ija[ija[1]-1]-1;i++) ijc[i]=ija[i];
	sprspm(sa,ija,sbt,ijbt,sc,ijc);
	for (i=1;i<=NP;i++) {
		for (j=1;j<=NP;j++) {
			ab[i][j]=0.0;
			for (k=1;k<=NP;k++) {
				ab[i][j]=ab[i][j]+a[i][k]*b[k][j];
			}
		}
	}
	printf("Reference matrix:\n");
	for (i=1;i<=NP;i++) {
		for (j=1;j<=NP;j++) printf("%5.2f\t",ab[i][j]);
		printf("\n");
	}
	printf("sprspm matrix (should show only tridiagonals):\n");
	for (i=1;i<=NP;i++) for (j=1;j<=NP;j++) c[i][j]=0.0;
	for (i=1;i<=NP;i++) {
		c[i][i]=sc[i];
		for (j=ijc[i];j<=ijc[i+1]-1;j++) c[i][ijc[j]]=sc[j];
	}
	for (i=1;i<=NP;i++) {
		for (j=1;j<=NP;j++) printf("%5.2f\t",c[i][j]);
		printf("\n");
	}
	free_convert_matrix(b,1,NP,1,NP);
	free_convert_matrix(a,1,NP,1,NP);
	free_matrix(ab,1,NP,1,NP);
	free_matrix(c,1,NP,1,NP);
	free_vector(sc,1,NMAX);
	free_vector(sbt,1,NMAX);
	free_vector(sb,1,NMAX);
	free_vector(sa,1,NMAX);
	free_lvector(ijc,1,NMAX);
	free_lvector(ijbt,1,NMAX);
	free_lvector(ijb,1,NMAX);
	free_lvector(ija,1,NMAX);
	return 0;
}
Exemplo n.º 16
0
/* The encoder doesn't know anything about interlacing, the halve height
 * needs to be passed and the double rowstride. Which field gets encoded
 * is decided by what buffers are passed to mjpeg_encode_frame */
jpeg_enc_t *jpeg_enc_init(int w, int h, int y_psize, int y_rsize,
                          int u_psize, int u_rsize, int v_psize, int v_rsize,
                          int cu, int q, int b) {
    jpeg_enc_t *j;
    int i = 0;
    mp_msg(MSGT_VO, MSGL_V, "JPEnc init: %dx%d %d %d %d %d %d %d\n",
           w, h, y_psize, y_rsize, u_psize,
           u_rsize, v_psize, v_rsize);

    j = av_malloc(sizeof(jpeg_enc_t));
    if (j == NULL) return NULL;

    j->s = av_malloc(sizeof(MpegEncContext));
    memset(j->s,0x00,sizeof(MpegEncContext));
    if (j->s == NULL) {
        av_free(j);
        return NULL;
    }

    /* info on how to access the pixels */
    j->y_ps = y_psize;
    j->u_ps = u_psize;
    j->v_ps = v_psize;
    j->y_rs = y_rsize;
    j->u_rs = u_rsize;
    j->v_rs = v_rsize;

    j->s->width = w;
    j->s->height = h;
    j->s->qscale = q;

    j->s->out_format = FMT_MJPEG;
    j->s->intra_only = 1;
    j->s->encoding = 1;
    j->s->pict_type = I_TYPE;
    j->s->y_dc_scale = 8;
    j->s->c_dc_scale = 8;

    //FIXME j->s->mjpeg_write_tables = 1;
    j->s->mjpeg_vsample[0] = 1;
    j->s->mjpeg_vsample[1] = 1;
    j->s->mjpeg_vsample[2] = 1;
    j->s->mjpeg_hsample[0] = 2;
    j->s->mjpeg_hsample[1] = 1;
    j->s->mjpeg_hsample[2] = 1;

    j->cheap_upsample = cu;
    j->bw = b;

    /* if libavcodec is used by the decoder then we must not
     * initialize again, but if it is not initialized then we must
     * initialize it here. */
    if (!avcodec_inited) {
        /* we need to initialize libavcodec */
        avcodec_init();
        avcodec_register_all();
        avcodec_inited=1;
    }

    if (ff_mjpeg_encode_init(j->s) < 0) {
        av_free(j->s);
        av_free(j);
        return NULL;
    }

    /* alloc bogus avctx to keep MPV_common_init from segfaulting */
    j->s->avctx = calloc(sizeof(*j->s->avctx), 1);
    /* Set up to encode mjpeg */
    j->s->avctx->codec_id = CODEC_ID_MJPEG;

    /* make MPV_common_init allocate important buffers, like s->block */
    j->s->avctx->thread_count = 1;

    if (MPV_common_init(j->s) < 0) {
        av_free(j->s);
        av_free(j);
        return NULL;
    }

    /* correct the value for sc->mb_height */
    j->s->mb_height = j->s->height/8;
    j->s->mb_intra = 1;

    j->s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
    for (i = 1; i < 64; i++)
        j->s->intra_matrix[i] = av_clip_uint8(
                                    (ff_mpeg1_default_intra_matrix[i]*j->s->qscale) >> 3);
    convert_matrix(j->s, j->s->q_intra_matrix, j->s->q_intra_matrix16,
                   j->s->intra_matrix, j->s->intra_quant_bias, 8, 8);
    return j;
}
Exemplo n.º 17
0
/**
 * \brief initialize mjpeg encoder
 *
 * This routine is to set up the parameters and initialize the mjpeg encoder.
 * It does all the initializations needed of lower level routines.
 * The formats accepted by this encoder is YUV422P and YUV420
 *
 * \param w width in pixels of the image to encode, must be a multiple of 16
 * \param h height in pixels of the image to encode, must be a multiple of 8
 * \param y_rsize size of each plane row Y component
 * \param y_rsize size of each plane row U component
 * \param v_rsize size of each plane row V component
 * \param cu "cheap upsample". Set to 0 for YUV422 format, 1 for YUV420 format
 *           when set to 1, the encoder will assume that there is only half th
 *           number of rows of chroma information, and every chroma row is
 *           duplicated.
 * \param q quality parameter for the mjpeg encode. Between 1 and 20 where 1
 *	    is best quality and 20 is the worst quality.
 * \param b monochrome flag. When set to 1, the mjpeg output is monochrome.
 *          In that case, the colour information is omitted, and actually the
 *          colour planes are not touched.
 *
 * \returns an appropriately set up jpeg_enc_t structure
 *
 * The actual plane buffer addreses are passed by jpeg_enc_frame().
 *
 * The encoder doesn't know anything about interlacing, the halve height
 * needs to be passed and the double rowstride. Which field gets encoded
 * is decided by what buffers are passed to mjpeg_encode_frame()
 */
static jpeg_enc_t *jpeg_enc_init(int w, int h, int y_rsize,
			  int u_rsize, int v_rsize,
		int cu, int q, int b) {
	jpeg_enc_t *j;
	int i = 0;
	VERBOSE("JPEG encoder init: %dx%d %d %d %d cu=%d q=%d bw=%d\n",
			w, h, y_rsize, u_rsize, v_rsize, cu, q, b);

	j = av_mallocz(sizeof(jpeg_enc_t));
	if (j == NULL) return NULL;

	j->s = av_mallocz(sizeof(MpegEncContext));
	if (j->s == NULL) {
		av_free(j);
		return NULL;
	}

	/* info on how to access the pixels */
	j->y_rs = y_rsize;
	j->u_rs = u_rsize;
	j->v_rs = v_rsize;

	j->s->width = w;		// image width and height
	j->s->height = h;
	j->s->qscale = q;		// Encoding quality

	j->s->out_format = FMT_MJPEG;
	j->s->intra_only = 1;		// Generate only intra pictures for jpeg
	j->s->encoding = 1;		// Set mode to encode
	j->s->pict_type = AV_PICTURE_TYPE_I;
	j->s->y_dc_scale = 8;
	j->s->c_dc_scale = 8;

	/*
	 * This sets up the MCU (Minimal Code Unit) number
	 * of appearances of the various component
	 * for the SOF0 table in the generated MJPEG.
	 * The values are not used for anything else.
	 * The current setup is simply YUV422, with two horizontal Y components
	 * for every UV component.
	 */
	//FIXME j->s->mjpeg_write_tables = 1;	// setup to write tables
	j->s->mjpeg_vsample[0] = 1;	// 1 appearance of Y vertically
	j->s->mjpeg_vsample[1] = 1;	// 1 appearance of U vertically
	j->s->mjpeg_vsample[2] = 1;	// 1 appearance of V vertically
	j->s->mjpeg_hsample[0] = 2;	// 2 appearances of Y horizontally
	j->s->mjpeg_hsample[1] = 1;	// 1 appearance of U horizontally
	j->s->mjpeg_hsample[2] = 1;	// 1 appearance of V horizontally

	j->cheap_upsample = cu;
	j->bw = b;

	init_avcodec();

	// Build mjpeg huffman code tables, setting up j->s->mjpeg_ctx
	if (ff_mjpeg_encode_init(j->s) < 0) {
		av_free(j->s);
		av_free(j);
		return NULL;
	}

	/* alloc bogus avctx to keep MPV_common_init from segfaulting */
	j->s->avctx = avcodec_alloc_context();
	if (j->s->avctx == NULL) {
		av_free(j->s);
		av_free(j);
		return NULL;
	}

	// Set some a minimum amount of default values that are needed
	// Indicates that we should generated normal MJPEG
	j->s->avctx->codec_id = AV_CODEC_ID_MJPEG;
	// Which DCT method to use. AUTO will select the fastest one
	j->s->avctx->dct_algo = FF_DCT_AUTO;
	j->s->intra_quant_bias= 1<<(QUANT_BIAS_SHIFT-1); //(a + x/2)/x
	// indicate we 'decode' to jpeg 4:2:2
	j->s->avctx->pix_fmt = PIX_FMT_YUVJ422P;

	j->s->avctx->thread_count = 1;

	/* make MPV_common_init allocate important buffers, like s->block
	 * Also initializes dsputil */
	if (ff_MPV_common_init(j->s) < 0) {
		av_free(j->s);
		av_free(j);
		return NULL;
	}

	/* correct the value for sc->mb_height. MPV_common_init put other
	 * values there */
	j->s->mb_height = j->s->height/8;
	j->s->mb_intra = 1;

	// Init q matrix
	j->s->intra_matrix[0] = ff_mpeg1_default_intra_matrix[0];
	for (i = 1; i < 64; i++)
		j->s->intra_matrix[i] = av_clip_uint8(
			(ff_mpeg1_default_intra_matrix[i]*j->s->qscale) >> 3);

	// precompute matrix
	convert_matrix(j->s, j->s->q_intra_matrix, j->s->q_intra_matrix16,
			j->s->intra_matrix, j->s->intra_quant_bias, 8, 8);

	/* Pick up the selection of the optimal get_pixels() routine
	 * to use, which was done in  MPV_common_init() */
	get_pixels = j->s->dsp.get_pixels;

	return j;
}