Basic Matrix class. Some minor functions might still be missing, but the class is usable

Author: frereit

.gitignore

@@ -258,4 +258,5 @@ paket-files/
 
 # Python Tools for Visual Studio (PTVS)
 __pycache__/
-*.pyc
+*.pyc
+/MachineLearningExamples

MachineLearning.sln

@@ -5,6 +5,10 @@ VisualStudioVersion = 15.0.28307.271
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MachineLearning", "MachineLearning\MachineLearning.csproj", "{6A02E4F2-B745-4699-984E-0A1A0B2B6AC0}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MachineLearningTests", "MachineLearningTests\MachineLearningTests.csproj", "{05EE43D7-F097-4221-93F0-9E58D462867C}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MachineLearningPlayground", "MachineLearningExamples\MachineLearningPlayground.csproj", "{00F7414E-8FC3-4503-B1F5-EAA4B4A6154E}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -15,6 +19,14 @@ Global
 		{6A02E4F2-B745-4699-984E-0A1A0B2B6AC0}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{6A02E4F2-B745-4699-984E-0A1A0B2B6AC0}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{6A02E4F2-B745-4699-984E-0A1A0B2B6AC0}.Release|Any CPU.Build.0 = Release|Any CPU
+		{05EE43D7-F097-4221-93F0-9E58D462867C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{05EE43D7-F097-4221-93F0-9E58D462867C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{05EE43D7-F097-4221-93F0-9E58D462867C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{05EE43D7-F097-4221-93F0-9E58D462867C}.Release|Any CPU.Build.0 = Release|Any CPU
+		{00F7414E-8FC3-4503-B1F5-EAA4B4A6154E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{00F7414E-8FC3-4503-B1F5-EAA4B4A6154E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{00F7414E-8FC3-4503-B1F5-EAA4B4A6154E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{00F7414E-8FC3-4503-B1F5-EAA4B4A6154E}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

MachineLearning/Exceptions.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MachineLearning
+{
+    public class DotProductNotPossibleException : Exception
+    {
+        public DotProductNotPossibleException(){ }
+
+        public DotProductNotPossibleException(string message) : base(message) { }
+
+        public DotProductNotPossibleException(string message, Exception inner) : base(message, inner) { }
+    }
+
+    public class MatrixAdditionNotPossibleException : Exception
+    {
+        public MatrixAdditionNotPossibleException() { }
+
+        public MatrixAdditionNotPossibleException(string message) : base(message) { }
+
+        public MatrixAdditionNotPossibleException(string message, Exception inner) : base(message) { }
+    }
+}

MachineLearning/Class1.cs MachineLearning/Globals.cs

@@ -6,7 +6,8 @@
 
 namespace MachineLearning
 {
-    public class Class1
+    class Globals
     {
+        public static Graph DefaultGraph;
     }
 }

MachineLearning/Graph.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MachineLearning
+{
+    public class Graph
+    {
+        public ArrayList Operations { get; set; }
+        public ArrayList Variables { get; set; }
+        public ArrayList Placeholders { get; set; }
+
+        public Graph()
+        {
+            Operations = new ArrayList();
+            Placeholders = new ArrayList();
+            Variables = new ArrayList();
+        }
+
+        public void SetAsDefault()
+        {
+            Globals.DefaultGraph = this;
+        }
+    }
+}

MachineLearning/MachineLearning.csproj

@@ -1,10 +1,10 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>6a02e4f2-b745-4699-984e-0a1a0b2b6ac0</ProjectGuid>
+    <ProjectGuid>{6A02E4F2-B745-4699-984E-0A1A0B2B6AC0}</ProjectGuid>
     <OutputType>Library</OutputType>
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>MachineLearning</RootNamespace>
@@ -31,24 +31,19 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="System"/>
-    
-    <Reference Include="System.Core"/>
-    <Reference Include="System.Xml.Linq"/>
-    <Reference Include="System.Data.DataSetExtensions"/>
-    
-    
-    <Reference Include="Microsoft.CSharp"/>
-    
-    <Reference Include="System.Data"/>
-    
-    <Reference Include="System.Net.Http"/>
-    
-    <Reference Include="System.Xml"/>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Class1.cs" />
+    <Compile Include="Exceptions.cs" />
+    <Compile Include="Matrix.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
- </Project>
+</Project>

MachineLearning/Matrix.cs

@@ -0,0 +1,170 @@
+using System;
+using System.Collections;
+
+namespace MachineLearning
+{
+    public class Matrix
+    {
+        private double[,] _matrix;
+
+        public int Rows
+        {
+            get { return _matrix.GetLength(0); }
+        }
+        public int Columns
+        {
+            get { return _matrix.GetLength(1); }
+        }
+
+        public Matrix(double[,] pMatrix)
+        {
+            _matrix = pMatrix;
+        }
+        
+        public Matrix(int pRows, int pColumns)
+        {
+            _matrix = new double[pRows, pColumns];
+            for(int row = 0; row < Rows; row++)
+            {
+                for(int col = 0; col < Columns; col++)
+                {
+                    _matrix[row, col] = 0.0;
+                }
+            }
+        }
+
+
+        public static Matrix operator +(Matrix m1, Matrix m2)
+        {
+            if(m1.Rows != m2.Rows || m1.Columns != m2.Columns)
+            {
+                throw (new MatrixAdditionNotPossibleException("Matrix dimensions are not indentical: Matrix1: " 
+                                                                + m1.Rows + "x" + m1.Columns + ". Matrix2: " 
+                                                                + m2.Rows + "x" + m2.Columns + "."));
+            }
+            Matrix result = new Matrix(m1.Rows, m1.Columns);
+            for(int row = 0; row < m1.Rows; row++)
+            {
+                for(int col = 0; col < m1.Columns; col++)
+                {
+                    result[row, col] = m1[row, col] + m2[row, col];
+                }
+            }
+            return result;
+        }
+
+        public static Matrix operator +(Matrix m1, double operand)
+        {
+            Matrix result = new Matrix(m1.Rows, m1.Columns);
+            for (int row = 0; row < m1.Rows; row++)
+            {
+                for (int col = 0; col < m1.Columns; col++)
+                {
+                    result[row, col] = m1[row, col] + operand;
+                }
+            }
+            return result;
+        }
+
+        public static Matrix operator -(Matrix m1, Matrix m2)
+        {
+            return m1 + (m2 * -1);
+        }
+
+        public static Matrix operator -(Matrix m1, double operand)
+        {
+            return m1 + (operand * -1);
+        }
+
+        public static Matrix operator *(Matrix m1, Matrix m2)
+        {
+            if(m1.Columns != m2.Rows)
+            {
+                throw (new DotProductNotPossibleException("Column Count of Matrix 1 (" 
+                                                            + m1.Rows + ") does not match up with Row Count of Matrix 2 (" 
+                                                            + m2.Columns + ")."));
+            }
+            Matrix result = new Matrix(m1.Rows, m2.Columns);
+            for(int m1Row = 0; m1Row < m1.Rows; m1Row++)
+            {
+                for(int m2Col = 0; m2Col < m2.Columns; m2Col++)
+                {
+                    double sum = 0;
+                    for(int i = 0; i < m1.Columns; i++)
+                    {
+                        sum += m2[i, m2Col] * m1[m1Row, i];
+                    }
+                    result[m1Row, m2Col] = sum;
+                }
+            }
+            return result;
+        }
+
+        public static Matrix operator *(Matrix m1, double scalar)
+        {
+            Matrix result = new Matrix(m1.Rows, m1.Columns);
+            for(int row = 0; row < m1.Rows; row++)
+            {
+                for(int col = 0; col < m1.Columns; col++)
+                {
+                    result[row, col] = m1[row,col] * scalar;
+                }
+            }
+            return result;
+        }
+
+        public static Matrix operator /(Matrix m1, double scalar)
+        {
+            return m1 * (1 / scalar);
+        }
+
+        public Matrix Transpose()
+        {
+            Matrix transposed = new Matrix(Columns, Rows);
+            for(int row = 0; row < Rows; row++)
+            {
+                for(int col = 0; col < Columns; col++)
+                {
+                    transposed[col, row] = this[row, col];
+                }
+            }
+            return transposed;
+        }
+
+        public bool Equals(Matrix m1)
+        {
+            if (m1.Rows != Rows) return false;
+            if (m1.Columns != Columns) return false;
+            for(int row = 0; row < Rows; row++)
+            {
+                for(int col = 0; col < Columns; col++)
+                {
+                    if (this[row, col] != m1[row, col]) return false;
+                }
+            }
+            return true;
+        }
+
+        public static Matrix Identitiy(int size)
+        {
+            Matrix identity = new Matrix(size, size);
+            for(int row = 0; row < size; row++)
+            {
+                for(int col = 0; col < size; col++)
+                {
+                    if(row == col)
+                    {
+                        identity[row, col] = 1.0;
+                    }
+                }
+            }
+            return identity;
+        }
+
+        public double this[int i, int j]
+        {
+            get { return _matrix[i, j]; }
+            set { _matrix[i, j] = value; }
+        }
+    }
+}

MachineLearning/Operations.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Collections;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MachineLearning
+{
+    public class Operation
+    {
+        public ArrayList InputNodes { get;  }
+        public ArrayList OutputNodes { get; set;  }
+        public ArrayList Inputs { get; set; }
+        public object Output { get; set; }
+
+        public Operation(ArrayList pInputNodes)
+        {
+            InputNodes = pInputNodes;
+            OutputNodes = new ArrayList();
+
+            foreach(object node in InputNodes)
+            {
+                if(node is Variable)
+                {
+                    ((Variable) node).OutputNodes.Add(this);
+                }else if(node is Placeholder)
+                {
+                    ((Placeholder)node).OutputNodes.Add(this);
+                }else if(node is Operation)
+                {
+                    ((Operation)node).OutputNodes.Add(this);
+                }
+                
+            }
+
+            Globals.DefaultGraph.Operations.Add(this);
+        }
+        
+        public object Compute(params Object[] objects) { return null; }
+    }
+
+    public class Add : Operation
+    {
+
+        public Add(object x, object y) : base(new ArrayList() { x, y, })
+        {
+
+        }
+
+        public new double Compute(params Object[] objects)
+        {
+            Inputs = new ArrayList() { objects[0], objects[1] };
+            return (double) objects[0] + (double) objects[1];
+        }
+    }
+
+    public class Multiply : Operation
+    {
+        public Multiply(object x, object y) : base(new ArrayList() { x, y, })
+        {
+
+        }
+
+        public new double Compute(params Object[] objects)
+        {
+            Inputs = new ArrayList() { objects[0], objects[1] };
+            return (double) objects[0] * (double) objects[1];
+        }
+    }
+
+
+    public class MatMul : Operation
+    {
+        public MatMul(Matrix x, Matrix y) : base(new ArrayList() { x, y, })
+        {
+
+        }
+
+        public new Matrix Compute(params Object[] objects)
+        {
+            Inputs = new ArrayList() { objects[0], objects[1] };
+            return (Matrix) objects[0] * (Matrix) objects[1];
+        }
+    }
+}

MachineLearning/Placeholder.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MachineLearning
+{
+    public class Placeholder
+    {
+        public ArrayList OutputNodes { get; set; }
+        public object Output { get; set; }
+        public Placeholder()
+        {
+            OutputNodes = new ArrayList();
+
+            Globals.DefaultGraph.Placeholders.Add(this);
+        }
+    }
+}

MachineLearning/Session.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.Collections;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MachineLearning
+{
+    public class Session
+    {
+        public object Run(Operation operation, Dictionary<Placeholder, object> feed_dict)
+        {
+            ArrayList nodesPostorder = new Traverser(operation).Traverse();
+            foreach(object node in nodesPostorder) 
+            {
+                if(node is Placeholder)
+                {
+                    ((Placeholder)node).Output = feed_dict[(Placeholder) node];
+                }else if (node is Variable)
+                {
+                    ((Variable)node).Output = ((Variable)node).Value;
+                }else if (node is Operation)
+                {
+                    foreach(object inputNode in ((Operation)node).InputNodes)
+                    {
+                        if(inputNode is Variable)
+                            ((Operation)node).Inputs.Add(((Variable) inputNode).Output);
+                        else if(inputNode is Placeholder)
+                            ((Operation)node).Inputs.Add(((Placeholder)inputNode).Output);
+
+                        ((Operation)node).Output = ((Operation)node).Compute(((Operation) node).InputNodes);
+                    }
+                }
+            }
+            return operation.Output;
+        }
+    }
+}

MachineLearning/Traverser.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MachineLearning
+{
+    public class Traverser
+    {
+        private readonly Operation startOperation;
+
+        public Traverser(Operation pOperation)
+        {
+            startOperation = pOperation;
+        }
+
+        public ArrayList Traverse()
+        {
+            return Recurse(startOperation);
+        }
+
+        public ArrayList Recurse(object node)
+        {
+            ArrayList nodesPostorder = new ArrayList();
+            if(node is Operation)
+            {
+                foreach(object input_node in ((Operation)node).InputNodes)
+                {
+                    nodesPostorder.Add(Recurse(input_node));
+                }
+            }
+            nodesPostorder.Add(node);
+            return nodesPostorder;
+        }
+    }
+}

MachineLearning/Variable.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Collections;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MachineLearning
+{
+    public class Variable
+    {
+        public ArrayList OutputNodes { get; set; }
+        public object Value { get; set; }
+        public object Output { get; set; }
+
+        public Variable(object pInitialValue)
+        {
+            Value = pInitialValue;
+            OutputNodes = new ArrayList();
+
+            Globals.DefaultGraph.Variables.Add(this);
+        }
+    }
+}

MachineLearningTests/MachineLearningTests.csproj

@@ -0,0 +1,106 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="..\packages\MSTest.TestAdapter.1.3.2\build\net45\MSTest.TestAdapter.props" Condition="Exists('..\packages\MSTest.TestAdapter.1.3.2\build\net45\MSTest.TestAdapter.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{05EE43D7-F097-4221-93F0-9E58D462867C}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>MachineLearningTests</RootNamespace>
+    <AssemblyName>MachineLearningTests</AssemblyName>
+    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
+    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
+    <ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\$(VisualStudioVersion)\UITestExtensionPackages</ReferencePath>
+    <IsCodedUITest>False</IsCodedUITest>
+    <TestProjectType>UnitTest</TestProjectType>
+    <TargetFrameworkProfile />
+    <NuGetPackageImportStamp>
+    </NuGetPackageImportStamp>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Microsoft.VisualStudio.TestPlatform.TestFramework, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <HintPath>..\packages\MSTest.TestFramework.1.3.2\lib\net45\Microsoft.VisualStudio.TestPlatform.TestFramework.dll</HintPath>
+    </Reference>
+    <Reference Include="Microsoft.VisualStudio.TestPlatform.TestFramework.Extensions, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+      <HintPath>..\packages\MSTest.TestFramework.1.3.2\lib\net45\Microsoft.VisualStudio.TestPlatform.TestFramework.Extensions.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+  </ItemGroup>
+  <Choose>
+    <When Condition="('$(VisualStudioVersion)' == '10.0' or '$(VisualStudioVersion)' == '') and '$(TargetFrameworkVersion)' == 'v3.5'">
+      <ItemGroup>
+        <Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework, Version=10.1.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
+      </ItemGroup>
+    </When>
+    <Otherwise />
+  </Choose>
+  <ItemGroup>
+    <Compile Include="MatrixTests.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\MachineLearning\MachineLearning.csproj">
+      <Project>{6A02E4F2-B745-4699-984E-0A1A0B2B6AC0}</Project>
+      <Name>MachineLearning</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Choose>
+    <When Condition="'$(VisualStudioVersion)' == '10.0' And '$(IsCodedUITest)' == 'True'">
+      <ItemGroup>
+        <Reference Include="Microsoft.VisualStudio.QualityTools.CodedUITestFramework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+          <Private>False</Private>
+        </Reference>
+        <Reference Include="Microsoft.VisualStudio.TestTools.UITest.Common, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+          <Private>False</Private>
+        </Reference>
+        <Reference Include="Microsoft.VisualStudio.TestTools.UITest.Extension, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+          <Private>False</Private>
+        </Reference>
+        <Reference Include="Microsoft.VisualStudio.TestTools.UITesting, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
+          <Private>False</Private>
+        </Reference>
+      </ItemGroup>
+    </When>
+  </Choose>
+  <Import Project="$(VSToolsPath)\TeamTest\Microsoft.TestTools.targets" Condition="Exists('$(VSToolsPath)\TeamTest\Microsoft.TestTools.targets')" />
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+    <PropertyGroup>
+      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+    </PropertyGroup>
+    <Error Condition="!Exists('..\packages\MSTest.TestAdapter.1.3.2\build\net45\MSTest.TestAdapter.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\MSTest.TestAdapter.1.3.2\build\net45\MSTest.TestAdapter.props'))" />
+    <Error Condition="!Exists('..\packages\MSTest.TestAdapter.1.3.2\build\net45\MSTest.TestAdapter.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\MSTest.TestAdapter.1.3.2\build\net45\MSTest.TestAdapter.targets'))" />
+  </Target>
+  <Import Project="..\packages\MSTest.TestAdapter.1.3.2\build\net45\MSTest.TestAdapter.targets" Condition="Exists('..\packages\MSTest.TestAdapter.1.3.2\build\net45\MSTest.TestAdapter.targets')" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

MachineLearningTests/MatrixTests.cs

@@ -0,0 +1,184 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MachineLearning;
+using System;
+using System.Collections;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace MachineLearning.Tests
+{
+    [TestClass()]
+    public class MatrixTests
+    {
+        [TestMethod()]
+        public void MatrixInitTest()
+        {
+            Matrix m1 = new Matrix(new double[,]
+            {
+                {1.0, 2.0, 3.0},
+                {4.0, 5.0, 6.0},
+            });
+            Matrix m2 = new Matrix(new double[,]
+            {
+                { 7.0,  8.0},
+                { 9.0, 10.0},
+                {11.0, 12.0},
+            });
+
+            Matrix m3 = new Matrix(5, 5);
+            Assert.AreEqual(m3[1,2], 0.0);
+
+            Assert.AreEqual(m1.Rows, 2);
+            Assert.AreEqual(m1.Columns, 3);
+            Assert.AreEqual(m1[0,1], 2.0);
+        }
+
+        [TestMethod()]
+        public void MatrixMatmulTest()
+        {
+            Matrix m1 = new Matrix(new double[,]
+            {
+                {1.0, 2.0, 3.0},
+                {4.0, 5.0, 6.0},
+            });
+            Matrix m2 = new Matrix(new double[,]
+            {
+                { 7.0,  8.0},
+                { 9.0, 10.0},
+                {11.0, 12.0},
+            });
+            Matrix m3 = new Matrix(new double[,]
+            {
+                { 7.0,  8.0},
+                { 9.0, 10.0},
+                {11.0, 12.0},
+                {13.0, 14.0},
+            });
+
+            Matrix dotProduct = m1 * m2;
+            Matrix dotProductActual = new Matrix(new double[,]
+            {
+                { 58.0,  64.0},
+                {139.0, 154.0},
+            });
+            Assert.IsTrue(dotProduct.Equals(dotProductActual));
+            Assert.ThrowsException<DotProductNotPossibleException>(delegate () { Matrix _ = m1 * m3; });
+        }
+
+        [TestMethod()]
+        public void MatrixScalarMulTest()
+        {
+            Matrix m1 = new Matrix(new double[,]
+            {
+                {1.0, 2.0, 3.0},
+                {4.0, 5.0, 6.0},
+            });
+
+            Matrix scalarProduct = m1 * 2;
+
+            Matrix scalarProductActual = new Matrix(new double[,]
+            {
+                {2.0,  4.0,  6.0},
+                {8.0, 10.0, 12.0},
+            });
+
+            Assert.IsTrue(scalarProduct.Equals(scalarProductActual));
+        }
+
+        [TestMethod()]
+        public void MatrixScalarDivTest()
+        {
+            Matrix m1 = new Matrix(new double[,]
+            {
+                {1.0, 2.0, 3.0},
+                {4.0, 5.0, 6.0},
+            });
+
+            Matrix scalarDivision = m1 / 2;
+
+            Matrix scalarDivisionActual = new Matrix(new double[,]
+            {
+                {0.5,  1.0,  1.5},
+                {2.0, 2.5, 3.0},
+            });
+
+            Assert.IsTrue(scalarDivision.Equals(scalarDivisionActual));
+        }
+
+        [TestMethod()]
+        public void MatrixAdditionTest()
+        {
+            Matrix m1 = new Matrix(new double[,]
+            {
+                {1.0, 2.0 },
+                {4.0, 5.0 },
+            });
+            Matrix m2 = new Matrix(new double[,]
+            {
+                { 7.0,  8.0},
+                { 9.0, 10.0},
+            });
+
+            Matrix m3 = new Matrix(new double[,]
+            {
+                { 7.0,  8.0, 5.0},
+                { 9.0, 10.0, 6.0},
+            });
+
+            Matrix matrixAddition = m1 + m2;
+            Matrix matrixAdditionActual = new Matrix(new double[,]
+            {
+                { 8.0, 10.0},
+                {13.0, 15.0},
+            });
+
+            Assert.IsTrue(matrixAddition.Equals(matrixAdditionActual));
+
+            Assert.ThrowsException<MatrixAdditionNotPossibleException>(delegate() { Matrix _ = m1 + m3; });
+        }
+
+        [TestMethod()]
+        public void MatrixTranspositionTest()
+        {
+            Matrix m1 = new Matrix(new double[,]
+            {
+                {1.0, 2.0},
+                {3.0, 4.0},
+                {5.0, 6.0},
+            });
+
+            Matrix transposed = m1.Transpose();
+            Matrix transposedActual = new Matrix(new double[,]
+            {
+                {1.0, 3.0, 5.0 },
+                {2.0, 4.0, 6.0 },
+            });
+            Assert.IsTrue(transposed.Equals(transposedActual));
+        }
+
+        [TestMethod()]
+        public void MatrixEqualityTest()
+        {
+            Matrix m1 = new Matrix(new double[,]
+            {
+                {1.0, 2.0, 3.0 },
+                {4.0, 5.0, 6.0 }
+            });
+            Matrix m2 = new Matrix(new double[,]
+            {
+                {1.0, 2.0, 3.0 },
+                {4.0, 5.0, 6.0 }
+            });
+            Matrix m3 = new Matrix(new double[,]
+            {
+                {1.0, 2.0},
+                {3.0, 4.0},
+                {5.0, 6.0},
+            });
+
+            Assert.IsFalse(m2.Equals(m3));
+            Assert.IsTrue(m1.Equals(m2));
+        }
+    }
+}

MachineLearningTests/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("MachineLearningTests")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("MachineLearningTests")]
+[assembly: AssemblyCopyright("Copyright ©  2019")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("05ee43d7-f097-4221-93f0-9e58d462867c")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

MachineLearningTests/packages.config

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="MSTest.TestAdapter" version="1.3.2" targetFramework="net461" />
+  <package id="MSTest.TestFramework" version="1.3.2" targetFramework="net461" />
+</packages>