#include <string.h>
#include "size.h"
#include "matmult.h"

static void naive_multiply_mat(int, int [MAX_SIZE][MAX_SIZE],
			       int [MAX_SIZE][MAX_SIZE],
			       int [MAX_SIZE][MAX_SIZE]);
static void rep_multiply_mat(int, int [MAX_SIZE][MAX_SIZE],
			     int [MAX_SIZE][MAX_SIZE],
			     int [MAX_SIZE][MAX_SIZE]);
static void sparse_multiply_mat(int, int [MAX_SIZE][MAX_SIZE],
				int [MAX_SIZE][MAX_SIZE],
				int [MAX_SIZE][MAX_SIZE]);
static void rtcg_multiply_mat(int, int [MAX_SIZE][MAX_SIZE],
			      int [MAX_SIZE][MAX_SIZE],
			      int [MAX_SIZE][MAX_SIZE]);

void (*select_function(char *name))(int, int [MAX_SIZE][MAX_SIZE],
				    int [MAX_SIZE][MAX_SIZE],
				    int [MAX_SIZE][MAX_SIZE])
{
  if ( !strcmp(name, "naive") ) return naive_multiply_mat;
  else if ( !strcmp(name, "rep") ) return rep_multiply_mat;
       else if ( !strcmp(name, "sparse") ) return sparse_multiply_mat;
            else if ( !strcmp(name, "rtcg") ) return rtcg_multiply_mat;
                 else return NULL;
}

/*
**  matrix multiplication: naive version
*/
static void naive_multiply_mat(int size, int M[MAX_SIZE][MAX_SIZE],
			       int N[MAX_SIZE][MAX_SIZE],
			       int R[MAX_SIZE][MAX_SIZE])
{
  int i,j,k;
  int dp;

  for (i=0; i<size; i++)
    for (j=0; j<size; j++) {
      dp=0;
      for (k=0; k<size; k++) dp = dp+M[i][k]*N[j][k];
      R[i][j] = dp;
    }
}

/*
**  matrix multiplication: using the representation
*/
static int rep_dotproduct(int size, int u[], int v[])
{
  int k;
  int dp;

  dp=0;
  for (k=0; k<size; k++) dp = dp+u[k]*v[k];
  return dp;
}

static void rep_multiply_mat(int size, int M[MAX_SIZE][MAX_SIZE],
		             int N[MAX_SIZE][MAX_SIZE],
		             int R[MAX_SIZE][MAX_SIZE])
{
  int i,j;

  for (i=0; i<size; i++)
    for (j=0; j<size; j++)
      R[i][j] = rep_dotproduct(size, M[i], N[j]);
}

/*
**  matrix mutiplication: using the representation and the sparsness
*/
static int sparse_dotproduct(int size, int u[], int v[])
{
  int k;
  int dp;
  
  dp=0;
  for (k=0; k<size; k++) if ( u[k] ) dp = dp+u[k]*v[k];
  return dp;
}

static void sparse_multiply_mat(int size, int M[MAX_SIZE][MAX_SIZE],
				int N[MAX_SIZE][MAX_SIZE],
				int R[MAX_SIZE][MAX_SIZE])
{
  int i,j;

  for (i=0; i<size; i++)
    for (j=0; j<size; j++)
      R[i][j] = sparse_dotproduct(size, M[i], N[j]);
}

/*
** matrix multiplication: using rtcg
*/
#include "dotproduct.rts.h"

static void rtcg_multiply_mat(int size,int M[MAX_SIZE][MAX_SIZE], 
		              int N[MAX_SIZE][MAX_SIZE],
		              int R[MAX_SIZE][MAX_SIZE])
{
  /*
  ** Attention, la taille actuelle du buffer ne permet pas de
  ** contenir les specialisation engendree pour des grosses
  ** matrices.
  */
  int (*spec)(int []);
  int i,j;

  for (i=0; i<size; i++)
  {
    /*
    ** specialisation
    */
    spec = rts_dotproduct_1(size, M[i]);

    for (j=0; j<size; j++)
      R[i][j] = (*spec)(N[j]);
  }
}