using System;

using NUnit.Framework;

using NUnitLite;

​

​

using System;

​

public class LSTMCell

{

    private readonly double[,] Wi;

    private readonly double[,] Wf;

    private readonly double[,] Wc;

    private readonly double[,] Wo;

​

    private readonly double[] bi;

    private readonly double[] bf;

    private readonly double[] bc;

    private readonly double[] bo;

​

    private const int InputSize = 1;

    private const int HiddenSize = 1;

​

    public LSTMCell()

    {

        // Initialize weights and biases with 0.5

        Wi = InitializeMatrix(HiddenSize + InputSize, HiddenSize, 0.5);

        Wf = InitializeMatrix(HiddenSize + InputSize, HiddenSize, 0.5);

        Wc = InitializeMatrix(HiddenSize + InputSize, HiddenSize, 0.5);

        Wo = InitializeMatrix(HiddenSize + InputSize, HiddenSize, 0.5);

​

        bi = InitializeArray(HiddenSize, 0.5);

        bf = InitializeArray(HiddenSize, 0.5);

        bc = InitializeArray(HiddenSize, 0.5);

        bo = InitializeArray(HiddenSize, 0.5);

    }

​

    private double[,] InitializeMatrix(int rows, int cols, double value)

    {

        double[,] matrix = new double[rows, cols];

        for (int i = 0; i < rows; i++)

        {

            for (int j = 0; j < cols; j++)

            {

                matrix[i, j] = value;

            }

        }

        return matrix;

    }

​

    private double[] InitializeArray(int size, double value)

    {

        double[] array = new double[size];

        for (int i = 0; i < size; i++)

        {

            array[i] = value;

        }

        return array;

    }

​

    private double Sigmoid(double x)

    {

        return 1 / (1 + Math.Exp(-x));

    }

​

    private double Tanh(double x)

    {

        return Math.Tanh(x);

    }

​

    public double Process(double input, double previousHiddenState, double previousCellState)

    {

        // Concatenate previous hidden state and input

        double[] concat = new double[HiddenSize + InputSize];

        concat[0] = previousHiddenState;

        concat[1] = input;

​

        // Input gate

        double it = Sigmoid(MatrixVectorProduct(Wi, concat)[0] + bi[0]);

​

        // Forget gate

        double ft = Sigmoid(MatrixVectorProduct(Wf, concat)[0] + bf[0]);

​

        // Candidate cell state

        double ct_candidate = Tanh(MatrixVectorProduct(Wc, concat)[0] + bc[0]);

​

        // Cell state

        double ct = ft * previousCellState + it * ct_candidate;

​

        // Output gate

        double ot = Sigmoid(MatrixVectorProduct(Wo, concat)[0] + bo[0]);

​

        // Hidden state

        double ht = ot * Tanh(ct);

​

        return ht;

    }

​

    private double[] MatrixVectorProduct(double[,] matrix, double[] vector)

    {

        int rows = matrix.GetLength(0);

        int cols = matrix.GetLength(1);

        int vectorSize = vector.Length;

​

        if (rows != vectorSize)

        {

            throw new ArgumentException("Matrix and vector dimensions are incompatible.");

        }

​

        double[] result = new double[cols];

​

        for (int j = 0; j < cols; j++)

        {

            double sum = 0;

            for (int i = 0; i < rows; i++)

            {

                sum += matrix[i, j] * vector[i];

            }

            result[j] = sum;

        }

​

        return result;

    }

​

}

​

​

[TestFixture]

public class LSTMCellTests

{

    [Test]

    public void Process_PositiveInput_ReturnsExpectedHiddenState()

    {

        // Arrange

        LSTMCell lstmCell = new LSTMCell();

        double input = 0.5;

        double previousHiddenState = 0.1;

        double previousCellState = 0.0;

​

        // Act

        double newHiddenState = lstmCell.Process(input, previousHiddenState, previousCellState);

​

        // Assert

        Assert.That(newHiddenState, Is.Not.NaN);

    }

​

    [Test]

    public void Process_ZeroInput_ReturnsExpectedHiddenState()

    {

        // Arrange

        LSTMCell lstmCell = new LSTMCell();

        double input = 0.0;

        double previousHiddenState = 0.0;

        double previousCellState = 0.0;

​

        // Act

        double newHiddenState = lstmCell.Process(input, previousHiddenState, previousCellState);

​

        // Assert

        Assert.That(newHiddenState, Is.Not.NaN);

    }

​

    [Test]

    public void Process_LargeInput_ReturnsExpectedHiddenState()

    {

        // Arrange

        LSTMCell lstmCell = new LSTMCell();

        double input = 100.0;

        double previousHiddenState = 10.0;

        double previousCellState = 1.0;

​

        // Act

        double newHiddenState = lstmCell.Process(input, previousHiddenState, previousCellState);

​

        // Assert

        Assert.That(newHiddenState, Is.Not.NaN);

    }

​

    [Test]

    public void Process_NegativeInput_ReturnsExpectedHiddenState()

    {

        // Arrange

        LSTMCell lstmCell = new LSTMCell();

        double input = -0.5;

        double previousHiddenState = -0.1;

        double previousCellState = -0.0;

​

        // Act

        double newHiddenState = lstmCell.Process(input, previousHiddenState, previousCellState);

​

        // Assert

        Assert.That(newHiddenState, Is.Not.NaN);

    }

​

    [Test]

    public void Process_NaNInput_ReturnsNaN()

    {

        // Arrange

        LSTMCell lstmCell = new LSTMCell();

        double input = double.NaN;

        double previousHiddenState = 0.1;

        double previousCellState = 0.0;

​

        // Act

        double newHiddenState = lstmCell.Process(input, previousHiddenState, previousCellState);

​

        // Assert

        Assert.That(newHiddenState, Is.NaN);

    }

​

    [Test]

    public void Process_MaxValueInput_ReturnsExpectedHiddenState()

    {

        // Arrange

        LSTMCell lstmCell = new LSTMCell();

        double input = double.MaxValue;

        double previousHiddenState = 0.1;

        double previousCellState = 0.0;

​

        // Act

        double newHiddenState = lstmCell.Process(input, previousHiddenState, previousCellState);

​

        // Assert

        Assert.That(newHiddenState, Is.Not.NaN);

    }

​

    [Test]

    public void Process_MinValueInput_ReturnsExpectedHiddenState()

    {

        // Arrange

        LSTMCell lstmCell = new LSTMCell();

        double input = double.MinValue;

        double previousHiddenState = 0.1;

        double previousCellState = 0.0;

​

        // Act

        double newHiddenState = lstmCell.Process(input, previousHiddenState, previousCellState);

​

        // Assert

        Assert.That(newHiddenState, Is.Not.NaN);

    }

​

    [Test]

    public void Process_DifferentPreviousStates_ReturnsDifferentHiddenState()

    {

        // Arrange

        LSTMCell lstmCell = new LSTMCell();

        double input = 0.5;

        double previousHiddenState1 = 0.1;

        double previousCellState1 = 0.0;

        double previousHiddenState2 = 0.2;

        double previousCellState2 = 0.1;

​

        // Act

        double newHiddenState1 = lstmCell.Process(input, previousHiddenState1, previousCellState1);

        double newHiddenState2 = lstmCell.Process(input, previousHiddenState2, previousCellState2);

​

        // Assert

        Assert.That(newHiddenState1, Is.Not.EqualTo(newHiddenState2));

    }

}

​

public class Program

{

      public static int Main(string[] args)

    {

        return new AutoRun().Execute(args);

    }

}