HAST-136: Posit floating point support

Hast.Samples.Posit/App.config

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.1" />
+    </startup>
+</configuration>

Hast.Samples.Posit/Hast.Samples.Posit.csproj

@@ -0,0 +1,63 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <OutputType>Exe</OutputType>
+    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Hast.Abstractions\Hast.Transformer.Abstractions\Hast.Transformer.Abstractions.csproj" />
+    <ProjectReference Include="..\Hast.Abstractions\Hast.Transformer.Vhdl.Abstractions\Hast.Transformer.Vhdl.Abstractions.csproj" />
+    <ProjectReference Include="..\Hast.Common\Hast.Common.csproj" />
+    <ProjectReference Include="..\Hast.Layer\Hast.Layer.csproj" />
+    <ProjectReference Include="..\Hast.Remote.Client\Hast.Remote.Client.csproj" />
+    <ProjectReference Include="..\Lombiq.Arithmetics\Lombiq.Arithmetics.csproj" />
+    <ProjectReference Include="..\Samples\Hast.Samples.SampleAssembly\Hast.Samples.SampleAssembly.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="PositCalculator.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>PositCalculator.cs</LastGenOutput>
+    </Content>
+    <Content Include="PositCalculatorSampleRunner.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>PositCalculatorSampleRunner.cs</LastGenOutput>
+    </Content>
+    <Content Include="Program.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>Program.cs</LastGenOutput>
+    </Content>
+    <Content Include="Sample.tt">
+      <Generator>TextTemplatingFileGenerator</Generator>
+      <LastGenOutput>Sample.cs</LastGenOutput>
+    </Content>
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.VisualStudio.Validation" Version="16.9.32" />
+  </ItemGroup>
+  <ItemGroup>
+    <Service Include="{508349b6-6b84-4df5-91f0-309beebad82d}" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Update="PositCalculator.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>PositCalculator.tt</DependentUpon>
+    </Compile>
+    <Compile Update="PositCalculatorSampleRunner.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>PositCalculatorSampleRunner.tt</DependentUpon>
+    </Compile>
+    <Compile Update="Program.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Program.tt</DependentUpon>
+    </Compile>
+    <Compile Update="Sample.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Sample.tt</DependentUpon>
+    </Compile>
+  </ItemGroup>
+</Project>

Hast.Samples.Posit/Posit16E0Calculator.cs

