Exemple #1
0
        /// <summary>
        /// Obtém um vector com todos os elementos de uma linha, incluindo os valores por defeito.
        /// </summary>
        /// <typeparam name="T">O tipo de objectos que constituem as entradas da matriz.</typeparam>
        /// <param name="line">A linha.</param>
        /// <param name="matrix">A matriz.</param>
        /// <returns>O vector com as entradas correspondentes à linha da matriz especificada.</returns>
        private T[] GetLineAsArray <T>(int line, SparseDictionaryMathMatrix <T> matrix)
        {
            var matrixColumnsNumber = matrix.GetLength(1);
            var currentMatrixLine   = default(ILongSparseMatrixLine <T>);
            var result = new T[matrixColumnsNumber];

            if (matrix.TryGetLine(line, out currentMatrixLine))
            {
                for (int i = 0; i < matrixColumnsNumber; ++i)
                {
                    var currentValue = default(T);
                    if (currentMatrixLine.TryGetColumnValue(i, out currentValue))
                    {
                        result[i] = currentMatrixLine[i];
                    }
                    else
                    {
                        result[i] = matrix.DefaultValue;
                    }
                }
            }
            else
            {
                for (int i = 0; i < result.Length; ++i)
                {
                    result[i] = matrix.DefaultValue;
                }
            }

            return(result);
        }
Exemple #2
0
        /// <summary>
        /// Verifica a validade da combinação de uma linha com a próxima tendo em conta os factores proporcionados.
        /// </summary>
        /// <typeparam name="T">O tipo de objectos que constituem as entradas das matrizes.</typeparam>
        /// <param name="target">A matriz.</param>
        /// <param name="firstFactor">O factor afecto à linha a ser substituída.</param>
        /// <param name="secondFactor">O factor afecto à linha a ser combinada.</param>
        /// <param name="ring">O anel responsável pelas operações sobre os coeficientes.</param>
        private void AssertTarget <T>(
            SparseDictionaryMathMatrix <T> target,
            T firstFactor,
            T secondFactor,
            IRing <T> ring)
        {
            var numberOfLines   = target.GetLength(0);
            var numberOfColumns = target.GetLength(1);

            var firstLine  = 0;
            var secondLine = 1;

            while (secondLine < numberOfLines)
            {
                var firstArray  = this.GetLineAsArray(firstLine, target);
                var secondArray = this.GetLineAsArray(secondLine, target);
                this.CombineArrays(firstArray, secondArray, firstFactor, secondFactor, ring);

                target.CombineLines(firstLine, secondLine, firstFactor, secondFactor, ring);

                var targetLine = default(ILongSparseMatrixLine <T>);
                if (target.TryGetLine(firstLine, out targetLine))
                {
                    for (int i = 0; i < numberOfColumns; ++i)
                    {
                        var targetValue = default(T);
                        if (!targetLine.TryGetColumnValue(i, out targetValue))
                        {
                            targetValue = target.DefaultValue;
                        }

                        Assert.AreEqual(firstArray[i], targetValue);
                    }
                }
                else
                {
                    for (int i = 0; i < numberOfColumns; ++i)
                    {
                        Assert.AreEqual(firstArray[i], target.DefaultValue);
                    }
                }

                ++firstLine;
                ++secondLine;
            }
        }