dataset.c

spiht for linux this is used to decod and encode vedio i wich all enjoy

    return(0);
  if ((dataset->fileptr == NULL) || (!dataset->access_block_size))
    return(0);

  if (!dataset->num_blocks_accessed)
    {
      dataset->access_block_size = QccMathMin(dataset->access_block_size,
                                              dataset->num_vectors);
      if (QccDatasetReadBlock(dataset))
        {
          QccErrorAddMessage("(QccDatasetReadSlidingBlock): Error calling QccDatasetReadBlock()");
          goto Error;
        }
      dataset->num_blocks_accessed = 1;
    }
  else
    {
      num_vectors_left_to_read = 
        dataset->num_vectors - 
        (dataset->access_block_size + dataset->num_blocks_accessed) + 1;
      for (vector = 0; vector < dataset->access_block_size - 1 ; vector++)
        QccVectorCopy(dataset->vectors[vector],
                      dataset->vectors[vector + 1],
                      dataset->vector_dimension);
      if (num_vectors_left_to_read <= 0)
        {
          if (dataset->access_block_size > 0)
            {
              dataset->access_block_size--;
              QccVectorFree(dataset->vectors[dataset->access_block_size]);
              dataset->vectors[dataset->access_block_size] = NULL;
            }
        }
      else
        for (component = 0; component < dataset->vector_dimension; 
             component++)
          if (QccFileReadDouble(dataset->fileptr,
                                &(dataset->vectors
                                  [dataset->access_block_size - 1]
                                  [component])))
            {
              QccErrorAddMessage("(QccDatasetReadSlidingBlock): Error calling QccFileReadDouble()");
              goto Error;
            }
      dataset->num_blocks_accessed++;
    }

  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  return(return_value);
}


int QccDatasetWriteWholefile(QccDataset *dataset)
{
  if (dataset == NULL)
    return(0);

  dataset->access_block_size = QCCDATASET_ACCESSWHOLEFILE;
  
  if (QccDatasetStartWrite(dataset))
    {
      QccErrorAddMessage("(QccDatasetWriteWholefile): Error calling QccDatasetStartWrite()");
      return(1);
    }
  if (QccDatasetWriteBlock(dataset))
    {
      QccErrorAddMessage("(QccDatasetWriteWholefile): Error calling QccDatasetWriteBlock()");
      return(1);
    }

  QccFileClose(dataset->fileptr);

  return(0);
}


int QccDatasetWriteHeader(QccDataset *dataset)
{
  if (dataset == NULL)
    return(0);
  if (dataset->fileptr == NULL)
    return(0);

  if (QccFileWriteMagicNumber(dataset->fileptr, QCCDATASET_MAGICNUM))
    goto QccErr;

  fprintf(dataset->fileptr, "%d %d\n",
          dataset->num_vectors,
          dataset->vector_dimension);
  if (ferror(dataset->fileptr))
    goto QccErr;

  fprintf(dataset->fileptr, "% 16.9e % 16.9e\n",
          dataset->min_val, dataset->max_val);
  if (ferror(dataset->fileptr))
    goto QccErr;
              
  return(0);

 QccErr:
  QccErrorAddMessage("(QccDatasetWriteHeader): Error writing header to %s",
                     dataset->filename);
  return(1);

}


int QccDatasetStartWrite(QccDataset *dataset)
{
  if (dataset == NULL)
    return(0);

  if ((dataset->fileptr = QccFileOpen(dataset->filename, "w")) == NULL)
    {
      QccErrorAddMessage("(QccDatasetWrite): Error opening %s for writing",
                         dataset->filename);
      return(1);
    }

  if (QccDatasetWriteHeader(dataset))
    {
      QccErrorAddMessage("(QccDatasetWrite): Error writing header to %s",
                         dataset->filename);
      return(1);
    }

  if (QccDatasetAlloc(dataset))
    {
      QccErrorAddMessage("(QccDatasetRead): Error calling QccDatasetAlloc()");
      return(1);
    }
      
  dataset->num_blocks_accessed = 0;

  return(0);
}


int QccDatasetEndWrite(QccDataset *dataset)
{
  if (dataset == NULL)
    return(0);

  QccFileClose(dataset->fileptr);

  QccDatasetFree(dataset);

  return(0);
}


int QccDatasetWriteBlock(QccDataset *dataset)
{
  int vector;
  int component;
  int num_vectors_to_write;

  if (dataset == NULL)
    return(0);
  if ((dataset->fileptr == NULL) || (!dataset->access_block_size))
    return(0);
  if (dataset->vectors == NULL)
    return(0);

  num_vectors_to_write = QccDatasetGetBlockSize(dataset);

  for (vector = 0; vector < num_vectors_to_write; vector++)
    {
      for (component = 0; component < dataset->vector_dimension; component++)
        if (QccFileWriteDouble(dataset->fileptr,
                               dataset->vectors[vector][component]))
          {
            QccErrorAddMessage("(QccDatasetWriteBlock): Error calling QccFileWriteDouble()");
            return(1);
          }
    }

  dataset->num_blocks_accessed++;

  return(0);
}


