コード例 #1
0
        public void ArraySupportShouldGetAndSetItems()
        {
            var array = new byte[2, 3, 4];
            array[0, 0, 3] = 3;
            array[0, 2, 3] = 23;
            array[1, 1, 2] = 112;

            var test = new byte[2, 3, 4];

            var arraySupport = new ArraySupport();

            var items = arraySupport.GetItems(array);
            arraySupport.SetItems(test, items);

            var matches = true;
            var arrayList = array.ToSimpleList();
            var testList = test.ToSimpleList();
            for (var i = 0; i < array.Length; i++)
            {
                var itemA = arrayList[i];
                var itemB = testList[i];
                if (itemA.Equals(itemB)) continue;

                matches = false;
                break;
            }

            Assert.IsTrue(matches);
        }
コード例 #2
0
        /// <summary> Tries to find the row-index in the given column. If it is not found,
        /// a reallocation is done, and a new index is returned.</summary>
        private int GetRowIndex(int row, int col)
        {
            int[]    curRow = _rowIndex[col];
            double[] curDat = _data[col];

            // Try to find column index
            int ind = ArraySupport.BinarySearchGreater(curRow, row, 0, _used[col]);

            // Found
            if (ind < _used[col] && curRow[ind] == row)
            {
                return(ind);
            }

            // Not found, try to make room
            if (row < 0 || row >= row_count)
            {
                throw new IndexOutOfRangeException(" Row " + row + " Column " + col);
            }
            _used[col]++;

            // Check available memory
            if (_used[col] > curDat.Length)
            {
                // If zero-length, use new length of 1, else double the bandwidth
                int newLength = 1;
                if (curDat.Length != 0)
                {
                    newLength = 2 * curDat.Length;
                }

                // Copy existing data into new arrays
                int[]    newRow = new int[newLength];
                double[] newDat = new double[newLength];
                Array.Copy(curRow, 0, newRow, 0, curDat.Length);
                Array.Copy(curDat, 0, newDat, 0, curDat.Length);

                // Update pointers
                _rowIndex[col] = newRow;
                _data[col]     = newDat;
                curRow         = newRow;
                curDat         = newDat;
            }

            // All ok, make room for insertion
            for (int i = _used[col] - 1; i >= ind + 1; --i)
            {
                curRow[i] = curRow[i - 1];
                curDat[i] = curDat[i - 1];
            }

            // Put in new structure
            curRow[ind] = row;
            curDat[ind] = 0.0;
            _isCompact  = false;

            return(ind);
        }
コード例 #3
0
        /// <summary> Tries to find the index. If it is not found, a reallocation is done, and
        /// a new index is returned.</summary>
        private int GetIndex(int index)
        {
            // Try to find column index
            int i = ArraySupport.BinarySearchGreater(_ind, index, 0, _used);

            // Found
            if (i < _used && _ind[i] == index)
            {
                return(i);
            }

            // Not found, try to make room
            if (index < 0 || index >= _length)
            {
                throw new IndexOutOfRangeException("Index " + index);
            }
            _used++;

            // Check available memory
            if (_used > _data.Length)
            {
                // If zero-length, use new length of 1, else double the bandwidth
                int newLength = 1;
                if (_data.Length != 0)
                {
                    newLength = 2 * _data.Length;
                }

                // Copy existing data into new arrays
                int[]    newInd = new int[newLength];
                double[] newDat = new double[newLength];
                Array.Copy(_ind, 0, newInd, 0, _data.Length);
                Array.Copy(_data, 0, newDat, 0, _data.Length);

                // Update pointers
                _ind  = newInd;
                _data = newDat;
            }

            // All ok, make room for insertion
            for (int j = _used - 1; j >= i + 1; --j)
            {
                _ind[j]  = _ind[j - 1];
                _data[j] = _data[j - 1];
            }

            // Put in new structure
            _ind[i]  = index;
            _data[i] = 0.0;
            return(i);
        }
コード例 #4
0
        public virtual double GetValue(int index)
        {
            int inRenamed = ArraySupport.BinarySearch(_ind, index, 0, _used);

            if (inRenamed != -1)
            {
                return(_data[inRenamed]);
            }
            if (index < _length && index >= 0)
            {
                return(0.0);
            }
            throw new IndexOutOfRangeException("Index " + index);
        }
