vector.c

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

/*
 * 
 * QccPack: Quantization, compression, and coding libraries
 * Copyright (C) 1997-2009  James E. Fowler
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 * 
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 675 Mass Ave, Cambridge,
 * MA 02139, USA.
 * 
 */


#include "libQccPack.h"


QccVector QccVectorAlloc(int vector_dimension)
{
  QccVector vector;

  if (vector_dimension <= 0)
    return(NULL);

  if ((vector = (QccVector)calloc(vector_dimension, sizeof(double))) == NULL)
    QccErrorAddMessage("(QccVectorAlloc): Error allocating memory");

  return(vector);
}


void QccVectorFree(QccVector vector)
{
  if (vector != NULL)
    QccFree(vector);
}


int QccVectorZero(QccVector vector, int vector_dimension)
{
  int component;

  if ((vector == NULL) || (vector_dimension <= 0))
    return(0);
  for (component = 0; component < vector_dimension; component++)
    vector[component] = 0;

  return(0);
}


QccVector QccVectorResize(QccVector vector,
                          int vector_dimension,
                          int new_vector_dimension)
{
  int index;
  QccVector new_vector = NULL;

  if ((vector_dimension < 0) || (new_vector_dimension < 0))
    return(vector);

  if (new_vector_dimension == vector_dimension)
    return(vector);

  if (vector == NULL)
    {
      vector_dimension = 0;
      if ((new_vector = QccVectorAlloc(new_vector_dimension)) == NULL)
        {
          QccErrorAddMessage("(QccVectorResize): Error calling QccVectorAlloc()");
          return(NULL);
        }
    }
  else
    {
      if ((new_vector = 
           (QccVector)realloc((void *)vector,
                              sizeof(double) * new_vector_dimension)) == NULL)
        {
          QccErrorAddMessage("(QccVectorRealloc): Error reallocating memory");
          return(NULL);
        }
    }
  
  for (index = vector_dimension; index < new_vector_dimension; index++)
    new_vector[index] = 0;

  return(new_vector);
}


double QccVectorMean(const QccVector vector, int vector_dimension)
{
  double mean = 0;
  int component;

  if ((vector == NULL) || (vector_dimension <= 0))
    return((double)0.0);

  for (component = 0; component < vector_dimension; component++)
    mean += vector[component];

  mean /= vector_dimension;

  return(mean);
}


double QccVectorVariance(const QccVector vector, int vector_dimension)
{
  double mean;
  double variance = 0;
  int component;

  if ((vector == NULL) || (vector_dimension <= 0))
    return((double)0.0);

  mean = QccVectorMean(vector, vector_dimension);

  for (component = 0; component < vector_dimension; component++)
    variance += (vector[component] - mean) * (vector[component] - mean);

  variance /= vector_dimension;

  return(variance);
}


int QccVectorAdd(QccVector vector1, const QccVector vector2,
                 int vector_dimension)
{
  int component;

  if ((vector1 == NULL) || (vector2 == NULL) || (vector_dimension <= 0))
    return(0);
  for (component = 0; component < vector_dimension; component++)
    vector1[component] += vector2[component];

  return(0);
}


int QccVectorSubtract(QccVector vector1, const QccVector vector2,
                      int vector_dimension)
{
  int component;

  if ((vector1 == NULL) || (vector2 == NULL) || (vector_dimension <= 0))
    return(0);
  for (component = 0; component < vector_dimension; component++)
    vector1[component] -= vector2[component];
  return(0);
}


int QccVectorScalarMult(QccVector vector, double s, int vector_dimension)
{
  int component;

  if ((vector == NULL) || (vector_dimension <= 0))
    return(0);
  for (component = 0; component < vector_dimension; component++)
    vector[component] *= s;
  return(0);
}


int QccVectorCopy(QccVector vector1, const QccVector vector2,
                  int vector_dimension)
{
  int component;

  if ((vector1 == NULL) || (vector2 == NULL) || (vector_dimension <= 0))
    return(0);

  for (component = 0; component < vector_dimension; component++)
    vector1[component] = vector2[component];

  return(0);
}


double QccVectorNorm(const QccVector vector, int vector_dimension)
{
  int component;
  double squared_norm = 0.0;

  if ((vector == NULL) || (vector_dimension <= 0))
    return(squared_norm);

  for (component = 0; component < vector_dimension; component++)
    squared_norm += vector[component]*vector[component];

  return(sqrt(squared_norm));
}


void QccVectorNormalize(QccVector vector, int vector_dimension)
{
  double norm;

  if ((vector == NULL) || (vector_dimension <= 0))
    return;

  norm = QccVectorNorm(vector, vector_dimension);

  if (norm == 0.0)
    return;

  QccVectorScalarMult(vector, 1/norm, vector_dimension);
}


double QccVectorDotProduct(const QccVector vector1, const QccVector vector2,
                           int vector_dimension)
{
  int component;
  double dot_product = 0.0;

  if ((vector1 == NULL) ||
      (vector2 == NULL) ||
      (vector_dimension <= 0))
    return(0.0);

  for (component = 0; component < vector_dimension; component++)
    dot_product += vector1[component] * vector2[component];

  return(dot_product);
}


double QccVectorAngle(const QccVector vector1,
                      const QccVector vector2,
                      int vector_dimension,
                      int degrees)
{
  double angle = 0.0;
  double dot_product;
  double norm1;
  double norm2;

  if ((vector1 == NULL) ||
      (vector2 == NULL) ||
      (vector_dimension <= 0))
    return(0.0);

  norm1 = QccVectorNorm(vector1, vector_dimension);
  norm2 = QccVectorNorm(vector2, vector_dimension);

  if ((norm1 == 0.0) || (norm2 == 0.0))
    return(0.0);

  dot_product = QccVectorDotProduct(vector1,
                                    vector2,
                                    vector_dimension);

  angle = acos(dot_product / norm1 / norm2);

  if (degrees)
    angle *= (180 / M_PI);

  return(angle);
}


double QccVectorSquareDistance(const QccVector vector1,
                               const QccVector vector2, 
                               int vector_dimension)
{
  double diff, distance = 0.0;
  int component;

  if ((vector1 == NULL) || (vector2 == NULL) || (vector_dimension <= 0))
    return((double)0.0);
  for (component = 0; component < vector_dimension; component++)
    {
      diff = 
        vector1[component] - vector2[component];
      distance += diff*diff;
    }
  return(distance);
}


double QccVectorSumComponents(const QccVector vector, int vector_dimension)
{
  int component;
  double sum = 0.0;

  if (vector == NULL)
    return((double)0.0);

  for (component = 0; component < vector_dimension; component++)
    sum += vector[component];

  return(sum);
}


double QccVectorMaxValue(const QccVector vector, int vector_dimension,
                         int *winner)
{
  int component;
  double max_value = -MAXDOUBLE;
  int max_index = 0;

  if (vector != NULL)
    for (component = 0; component < vector_dimension; component++)
      if (vector[component] > max_value)
        {
          max_value = vector[component];
          max_index = component;
        }

  if (winner != NULL)
    *winner = max_index;

  return(max_value);
}


double QccVectorMinValue(const QccVector vector, int vector_dimension,
                         int *winner)
{
  int component;
  double min_value = MAXDOUBLE;
  int min_index = 0;

  if (vector != NULL)
    for (component = 0; component < vector_dimension; component++)
      if (vector[component] < min_value)
        {
          min_value = vector[component];
          min_index = component;
        }

  if (winner != NULL)
    *winner = min_index;

  return(min_value);
}




int QccVectorPrint(const QccVector vector,
                   int vector_dimension)
{
  int component;

  if (vector == NULL)