#include <vector>
#include <iostream>
#include <sstream>
#include <string>
#include <math.h>
#include <numeric>

using namespace std;

#include "matrix.h"

// read in a matrix from input stream is

void
readmatrix (istream & is, Tmatrix & m)
{
  string instr;
  while (getline (is, instr)) {
    stringstream ss (instr);
    double a;
    Trow r;
    while (ss >> a)
      r.push_back (a);
    if (r.size ())
      m.push_back (r);
  }
}


// operator overload vector = scalar * vector

Trow
operator * (double a, Trow r)
{
  for (int i = 0; i < r.size (); i++)
    r[i] *= a;
  return r;
}

Tmatrix
operator * (double a, Tmatrix m)
{
  for (int i = 0; i < m.size (); i++) {
    m[i] = a * m[i];
  }
  return m;
}

// operator overload vector = vector + vector

Trow
operator + (Trow r, const Trow & rr)
{
  for (int i = 0; i < r.size (); i++)
    r[i] += rr[i];
  return r;
}

Tmatrix
operator + (Tmatrix mm, Tmatrix m)
{
  for (int i = 0; i < mm.size (); i++) {
    mm[i] = mm[i] + m[i];
  }
  return mm;
}

// operator overload vector = matrix * vector

Trow
operator * (const Tmatrix & m, const Trow & r)
{
  Trow res;
  for (int i = 0; i < m.size (); i++) {
    double a = 0;
    for (int j = 0; j < m[i].size (); j++) {
      a += m[i][j] * r[j];
    }
    res.push_back (a);
  }
  return res;
}

// vector times scalar                                           

Trow
operator * (const Trow & r, double a)
{
  return a * r;
}

// vector divided by scalar                                     

Trow
operator / (const Trow & r, double a)
{
  return (1.0 / a) * r;
}

double
dot (const Trow & r, const Trow & rr)
{
  return inner_product (r.begin (), r.end (), rr.begin (), 0.0);
}

// find the norm of a vector

double
norm (Trow r)
{
  double n = 0;
  for (int i = 0; i < r.size (); i++) {
    n += r[i] * r[i];
  }
  return pow (n, 0.5);
}

Tmatrix
idmatrix (int n)
{
  Trow r (n, 0);
  Tmatrix m;
  for (int i = 0; i < n; i++) {
    m.push_back (r);
    m[i][i] = 1;
  }
  return m;
}