public override Vec <float> SubVec(int start, int length)
{
Vecf result = new Vecf(length);
for (int i = 0; i < length; i++)
{
result.elements[i] = elements[start + i];
}
return(result);
}
public override bool Equals(object obj)
{
Vecf v = (Vecf)obj;
if (v == null)
{
return(false);
}
return(this == v);
}
public static Vecf operator *(Vecf left, float value)
{
Vecf result = new Vecf(left.size);
for (int i = 0; i < left.size; i++)
{
result.elements[i] = left.elements[i] * value;
}
return(result);
}
public static Vecf FromArray(float[] arr)
{
Vecf result = new Vecf(arr.Length);
for (int i = 0; i < result.size; i++)
{
result.elements[i] = arr[i];
}
return(result);
}
public override Vec <float> Copy()
{
Vecf result = new Vecf(size);
for (int i = 0; i < size; i++)
{
result.elements[i] = elements[i];
}
return(result);
}
public void Scale(Vecf v)
{
if (size != v.size)
{
throw new ArgumentException();
}
for (int i = 0; i < size; i++)
{
elements[i] *= v.elements[i];
}
}
public static Matf Mul(Vecf vertical, Vecf horizontal)
{
Matf result = new Matf(vertical.size, horizontal.size);
for (int row = 0; row < result.rows; row++)
{
for (int col = 0, index = row * result.cols; col < result.cols; col++, index++)
{
result.elements[index] = vertical.elements[row] * horizontal.elements[col];
}
}
return(result);
}
public static Vecf operator -(Vecf left, float[] right)
{
if (left.size != right.Length)
{
throw new ArgumentException();
}
Vecf result = new Vecf(left.size);
for (int i = 0; i < result.size; i++)
{
result.elements[i] = left.elements[i] - right[i];
}
return(result);
}
public static Matf ParallelMul(Vecf vertical, Vecf horizontal)
{
Matf result = new Matf(vertical.size, horizontal.size);
Parallel.For(0, result.rows, new ParallelOptions()
{
MaxDegreeOfParallelism = Environment.ProcessorCount
}, (row) =>
{
for (int col = 0, index = row * result.cols; col < result.cols; col++, index++)
{
result.elements[index] = vertical.elements[row] * horizontal.elements[col];
}
});
return(result);
}
public static Matf Mul(Matf m, Vecf v)
{
if (m.cols != 1)
{
throw new ArgumentException();
}
Matf result = new Matf(m.rows, v.size);
for (int row = 0; row < result.rows; row++)
{
for (int col = 0, index = row * result.cols; col < result.cols; col++, index++)
{
result.elements[index] = m.elements[row] * v.elements[col];
}
}
return(result);
}
public static Vecf Mul(Vecf v, Matf m)
{
if (v.size != m.rows)
{
throw new ArgumentException();
}
Vecf result = new Vecf(m.cols);
for (int x = 0; x < m.cols; x++)
{
float sum = 0;
for (int y = 0, offset = 0; y < m.rows; y++, offset += m.cols)
{
sum += v.elements[y] * m.elements[offset + x];
}
result.elements[x] = sum;
}
return(result);
}
public static Matf Mul(Vecf v, Matf m)
{
if (v.size != m.rows)
{
throw new ArgumentException();
}
Matf result = new Matf(1, m.cols);
for (int x = 0; x < m.cols; x++)
{
float sum = 0;
for (int i = 0; i < v.size; i++)
{
sum += v.elements[i] * m.elements[i * m.cols + x];
}
result.elements[x] = sum;
}
return(result);
}
public static Vecf ParallelMul(Vecf v, Matf m)
{
if (v.size != m.rows)
{
throw new ArgumentException();
}
Vecf result = new Vecf(m.cols);
Parallel.For(0, m.cols, new ParallelOptions()
{
MaxDegreeOfParallelism = Environment.ProcessorCount
}, (x) =>
{
float sum = 0;
for (int y = 0, offset = 0; y < m.rows; y++, offset += m.cols)
{
sum += v.elements[y] * m.elements[offset + x];
}
result.elements[x] = sum;
});
return(result);
}