@@ -0,0 +1,203 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Hast.Layer;
+using Hast.Transformer.Abstractions.SimpleMemory;
+using Lombiq.Arithmetics;
+
+namespace Hast.Samples.Posit
+{
+
+    public class Posit16E0Calculator
+    {
+        public const int CalculateLargeIntegerSum_InputInt32Index = 0;
+        public const int CalculateLargeIntegerSum_OutputInt32Index = 0;
+        public const int ParallelizedCalculateLargeIntegerSum_Int32NumbersStartIndex = 0;
+        public const int ParallelizedCalculateLargeIntegerSum_OutputInt32sStartIndex = 0;
+        public const int AddPositsInArray_InputPosit32CountIndex = 0;
+        public const int AddPositsInArray_InputPosit32sStartIndex = 1;
+        public const int AddPositsInArray_OutputPosit32Index = 2;
+        public const int CalculatePowerOfReal_InputInt32Index = 0;
+        public const int CalculatePowerOfReal_InputPosit32Index = 1;
+        public const int CalculatePowerOfReal_OutputPosit32Index = 0;
+
+        public const int MaxDegreeOfParallelism = 5;
+
+
+        public virtual void CalculateIntegerSumUpToNumber(SimpleMemory memory)
+        {
+            var number = memory.ReadUInt32(CalculateLargeIntegerSum_InputInt32Index);
+
+            var a = new Posit16E0((ushort)1);
+            var b = a;
+
+            for (uint i = 1; i < number; i++)
+            {
+                a += b;
+            }
+
+            var result = (int)a;
+            memory.WriteInt32(CalculateLargeIntegerSum_OutputInt32Index, result);
+        }
+
+        public virtual void CalculatePowerOfReal(SimpleMemory memory)
+        {
+            var number = memory.ReadInt32(CalculatePowerOfReal_InputInt32Index);
+            var positToMultiply = (ushort)memory.ReadUInt32(CalculatePowerOfReal_InputPosit32Index);
+
+            var a = new Posit16E0(positToMultiply, true);
+            var b = a;
+
+            for (uint i = 0; i < number; i++)
+            {
+                a *= b;
+            }
+
+            var result = a.PositBits;
+            memory.WriteUInt32(CalculatePowerOfReal_OutputPosit32Index, result);
+        }
+
+        public virtual void ParallelizedCalculateIntegerSumUpToNumbers(SimpleMemory memory)
+        {
+            var numbers = new int[MaxDegreeOfParallelism];
+
+            var tasks = new Task<int>[MaxDegreeOfParallelism];
+
+            for (int i = 0; i < MaxDegreeOfParallelism; i++)
+            {
+                var upToNumber = memory.ReadInt32(ParallelizedCalculateLargeIntegerSum_Int32NumbersStartIndex + i);
+
+                tasks[i] = Task.Factory.StartNew(
+                    upToNumberObject =>
+                    {
+                        var a = new Posit16E0(1);
+                        var b = a;
+
+                        for (int j = 1; j < (int)upToNumberObject; j++)
+                        {
+                            a += b;
+                        }
+
+                        return (int)a;
+                    }, upToNumber);
+            }
+
+            Task.WhenAll(tasks).Wait();
+
+            for (int i = 0; i < MaxDegreeOfParallelism; i++)
+            {
+                memory.WriteInt32(ParallelizedCalculateLargeIntegerSum_OutputInt32sStartIndex + i, tasks[i].Result);
+            }
+        }
+
+        public virtual void AddPositsInArray(SimpleMemory memory)
+        {
+            uint numberCount = memory.ReadUInt32(AddPositsInArray_InputPosit32CountIndex);
+
+            var result = new Posit16E0((ushort)memory.ReadUInt32(AddPositsInArray_InputPosit32sStartIndex), true);
+
+            for (int i = 1; i < numberCount; i++)
+            {
+                result += new Posit16E0((ushort)memory.ReadUInt32(AddPositsInArray_InputPosit32sStartIndex + i), true);
+            }
+
+            memory.WriteUInt32(AddPositsInArray_OutputPosit32Index, result.PositBits);
+        }
+    }
+
+
+    public static class Posit16E0CalculatorCalculatorExtensions
+    {
+        public static int CalculateIntegerSumUpToNumber(
+            this  Posit16E0Calculator  positCalculator,
+            int number,
+            IHastlayer hastlayer = null,
+            IHardwareGenerationConfiguration configuration = null)
+        {
+             var memory = hastlayer is null
+                ? SimpleMemory.CreateSoftwareMemory(1)
+                : hastlayer.CreateMemory(configuration, 1);
+
+            memory.WriteInt32( Posit16E0Calculator.CalculateLargeIntegerSum_InputInt32Index, number);
+            positCalculator.CalculateIntegerSumUpToNumber(memory);
+
+            return memory.ReadInt32( Posit16E0Calculator.CalculateLargeIntegerSum_OutputInt32Index);
+        }
+
+        public static float CalculatePowerOfReal(
+            this  Posit16E0Calculator  positCalculator,
+            int number,
+            float real,
+            IHastlayer hastlayer = null,
+            IHardwareGenerationConfiguration configuration = null)
+        {
+            var memory = hastlayer is null
+                ? SimpleMemory.CreateSoftwareMemory(2)
+                : hastlayer.CreateMemory(configuration, 2);
+
+            memory.WriteInt32( Posit16E0Calculator.CalculatePowerOfReal_InputInt32Index, number);
+            memory.WriteUInt32( Posit16E0Calculator.CalculatePowerOfReal_InputPosit32Index, new  Posit16E0(real).PositBits);
+
+            positCalculator.CalculatePowerOfReal(memory);
+
+            return (float)new Posit16E0((ushort)memory.ReadUInt32( Posit16E0Calculator.CalculatePowerOfReal_OutputPosit32Index), true);
+        }
+
+        public static IEnumerable<int> ParallelizedCalculateIntegerSumUpToNumbers(
+            this  Posit16E0Calculator positCalculator,
+            int[] numbers,
+            IHastlayer hastlayer = null,
+            IHardwareGenerationConfiguration configuration = null)
+        {
+            if (numbers.Length !=  Posit16E0Calculator.MaxDegreeOfParallelism)
+            {
+                throw new ArgumentException(
+                    "Provide as many numbers as the degree of parallelism of  Posit16E0Calculator is (" +
+                     Posit16E0Calculator.MaxDegreeOfParallelism + ")");
+            }
+
+            var memory = hastlayer is null
+                ? SimpleMemory.CreateSoftwareMemory(Posit16E0Calculator.MaxDegreeOfParallelism)
+                : hastlayer.CreateMemory(configuration, Posit16E0Calculator.MaxDegreeOfParallelism);
+
+            for (int i = 0; i < numbers.Length; i++)
+            {
+                memory.WriteInt32( Posit16E0Calculator.ParallelizedCalculateLargeIntegerSum_Int32NumbersStartIndex + i, numbers[i]);
+            }
+
+            positCalculator.ParallelizedCalculateIntegerSumUpToNumbers(memory);
+
+            var results = new int[ Posit16E0Calculator.MaxDegreeOfParallelism];
+
+            for (int i = 0; i < numbers.Length; i++)
+            {
+                results[i] = memory.ReadInt32( Posit16E0Calculator.ParallelizedCalculateLargeIntegerSum_OutputInt32sStartIndex + i);
+            }
+
+            return results;
+        }
+
+        public static float AddPositsInArray(
+            this  Posit16E0Calculator positCalculator,
+            uint[] positArray,
+            IHastlayer hastlayer = null,
+            IHardwareGenerationConfiguration configuration = null)
+        {
+            var memory = hastlayer is null
+                ? SimpleMemory.CreateSoftwareMemory(positArray.Length + 1)
+                : hastlayer.CreateMemory(configuration, positArray.Length + 1);
+
+            memory.WriteUInt32( Posit16E0Calculator.AddPositsInArray_InputPosit32CountIndex, (uint) positArray.Length);
+
+            for (var i = 0; i <  positArray.Length; i++)
+            {
+                memory.WriteUInt32( Posit16E0Calculator.AddPositsInArray_InputPosit32sStartIndex + i, positArray[i]);
+            }
+
+            positCalculator.AddPositsInArray(memory);
+
+            return (float)new Posit32(memory.ReadUInt32( Posit16E0Calculator.AddPositsInArray_OutputPosit32Index), true);
+        }
+    }
+}
+