int QccDatasetSetMaxMinValues(QccDataset *dataset)
{
  int block_size;

  if (dataset == NULL)
    return(0);
  if (dataset->vectors == NULL)
    return(0);

  block_size = QccDatasetGetBlockSize(dataset);

  dataset->min_val =
    QccMatrixMinValue(dataset->vectors,
                           block_size,
                           dataset->vector_dimension);
  dataset->max_val =
    QccMatrixMaxValue(dataset->vectors,
                           block_size,
                           dataset->vector_dimension);

  return(0);
}


double QccDatasetMSE(const QccDataset *dataset1, const QccDataset *dataset2)
{
  double mse = 0.0;
  int vector;
  int block_size;
  int vector_dimension;

  if (dataset1 == NULL)
    return((double)0);
  if (dataset2 == NULL)
    return((double)0);
  if (dataset1->vectors == NULL)
    return((double)0);
  if (dataset2->vectors == NULL)
    return((double)0);

  vector_dimension = dataset1->vector_dimension;
  block_size = QccDatasetGetBlockSize(dataset1);

  if ((dataset2->vector_dimension != vector_dimension) ||
      (QccDatasetGetBlockSize(dataset2) != block_size))
    {
      QccErrorAddMessage("(QccDatasetMSE): %s and %s are not the same size datasets",
                         dataset1->filename, dataset2->filename);
      return((double)-1.0);
    }

  for (vector = 0; vector < block_size; vector++)
    mse += 
      QccVectorSquareDistance(dataset1->vectors[vector],
                              dataset2->vectors[vector],
                              vector_dimension) / vector_dimension;
  return(mse/block_size);
}


int QccDatasetMeanVector(const QccDataset *dataset, QccVector mean)
{
  int vector;
  int vector_dimension;
  int block_size;

  if (dataset == NULL)
    return(0);
  if (mean == NULL)
    return(0);

  if (dataset->vectors == NULL)
    return(0);

  if (dataset->num_vectors <= 0)
    return(0);

  vector_dimension = dataset->vector_dimension;
  block_size = QccDatasetGetBlockSize(dataset);

  if (QccVectorZero(mean, vector_dimension))
    {
      QccErrorAddMessage("(QccDatasetMeanVector): Error calling QccVectorZero()");
      return(1);
    }

  for (vector = 0; vector < block_size; vector++)
    {
      if (QccVectorAdd(mean, dataset->vectors[vector],
                       vector_dimension))
        {
          QccErrorAddMessage("(QccDatasetMeanVector): Error calling QccVectorAdd()");
          return(1);
        }
    }

  if (QccVectorScalarMult(mean, (double)1/block_size,
                          vector_dimension))
    {
      QccErrorAddMessage("(QccDatasetMeanVector): Error calling QccVectorScalarMult()");
      return(1);
    }

  return(0);
}


int QccDatasetCovarianceMatrix(const QccDataset *dataset, QccMatrix covariance)
{
  int return_value;
  QccVector mean = NULL;
  int row, col1, col2;
  int vector_dimension;
  int block_size;

  if (dataset == NULL)
    return(0);
  if (covariance == NULL)
    return(0);

  if (dataset->vectors == NULL)
    return(0);
  if (dataset->num_vectors <= 0)
    return(0);

  vector_dimension = dataset->vector_dimension;
  block_size = QccDatasetGetBlockSize(dataset);

  if ((mean = QccVectorAlloc(vector_dimension)) == NULL)
    {
      QccErrorAddMessage("(QccDatasetCovarianceMatrix): Error calling QccVectorAlloc()");
      goto Error;
    }

  if (QccDatasetMeanVector(dataset, mean))
    {
      QccErrorAddMessage("(QccDatasetCovarianceMatrix): Error calling QccDatasetMeanVector()");
      goto Error;
    }

  if (QccMatrixZero(covariance, vector_dimension, vector_dimension))
    {
      QccErrorAddMessage("(QccDatasetCovarianceMatrix): Error calling QccMatrixZero()");
      goto Error;
    }

  if (block_size > 1)
    {
      for (col1 = 0; col1 < vector_dimension; col1++)
        for (col2 = col1; col2 < vector_dimension; col2++)
          for (row = 0; row < block_size; row++)
            covariance[col2][col1] +=
              (dataset->vectors[row][col1] - mean[col1]) *
              (dataset->vectors[row][col2] - mean[col1]);
      
      for (col1 = 0; col1 < vector_dimension; col1++)
        for (col2 = col1; col2 < vector_dimension; col2++)
          {
            covariance[col2][col1] /= (block_size - 1);
            covariance[col1][col2] = covariance[col2][col1];
          }
    }

  return_value = 0;
  goto Return;
 Error:
  return_value = 1;
 Return:
  QccVectorFree(mean);
  return(return_value);
}


int QccDatasetCalcVectorPowers(const QccDataset *dataset,
                               QccVector vector_power)
{
  int vector_dimension;
  int block_size;
  int vector;
  double norm_value;

  if ((dataset == NULL) || (vector_power == NULL))
    return(0);

  if (dataset->vectors == NULL)
    return(0);

  vector_dimension = dataset->vector_dimension;
  block_size = QccDatasetGetBlockSize(dataset);

  for (vector = 0; vector < block_size; vector++)
    {
      norm_value = QccVectorNorm(dataset->vectors[vector],
                                 vector_dimension);
      vector_power[vector] = norm_value * norm_value;
    }

  return(0);
}