sparsematrixasvector.cs

Data Structures and Algorithms with Object-Oriented Design Patterns in C# 这本书的范例代码dll自己反编译的source

namespace Opus6
{
    using System;
    using System.Reflection;
    using System.Runtime.InteropServices;

    [Copyright("Copyright (c) 2001 by Bruno R. Preiss, P.Eng."), Version("$Id: SparseMatrixAsVector.cs,v 1.5 2001/10/28 19:50:09 brpreiss Exp $")]
    public class SparseMatrixAsVector : SparseMatrix
    {
        public SparseMatrixAsVector(int numberOfRows, int numberOfColumns, int numberOfElements)
        {
            if (numberOfRows < 0)
            {
                throw new IndexOutOfRangeException();
            }
            if (numberOfColumns < 0)
            {
                throw new IndexOutOfRangeException();
            }
            this.numberOfRows = numberOfRows;
            this.numberOfColumns = numberOfColumns;
            this.array = new Opus6.SparseMatrixAsVector.Entry[numberOfElements];
            for (int num1 = 0; num1 < numberOfElements; num1++)
            {
                this.array[num1] = new Opus6.SparseMatrixAsVector.Entry();
            }
        }

        private int FindPosition(int i, int j)
        {
            int num1 = (i * this.numberOfColumns) + j;
            int num2 = 0;
            int num3 = this.numberOfElements - 1;
            while (num2 <= num3)
            {
                int num4 = (num2 + num3) / 2;
                int num5 = (this.array[num4].row * this.numberOfColumns) + this.array[num4].column;
                if (num1 > num5)
                {
                    num2 = num4 + 1;
                }
                else
                {
                    if (num1 < num5)
                    {
                        num3 = num4 - 1;
                        continue;
                    }
                    return num4;
                }
            }
            return -1;
        }

        public static void Main()
        {
            Matrix matrix1 = new SparseMatrixAsVector(6, 6, 12);
            Matrix.TestTranspose(matrix1);
            Matrix.TestTimes(matrix1, matrix1);
        }

        public override Matrix Plus(Matrix mat)
        {
            throw new MethodNotImplementedException();
        }

        public override void PutZero(int i, int j)
        {
            Bounds.Check(i, 0, this.numberOfRows);
            Bounds.Check(j, 0, this.numberOfColumns);
            int num1 = this.FindPosition(i, j);
            if (num1 >= 0)
            {
                this.numberOfElements--;
                int num2 = num1;
                while (num2 < this.numberOfElements)
                {
                    this.array[num2] = this.array[num2 + 1];
                    num2++;
                }
                this.array[num2] = new Opus6.SparseMatrixAsVector.Entry();
            }
        }

        public override Matrix Times(Matrix mat)
        {
            SparseMatrixAsVector vector1 = (SparseMatrixAsVector) mat;
            if (this.numberOfColumns != vector1.numberOfRows)
            {
                throw new ArgumentException("incompatible matrices");
            }
            SparseMatrixAsVector vector2 = (SparseMatrixAsVector) vector1.Transpose;
            SparseMatrixAsVector vector3 = new SparseMatrixAsVector(this.numberOfRows, vector2.numberOfRows, this.numberOfRows + vector2.numberOfRows);
            int num1 = 0;
            while (num1 < this.numberOfElements)
            {
                int num2 = this.array[num1].row;
                int num3 = 0;
                while (num3 < vector2.numberOfElements)
                {
                    int num4 = vector2.array[num3].row;
                    double num5 = 0;
                    int num6 = num1;
                    int num7 = num3;
                    while (((num6 < this.numberOfElements) && (this.array[num6].row == num2)) && ((num7 < vector2.numberOfElements) && (vector2.array[num7].row == num4)))
                    {
                        if (this.array[num6].column < vector2.array[num7].column)
                        {
                            num6++;
                        }
                        else
                        {
                            if (this.array[num6].column > vector2.array[num7].column)
                            {
                                num7++;
                                continue;
                            }
                            num5 += this.array[num6++].datum * vector2.array[num7++].datum;
                        }
                    }
                    if (num5 != 0)
                    {
                        vector3[num2, num4] = num5;
                    }
                    while ((num3 < vector2.numberOfElements) && (vector2.array[num3].row == num4))
                    {
                        num3++;
                    }
                }
                while ((num1 < this.numberOfElements) && (this.array[num1].row == num2))
                {
                    num1++;
                }
            }
            return vector3;
        }


