}         // constructor

        public virtual decimal?this[decimal rowValeRaw, decimal columnValeRaw] {
            get {
                if (!IsInitialized)
                {
                    throw new Exception("Matrix was not initialized");
                }

                var rowValue = new DecimalIntervalMatrixIntervalEdge(rowValeRaw);

                DecimalIntervalMatrixColumn column = null;

                foreach (KeyValuePair <DecimalIntervalMatrixInterval, DecimalIntervalMatrixColumn> pair in this.data)
                {
                    var rowInterval = pair.Key;

                    if (!rowInterval.Contains(rowValue))
                    {
                        continue;
                    }

                    column = pair.Value;
                    break;
                }                 // for each

                if (column == null)
                {
                    return(null);
                }

                var columnValue = new DecimalIntervalMatrixIntervalEdge(columnValeRaw);

                foreach (KeyValuePair <DecimalIntervalMatrixInterval, decimal?> pair in column)
                {
                    if (pair.Key.Contains(columnValue))
                    {
                        return(pair.Value);
                    }
                }                 // for each

                return(null);
            }     // get
        }         // indexer
        }         // IsInitialized

        protected virtual void AddValue(decimal?rowTitleValueRaw, decimal?columnTitleValueRaw, decimal?cellValue)
        {
            DecimalIntervalMatrixIntervalEdge rowTitleValue = rowTitleValueRaw == null
                                ? new DecimalIntervalMatrixIntervalEdge(true)
                                : new DecimalIntervalMatrixIntervalEdge(rowTitleValueRaw.Value);

            if (rowTitleValue <= MinRowTitleValue)
            {
                return;
            }

            DecimalIntervalMatrixIntervalEdge columnTitleValue = columnTitleValueRaw == null
                                ? new DecimalIntervalMatrixIntervalEdge(true)
                                : new DecimalIntervalMatrixIntervalEdge(columnTitleValueRaw.Value);

            if (columnTitleValue <= MinColumnTitleValue)
            {
                return;
            }

            this.rawData[rowTitleValue, columnTitleValue] = cellValue;
        }         // AddValue
        }         // AddValue

        protected virtual bool Init()
        {
            IsInitialized = false;
            this.data.Clear();

            if (!this.rawData.HasAlignedColumns())
            {
                return(IsInitialized);
            }

            DecimalIntervalMatrixIntervalEdge prevRowTitle = MinRowTitleValue;

            this.rawData.ForEachRow((curRowTitle, curRow) => {
                DecimalIntervalMatrixIntervalEdge prevColumnTitle = MinColumnTitleValue;

                var column = new DecimalIntervalMatrixColumn();

                this.data[new DecimalIntervalMatrixInterval(prevRowTitle, curRowTitle)] = column;

                foreach (var pair in curRow)
                {
                    var curColumnTitle = pair.Key;

                    column[new DecimalIntervalMatrixInterval(prevColumnTitle, curColumnTitle)] = pair.Value;

                    prevColumnTitle = curColumnTitle;
                }                 // for each column

                prevRowTitle = curRowTitle;
            });

            this.rawData.Clear();
            IsInitialized = true;

            return(IsInitialized);
        }         // Init
 public DecimalIntervalMatrixInterval(
     DecimalIntervalMatrixIntervalEdge left,
     DecimalIntervalMatrixIntervalEdge right
     ) : base(left, right)
 {
 }                                // constructor