コード例 #5
0
        public virtual double GetValue(int row, int column)
        {
            int ind = ArraySupport.BinarySearch(_columnIndex[row], column, 0, _used[row]);

            if (ind != -1)
            {
                return(_data[row][ind]);
            }
            if (column < column_count && column >= 0)
            {
                return(0.0);
            }
            throw new IndexOutOfRangeException("Row " + row + " Column " + column);
        }
コード例 #6
0
        public virtual double GetValue(int row, int column)
        {
            int ind = ArraySupport.BinarySearch(_rowIndex[column], row, 0, _used[column]);

            if (ind != -1)
            {
                return(_data[column][ind]);
            }
            if (row < row_count && row >= 0)
            {
                return(0.0);
            }
            throw new IndexOutOfRangeException("Row " + row + " Column " + column);
        }
コード例 #7
0
        /// <summary> Tries to find the col-index in the given row. If it is not found,
        /// a reallocation is done, and a new index is returned. If there is no more
        /// space for further allocation, an exception is thrown.</summary>
        private int GetColumnIndex(int col, int row)
        {
            int rowOffset = _rowIndices[row];

            int ind = ArraySupport.BinarySearchGreater(_columnIndices, col,
                                                       rowOffset, rowOffset + _used[row]) - rowOffset;

            // Found
            if (ind < _used[row] && _columnIndices[rowOffset + ind] == col)
            {
                return(ind);
            }

            // Need to insert

            // Check column index
            if (col < 0 || col >= column_count)
            {
                throw new IndexOutOfRangeException("Row " + row + " Column " + col);
            }

            // Is the row full?
            if (rowOffset + _used[row] >= _data.Length || ((row + 1) < _rowIndices.Length &&
                                                           rowOffset + _used[row] >= _rowIndices[row + 1]))
            {
                throw new IndexOutOfRangeException("Too many non-zeros on row " + row);
            }

            // Make room for insertion
            for (int i = _used[row]; i >= ind + 1; --i)
            {
                _columnIndices[rowOffset + i] = _columnIndices[rowOffset + i - 1];
                _data[rowOffset + i]          = _data[rowOffset + i - 1];
            }

            // Put in new structure
            _used[row]++;
            _columnIndices[rowOffset + ind] = col;
            _data[rowOffset + ind]          = 0;
            _isCompact = false;

            return(ind);
        }
コード例 #8
0
        /// <summary> Tries to find the col-index in the given row. If it is not found,
        /// a reallocation is done, and a new index is returned. If there is no more
        /// space for further allocation, an exception is thrown.
        /// </summary>
        private int GetRowIndex(int row, int col)
        {
            int columnOffset = _columnIndex[col];

            int ind = ArraySupport.BinarySearchGreater(_rowIndex, row, columnOffset, columnOffset + _used[col]) - columnOffset;

            // Found
            if (ind < _used[col] && _rowIndex[columnOffset + ind] == row)
            {
                return(ind);
            }

            // Need to insert

            // Check row index
            if (row < 0 || row >= row_count)
            {
                throw new IndexOutOfRangeException("Row " + row + " Column " + col);
            }

            // Is the column full?
            if (columnOffset + _used[col] >= _data.Length || ((col + 1) < _columnIndex.Length && columnOffset + _used[col] >= _columnIndex[col + 1]))
            {
                throw new IndexOutOfRangeException("Too many non-zeros on column " + col);
            }

            // Make room for insertion
            for (int i = _used[col]; i >= ind + 1; --i)
            {
                _rowIndex[columnOffset + i] = _rowIndex[columnOffset + i - 1];
                _data[columnOffset + i]     = _data[columnOffset + i - 1];
            }

            // Put in new structure
            _used[col]++;
            _rowIndex[columnOffset + ind] = row;
            _data[columnOffset + ind]     = 0;
            _isCompact = false;

            return(ind);
        }
コード例 #9
0
 public void ArraySupportKnowsTheLengthOfAnyArray()
 {
     var arraySupport = new ArraySupport();
     var array = new byte[2, 3, 4];
     Assert.AreEqual(array.Length, arraySupport.GetLength(array));
 }
コード例 #10
0
 public void ArraySupportKnowsTheEnumerableMarkOfItself()
 {
     var arraySupport = new ArraySupport();
     Assert.AreEqual(ComplexTypeMark.Array, arraySupport.ComplexTypeMark);
 }