        public override int Columns
        {
            get
            {
                return this.numberOfColumns;
            }
        }

        public override double this[int i, int j]
        {
            get
            {
                Bounds.Check(i, 0, this.numberOfRows);
                Bounds.Check(j, 0, this.numberOfColumns);
                int num1 = this.FindPosition(i, j);
                if (num1 >= 0)
                {
                    return this.array[num1].datum;
                }
                return 0;
            }
            set
            {
                Bounds.Check(i, 0, this.numberOfRows);
                Bounds.Check(j, 0, this.numberOfColumns);
                int num1 = this.FindPosition(i, j);
                if (num1 >= 0)
                {
                    this.array[num1].datum = value;
                }
                else
                {
                    if (this.array.Length == this.numberOfElements)
                    {
                        Opus6.SparseMatrixAsVector.Entry[] entryArray1 = new Opus6.SparseMatrixAsVector.Entry[2 * this.array.Length];
                        Array.Copy(this.array, entryArray1, this.array.Length);
                        for (int num2 = this.array.Length; num2 < entryArray1.Length; num2++)
                        {
                            entryArray1[num2] = new Opus6.SparseMatrixAsVector.Entry();
                        }
                        this.array = entryArray1;
                    }
                    int num3 = this.numberOfElements;
                    while ((num3 > 0) && ((this.array[num3 - 1].row > i) || ((this.array[num3 - 1].row == i) && (this.array[num3 - 1].column >= j))))
                    {
                        this.array[num3] = this.array[num3 - 1];
                        num3--;
                    }
                    this.array[num3] = new Opus6.SparseMatrixAsVector.Entry(i, j, value);
                    this.numberOfElements++;
                }
            }
        }

        public override int Rows
        {
            get
            {
                return this.numberOfRows;
            }
        }

        public override Matrix Transpose
        {
            get
            {
                int num7;
                SparseMatrixAsVector vector1 = new SparseMatrixAsVector(this.numberOfColumns, this.numberOfRows, this.numberOfElements);
                int[] numArray1 = new int[this.numberOfColumns];
                for (int num1 = 0; num1 < this.numberOfColumns; num1++)
                {
                    numArray1[num1] = 0;
                }
                for (int num2 = 0; num2 < this.numberOfElements; num2++)
                {
                    numArray1[num7 = this.array[num2].column] = numArray1[num7] + 1;
                }
                int num3 = 0;
                for (int num4 = 0; num4 < this.numberOfColumns; num4++)
                {
                    int num5 = numArray1[num4];
                    numArray1[num4] = num3;
                    num3 += num5;
                }
                for (int num6 = 0; num6 < this.numberOfElements; num6++)
                {
                    int[] numArray2;
                    int num8;
                    (numArray2 = numArray1)[num7 = this.array[num6].column] = (num8 = numArray2[num7]) + 1;
                    vector1.array[num8] = new Opus6.SparseMatrixAsVector.Entry(this.array[num6].column, this.array[num6].row, this.array[num6].datum);
                }
                vector1.numberOfElements = this.numberOfElements;
                return vector1;
            }
        }


        private Opus6.SparseMatrixAsVector.Entry[] array;
        private int numberOfColumns;
        private int numberOfElements;
        private int numberOfRows;


        [StructLayout(LayoutKind.Sequential)]
        private struct Entry
        {
            internal int row;
            internal int column;
            internal double datum;
            internal Entry(int row, int column, double datum)
            {
                this.row = row;
                this.column = column;
                this.datum = datum;
            }

        }
    }
}