/**********************************************************************/

/* The functions below are obsolete                                   */

/**********************************************************************/

int

FUNCTION (gsl_matrix, get_row) (TYPE (gsl_vector) * v,

                                 const TYPE (gsl_matrix) * m,

                                 const size_t i)

{

  const size_t M = m->size1;

  const size_t N = m->size2;

  const size_t tda = m->tda;

  if (i >= M)

    {

      GSL_ERROR ("row index is out of range", GSL_EINVAL);

    }

  if (v->size != N)

    {

      GSL_ERROR ("matrix row size and vector length are not equal",

                 GSL_EBADLEN);

    }

  {

    ATOMIC *v_data = v->data;

    const ATOMIC *row_data = m->data + MULTIPLICITY * i * tda;

    const size_t stride = v->stride ;

    size_t j;

    for (j = 0; j < N; j++)

      {

        unsigned int k;

        for (k = 0; k < MULTIPLICITY; k++)

          {

            v_data[MULTIPLICITY * stride * j + k] 

              = row_data[MULTIPLICITY * j + k];

          }

      }

  }

  return GSL_SUCCESS;

}

int

FUNCTION (gsl_matrix, get_col) (TYPE (gsl_vector) * v,

                                 const TYPE (gsl_matrix) * m,

                                 const size_t j)

{

  const size_t M = m->size1;

  const size_t N = m->size2;

  const size_t tda = m->tda;

  if (j >= N)

    {

      GSL_ERROR ("column index is out of range", GSL_EINVAL);

    }

  if (v->size != M)

    {

      GSL_ERROR ("matrix column size and vector length are not equal",

                 GSL_EBADLEN);

    }

  {

    ATOMIC *v_data = v->data;

    const ATOMIC *column_data = m->data + MULTIPLICITY * j;

    const size_t stride = v->stride ;

    size_t i;

    for (i = 0; i < M; i++)

      {

        unsigned int k;

        for (k = 0; k < MULTIPLICITY; k++)

          {

            v_data[stride * MULTIPLICITY * i + k] =

              column_data[MULTIPLICITY * i * tda + k];

          }

      }

  }

  return GSL_SUCCESS;

}

int

FUNCTION (gsl_matrix, set_row) (TYPE (gsl_matrix) * m,

                                const size_t i,

                                const TYPE (gsl_vector) * v)

{

  const size_t M = m->size1;

  const size_t N = m->size2;

  const size_t tda = m->tda;

  if (i >= M)

    {

      GSL_ERROR ("row index is out of range", GSL_EINVAL);

    }

  if (v->size != N)

    {

      GSL_ERROR ("matrix row size and vector length are not equal",

                 GSL_EBADLEN);

    }

  {

    const ATOMIC *v_data = v->data;

    ATOMIC *row_data = m->data + MULTIPLICITY * i * tda;

    const size_t stride = v->stride ;

    size_t j;

    for (j = 0; j < N; j++)

      {

        unsigned int k;

        for (k = 0; k < MULTIPLICITY; k++)

          {

            row_data[MULTIPLICITY*j + k] 

              = v_data[MULTIPLICITY * stride * j + k];

          }

      }

  }

  return GSL_SUCCESS;

}

int

FUNCTION (gsl_matrix, set_col) (TYPE (gsl_matrix) * m,

                                const size_t j,

                                const TYPE (gsl_vector) * v)

{

  const size_t M = m->size1;

  const size_t N = m->size2;

  const size_t tda = m->tda;

  if (j >= N)

    {

      GSL_ERROR ("column index is out of range", GSL_EINVAL);

    }

  if (v->size != M)

    {

      GSL_ERROR ("matrix column size and vector length are not equal",

                 GSL_EBADLEN);

    }

  {

    const ATOMIC *v_data = v->data;

    ATOMIC *column_data = m->data + MULTIPLICITY * j;

    const size_t stride = v->stride ;

    size_t i;

    for (i = 0; i < M; i++)

      {

        unsigned int k;

        for (k = 0; k < MULTIPLICITY; k++)

          {

            column_data[MULTIPLICITY * i * tda + k] 

              = v_data[MULTIPLICITY * stride * i + k];

          }

      }

  }

  return GSL_SUCCESS;

}

TYPE (gsl_vector) *

FUNCTION (gsl_vector, alloc_row_from_matrix) (TYPE(gsl_matrix) * m,

                                              const size_t i)

{

  TYPE (gsl_vector) * v;

  const size_t M = m->size1;

  if (i >= M)

    {

      GSL_ERROR_VAL ("row index is out of range", GSL_EINVAL, 0);

    }

  v = (TYPE (gsl_vector) *) malloc (sizeof (TYPE (gsl_vector)));

  if (v == 0)

    {

      GSL_ERROR_VAL ("failed to allocate space for vector struct",

                        GSL_ENOMEM, 0);

    }

  v->data = m->data + MULTIPLICITY * i * m->tda ;

  v->size = m->size2;

  v->stride = 1;

  v->block = 0;

  return v;

}

TYPE (gsl_vector) *

FUNCTION (gsl_vector, alloc_col_from_matrix) (TYPE(gsl_matrix) * m,

                                              const size_t j)

{

  TYPE (gsl_vector) * v;

  const size_t N = m->size2;

  if (j >= N)

    {

      GSL_ERROR_VAL ("column index is out of range", GSL_EINVAL, 0);

    }

  v = (TYPE (gsl_vector) *) malloc (sizeof (TYPE (gsl_vector)));

  if (v == 0)

    {

      GSL_ERROR_VAL ("failed to allocate space for vector struct",

                        GSL_ENOMEM, 0);

    }

  v->data = m->data + MULTIPLICITY * j ;

  v->size = m->size1;

  v->stride = m->tda;

  v->block = 0;

  return v;

}