LBC

Esiur.Analysis/Coding/Arithmetic.cs

@@ -7,6 +7,5 @@ namespace Esiur.Analysis.Coding
     public class Arithmetic<T> where T : System.Enum
     {
 
-
     }
 }

Esiur.Analysis/Coding/BlockCode.cs

@@ -0,0 +1,34 @@
+using Esiur.Analysis.Graph;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Esiur.Analysis.Coding
+{
+    internal class BlockCode<T> where T : struct
+    {
+        public Matrix<T> Generator { get; private set; }
+        public Matrix<T> ParityCheck { get; private set; }
+
+        int k = 0;
+        Matrix<T> p;
+
+        public BlockCode(Matrix<T> parityMatrix, T identity)
+        {
+            // create generator matrix from parity matrix
+            // K = number of rows
+
+            p = parityMatrix;
+            k = parityMatrix.Rows;
+
+            var g = new Matrix<T>(p.Rows, p.Columns + p.Rows);
+            for(var i = 0; i < p.Rows; i++)
+                for(var j = 0; j < p.Columns; j++)
+                    g[i, j] = p[i, j];
+
+            for (var i = 0; i < k; i++)
+                g[i, p.Columns + i] = (T)1;
+
+        }
+    }
+}

Esiur.Analysis/Coding/CodeSet.cs

@@ -1,4 +1,5 @@
-using System;
+using Microsoft.CodeAnalysis;
+using System;
 using System.Collections.Generic;
 using System.Text;
 
@@ -41,6 +42,16 @@ namespace Esiur.Analysis.Coding
         Two
     }
 
+
+
+    public interface BaseNumber<T>
+    {
+        public static T AdditiveIdentity { get; }
+        public static T MultiplicativeIdentity { get; }
+
+        //public
+    }
+
     //public struct BinaryValue : IBaseValue<Base2>
     //{
     //    public Base2 Value { get; set; }

Esiur.Analysis/Coding/Functions.cs

@@ -14,6 +14,11 @@ namespace Esiur.Analysis.Coding
             return frequencies.Sum(x => ((double)x / total * -Log2(x)));
         }
 
+        public static double AverageLength<T>(this CodeWord<T>[] words)
+        {
+            return words.Sum(x => x.Length) / (double)words.Length;
+        }
+
         public static double Log2(double value) => Math.Log10(value) / Math.Log10(2);
     }
 }

Esiur.Analysis/Coding/Symbol.cs

@@ -23,7 +23,7 @@ namespace Esiur.Analysis.Coding
             return ToString().GetHashCode();
         }
 
-  
+        public int Length => Word.Length;
 
         public static CodeWord<Base2> FromByte(byte b)
         {

Esiur.Analysis/Graph/Matrix.cs

@@ -9,14 +9,35 @@ namespace Esiur.Analysis.Graph
     {
         internal T[,] value;
 
-        public int Rows => value.GetLength(0);
+        public int Rows { get; private set; }
-        public int Columns => value.GetLength(1);
+        public int Columns { get; private set; }
 
-        public T this[int x, int y] => value[x, y];
+        public T this[int x, int y] {
+            get => value [x, y];
+            set => this.value[x, y] = value;
+        }
+
+        public Matrix(int rows, int columns)
+        {
+            value = new T[rows, columns];
+        }
 
         public Matrix(T[,] value)
         {
             this.value = value;
+            Rows = value.GetLength(0);
+            Columns = value.GetLength(1); 
+        }
+
+        public Matrix<T> Transpose()
+        {
+            var rt = new T[Columns, Rows];
+
+            for(var i = 0; i < Rows; i++)
+                for(var j = 0; j < Columns; j++)
+                    rt[j, i] = value[i, j];
+
+            return new Matrix<T>(rt);
         }
 
         public static Matrix<T> operator *(Matrix<T> a, Matrix<T> b)