// Multiplication with a vector
public static Vector <T> operator *(NumericMatrix <T> m, Vector <T> v)
{
if (mulTT == null)
{
mulTT = GenericOperatorFactory <T, T, T, Vector <T> > .Multiply;
}
if (addTT == null)
{
addTT = GenericOperatorFactory <T, T, T, Vector <T> > .Add;
}
Vector <T> result = new Vector <T>(m.Rows);
int i, j;
for (i = m.MinRowIndex; i <= m.MaxRowIndex; i++)
{
result[i] = mulTT(m[i, m.MinColumnIndex], v[v.MinIndex]);
for (j = m.MinColumnIndex + 1; j <= m.MaxColumnIndex; j++)
{
result[i] = addTT(result[i], mulTT(m[i, j], v[j]));
}
}
return(result);
}
public static T operator /(T t, Vector <T> v)
{
if (divTT == null)
{
divTT = GenericOperatorFactory <T, int, T, Vector <T> > .Divide;
}
return(divTT(t, v.Length));
}
public static T Sum <T>(this Vector <T> v)
{
BinaryOperatorT <T, T, T> addTt = GenericOperatorFactory <T, T, T, Vector <T> > .Add;
T result = default(T);
for (int i = v.MinIndex; i < v.Length; i++)
{
result = addTt(result, v[i]);
}
return(result);
}
public static double GeometricMean <T>(this Vector <T> v) where T : IConvertible
{
BinaryOperatorT <T, T, T> multiplyTt = GenericOperatorFactory <T, T, T, Vector <T> > .Multiply;
T result = default(T);
for (int i = v.MinIndex; i < v.Length; i++)
{
result = multiplyTt(result, v[i]);
}
return(Math.Sqrt(Convert.ToDouble(result)));
}
//operator overloading for '*' operator. multiplying t1 with every index of v1
public static Vector <T> operator *(Vector <T> v1, T t1)
{
Vector <T> result = new Vector <T>(v1.Length, v1.MinIndex);
if (mulTT == null)
{
mulTT = new BinaryOperatorT <T, T, T>(GenericOperatorFactory <T, T, T, Vector <T> > .Multiply);
}
for (int i = v1.MinIndex; i <= v1.MaxIndex; i++)
{
result[i] = mulTT(v1[i], t1);
}
return(result);
}
//operator overloading for '-' operator. Substracting v1 from t1
public static Vector <T> operator -(T t1, Vector <T> v1)
{
Vector <T> result = new Vector <T>(v1.Length, v1.MinIndex);
if (subTT == null)
{
subTT = new BinaryOperatorT <T, T, T>(GenericOperatorFactory <T, T, T, Vector <T> > .Subtract);
}
for (int i = v1.MinIndex; i <= v1.MaxIndex; i++)
{
result[i] = subTT(t1, v1[i]);
}
return(result);
}
//Operator overloading for '+' operator. Adding v2 to v1
public static Vector <T> operator +(Vector <T> v1, Vector <T> v2)
{
Vector <T> result = new Vector <T>(v1.Length, v1.MinIndex);
int delta = v1.MinIndex - v2.MinIndex;
if (addTT == null)
{
addTT = new BinaryOperatorT <T, T, T>(GenericOperatorFactory <T, T, T, Vector <T> > .Add);
}
for (int i = v1.MinIndex; i <= v1.MaxIndex; i++)
{
result[i] = addTT(v1[i], v2[(i - delta)]);
}
return(result);
}
// Matrix multiplication
public static NumericMatrix <T> operator *(NumericMatrix <T> m1, NumericMatrix <T> m2)
{
NumericMatrix <T> result = new NumericMatrix <T>(m1.Rows, m2.Columns, m1.MinRowIndex, m1.MinColumnIndex);
if (mulTT == null)
{
mulTT = GenericOperatorFactory <T, T, T, Vector <T> > .Multiply;
}
if (addTT == null)
{
addTT = GenericOperatorFactory <T, T, T, Vector <T> > .Add;
}
/* OLD int i, j, k, l;
*
* for( i = result.MaxRowIndex; i >= result.MinRowIndex; i-- )
* {
* for( j = result.MinColumnIndex; j <= result.MaxColumnIndex; j++ )
* {
* for( k = m1.MinColumnIndex, l = m2.MaxRowIndex; k <= m1.MaxColumnIndex; k++, l-- )
* {
* result[ i, j ] = addTT( result[ i, j ], mulTT( m1[ i, k ], m2[ l, j ] ) );
* }
* }
* }*/
// Index variables must be declared at this scope
int i, j, k;
for (i = result.MinRowIndex; i <= result.MaxRowIndex; i++)
{
for (j = result.MinColumnIndex; j <= result.MaxColumnIndex; j++)
{
result[i, j] = mulTT(m1[i, m1.MinColumnIndex], m2[m2.MinRowIndex, j]);
for (k = m1.MinColumnIndex + 1; k <= m1.MaxColumnIndex; k++)
{
result[i, j] = addTT(result[i, j], mulTT(m1[i, k], m2[k, j]));
}
}
}
return(result);
}
// Subtraction
public static NumericMatrix <T> operator -(NumericMatrix <T> m1, NumericMatrix <T> m2)
{
NumericMatrix <T> temp_matrix = new NumericMatrix <T>(m1.Rows, m1.Columns, m1.MinRowIndex, m1.MinColumnIndex);
int i, j;
if (subTT == null)
{
subTT = GenericOperatorFactory <T, T, T, Vector <T> > .Subtract;
}
for (i = m1.MinColumnIndex; i <= m1.MaxColumnIndex; i++)
{
for (j = m1.MinRowIndex; j <= m1.MaxRowIndex; j++)
{
//temp_matrix[ j, i ] = subTT( m1[ j, i ], m2[ j, i ] );
temp_matrix[j, i] = subTT(m1[j, i], m2[j, i]);
}
}
return(temp_matrix);
}
// Scalar multiplication
public static NumericMatrix <T> operator *(T getal, NumericMatrix <T> m)
{
NumericMatrix <T> result = new NumericMatrix <T>(m.Rows, m.Columns, m.MinRowIndex, m.MinColumnIndex);
int i, j;
if (mulTT == null)
{
mulTT = GenericOperatorFactory <T, T, T, Vector <T> > .Multiply;
}
for (i = m.MinRowIndex; i <= m.MaxRowIndex; i++)
{
for (j = m.MinColumnIndex; j <= m.MaxColumnIndex; j++)
{
result[i, j] = mulTT(getal, m[i, j]);
}
}
return(result);
}
// Operators
// Addition
public static NumericMatrix <T> operator +(NumericMatrix <T> m1, NumericMatrix <T> m2)
{
NumericMatrix <T> temp_matrix = new NumericMatrix <T>(m1.Rows, m1.Columns, m1.MinRowIndex, m1.MinColumnIndex);
int i, j;
if (addTT == null)
{
addTT = GenericOperatorFactory <T, T, T, Vector <T> > .Add;
// addTT = new BinaryOperatorT<T, T, T>(GenericOperatorFactory<T, T, T, Vector<T>>.Add);
}
for (i = m1.MinColumnIndex; i <= m1.MaxColumnIndex; i++)
{
for (j = m1.MinRowIndex; j <= m1.MaxRowIndex; j++)
{
temp_matrix[j, i] = addTT(m1[j, i], m2[j, i]);
}
}
return(temp_matrix);
}
