예제 #1
0
파일: AlgTopNH.cs 프로젝트: Lannyland/IPPA
 // Constructor
 public AlgTopNH(PathPlanningRequest _curRequest, int _ModeCount, RtwMatrix _mModes, RtwMatrix _mDistReachable, 
     RtwMatrix _mDiffReachable, double _Efficiency_UB)
     : base(_curRequest, _mDistReachable, _mDiffReachable, _Efficiency_UB)
 {
     ModeCount = _ModeCount;
     mModes = _mModes;
 }
예제 #2
0
 // Constructor
 public ComputeEfficiencyUB(PathPlanningRequest _curRequest, RtwMatrix _mDistReachable, RtwMatrix _mDiffReachable)
 {
     curRequest = _curRequest;
     mDistReachable = _mDistReachable;
     mDiffReachable = _mDiffReachable;
     Compute();
 }
예제 #3
0
 // Constructor
 public AlgSearchReverse(PathPlanningRequest _curRequest, int _ModeCount, RtwMatrix _mMode, 
     RtwMatrix _mDistReachable, RtwMatrix _mDiffReachable, double _Efficiency_UB)
     : base(_curRequest, _mDistReachable, _mDiffReachable, _Efficiency_UB)
 {
     ModeCount = _ModeCount;
     mMode = _mMode;
 }
예제 #4
0
파일: MapModes.cs 프로젝트: Lannyland/IPPA
 // Constructor
 public MapModes(int _ModeCount, RtwMatrix _mModes, PathPlanningRequest _curRequest)
 {
     ModeCount = _ModeCount;
     mModes = _mModes;
     curRequest = _curRequest;
     N = curRequest.TopN;
     FindTopNModes();
 }
예제 #5
0
 // Scale matrix back
 public static void ScaleBack(ref RtwMatrix matrixOut, float max)
 {
     for (int y = 0; y < matrixOut.Rows; y++)
     {
         for (int x = 0; x < matrixOut.Columns; x++)
         {
             matrixOut[y, x] = matrixOut[y, x] / 255 * max;
         }
     }
 }
예제 #6
0
 // Constructor
 public PathPlanningTask(PathPlanningRequest _curRequest, int _ModeCount, RtwMatrix _mModes,
     RtwMatrix _mDistReachable, RtwMatrix _mDiffReachable, double _Efficiency_UB)
 {
     curRequest = _curRequest;
     ModeCount = _ModeCount;
     mModes = _mModes;
     mDistReachable = _mDistReachable;
     mDiffReachable = _mDiffReachable;
     Efficiency_UB = _Efficiency_UB;
 }
예제 #7
0
 // Constructor
 public AlgGlobalWarming(PathPlanningRequest _curRequest, int _ModeCount, 
     RtwMatrix _mDistReachable, RtwMatrix _mDiffReachable, double _Efficiency_UB)
     : base(_curRequest, _mDistReachable, _mDiffReachable, _Efficiency_UB)
 {
     ModeCount = _ModeCount;
     GWCount = ProjectConstants.GWCount;
     ConvCount = ProjectConstants.ConvCount;
     CTFGWCoraseLevel = ProjectConstants.CTFGWCoraseLevel;
     CTFGWLevelCount = ProjectConstants.CTFGWLevelCount;
     PFCount = ProjectConstants.PFCount;
 }
예제 #8
0
파일: ImgLib.cs 프로젝트: Lannyland/IPPA
        // Static function to convert matrix back to gray bitmap image
        public static void MatrixToImage(ref RtwMatrix m, ref Bitmap bm)
        {
            for (int y = 0; y < m.Rows; y++)
            {
                for (int x = 0; x < m.Columns; x++)
                {
                    int grayScale = Convert.ToInt32(m[y, x]);

                    Color c = Color.FromArgb(grayScale, grayScale, grayScale);
                    bm.SetPixel(x, y, c);
                }
            }
        }
예제 #9
0
파일: ImgLib.cs 프로젝트: Lannyland/IPPA
 // Static function to convert bitmap image object to matrix
 public static RtwMatrix ImageToMatrix(ref Bitmap bm)
 {
     RtwMatrix m = new RtwMatrix(bm.Height, bm.Width);
     for (int y = 0; y < bm.Size.Height; y++)
     {
         for (int x = 0; x < bm.Size.Width; x++)
         {
             Color c = bm.GetPixel(x, y);
             m[y, x] = (float)c.R;
         }
     }
     return m;
 }
예제 #10
0
        // Constructor
        public AlgPathPlanning(PathPlanningRequest _curRequest,
            RtwMatrix _mDist, RtwMatrix _mDiff, double _Efficiency_UB)
        {
            // Start timer
            startTime = DateTime.Now;

            curRequest = _curRequest;
            mDist = _mDist;
            mDiff = _mDiff;
            // Clone distribution map so we can modify it
            mCurDist = mDist.Clone();
            Efficiency_UB = _Efficiency_UB;
        }
예제 #11
0
 // Method to convert Protocal Buffer version of Matrix to RtwMatrix
 public static RtwMatrix PBMatrixToRtwMatrix(ProtoBuffer.PathPlanningRequest.Types.Matrix mPB)
 {
     RtwMatrix mMap = null;
     if (mPB.RowList.Count > 0)
     {
         mMap = new RtwMatrix(mPB.RowList.Count, mPB.RowList[0].CellList.Count);
         for (int i = 0; i < mPB.RowList.Count; i++)
         {
             for (int j = 0; j < mPB.RowList[0].CellList.Count; j++)
             {
                 mMap[i, j] = mPB.RowList[i].CellList[j];
             }
         }
     }
     return mMap;
 }
예제 #12
0
파일: AlgTopTwo.cs 프로젝트: Lannyland/IPPA
        public AlgTopTwo(MapModes _curModes, PathPlanningRequest _curRequest, int _ModeCount, RtwMatrix _mModes, RtwMatrix _mDistReachable,
            RtwMatrix _mDiffReachable, double _Efficiency_UB)
            : base(_curRequest, _mDistReachable, _mDiffReachable, _Efficiency_UB)
        {
            // Start timer
            //DateTime startTime = DateTime.Now;
            myModes = _curModes;
            //DateTime stopTime = DateTime.Now;
            //TimeSpan duration = stopTime - startTime;
            //double RunTime = duration.TotalSeconds;
            //System.Windows.Forms.MessageBox.Show("Run time " + RunTime + " seconds!");

            CTFTTCoraseLevel = ProjectConstants.CTFTTCoraseLevel;
            CTFTTLevelCount = ProjectConstants.CTFTTLevelCount;
            mDistAfterSeg1Seg4 = mDist;
        }
예제 #13
0
파일: AlgTopN.cs 프로젝트: Lannyland/IPPA
        public AlgTopN(MapModes _curModes, PathPlanningRequest _curRequest, int _ModeCount, RtwMatrix _mModes, RtwMatrix _mDistReachable,
            RtwMatrix _mDiffReachable, double _Efficiency_UB)
            : base(_curRequest, _mDistReachable, _mDiffReachable, _Efficiency_UB)
        {
            //DateTime startTime = DateTime.Now;
            myModes = _curModes;
            //DateTime stopTime = DateTime.Now;
            //TimeSpan duration = stopTime - startTime;
            //double RunTime = duration.TotalSeconds;
            //System.Windows.Forms.MessageBox.Show("Run time " + RunTime + " seconds!");

            Start = new Point(curRequest.pStart.column, curRequest.pStart.row);
            if (curRequest.UseEndPoint)
            {
                End = new Point(curRequest.pEnd.column, curRequest.pEnd.row);
            }
            N = curRequest.TopN;
        }
예제 #14
0
 // Method to convert RtwMatrix to Protocal Buffer version of Matrix
 private static ProtoBuffer.PathPlanningRequest.Types.Matrix RtwMatrixToPBMatrix(RtwMatrix m)
 {
     ProtoBuffer.PathPlanningRequest.Types.Matrix.Builder newMBuilder = ProtoBuffer.PathPlanningRequest.Types.Matrix.CreateBuilder();
     for (int i = 0; i < m.Rows; i++)
     {
         ProtoBuffer.PathPlanningRequest.Types.MatrixRow.Builder rowBuilder = ProtoBuffer.PathPlanningRequest.Types.MatrixRow.CreateBuilder();
         for (int j = 0; j < m.Columns; j++)
         {
             rowBuilder.AddCell(m[i, j]);
         }
         ProtoBuffer.PathPlanningRequest.Types.MatrixRow newRow = rowBuilder.Build();
         rowBuilder = null;
         newMBuilder.AddRow(newRow);
     }
     ProtoBuffer.PathPlanningRequest.Types.Matrix newM = newMBuilder.Build();
     newMBuilder = null;
     return newM;
 }
예제 #15
0
        protected float GetPartialDetection(Point p, RtwMatrix m)
        {
            float original = 0;
            float current = m[p.Y, p.X];
            float amountToDeduct = 0;

            // Always do fixed percent of remaining for DiffRates
            // Based on detection type, compute differently
            switch (curRequest.DetectionType)
            {
                case DType.FixAmount:
                    // Ignore task-difficulty map
                    amountToDeduct = (float)curRequest.DetectionRate;
                    break;
                case DType.FixAmountInPercentage:
                    if (curRequest.UseTaskDifficultyMap)
                    {
                        original = mDistReachable[p.Y, p.X];
                        amountToDeduct = (float)(original * curRequest.DiffRates[Convert.ToInt32(mDiffReachable[p.Y, p.X])] * curRequest.DetectionRate);
                    }
                    else
                    {
                        amountToDeduct = (float)(current * curRequest.DetectionRate);
                    }
                    break;
                case DType.FixPercentage:
                    if (curRequest.UseTaskDifficultyMap)
                    {
                        amountToDeduct = (float)(current * curRequest.DiffRates[Convert.ToInt32(mDiffReachable[p.Y, p.X])] * curRequest.DetectionRate);
                    }
                    else
                    {
                        amountToDeduct = (float)(current * curRequest.DetectionRate);
                    }
                    break;
            }
            if (amountToDeduct > current)
            {
                amountToDeduct = current;
            }
            return amountToDeduct;
        }
예제 #16
0
파일: RtwMatrix.cs 프로젝트: Lannyland/IPPA
        //inverse
        public static RtwMatrix operator !(RtwMatrix mtx)
        {
            if(mtx.Determinant() == 0)
                throw new RtwMatrixException("Attempt to invert a singular matrix");
                //return null;

            //inverse of a 2x2 matrix
            if(mtx.Rows == 2 && mtx.Columns == 2)
            {
                RtwMatrix tempMtx = new RtwMatrix(2,2);

                tempMtx[0,0] = mtx[1,1];
                tempMtx[0,1] = -mtx[0,1];
                tempMtx[1,0] = -mtx[1,0];
                tempMtx[1,1] = mtx[0,0];

                return tempMtx / mtx.Determinant();
            }

            return mtx.Adjoint()/mtx.Determinant();
        }
예제 #17
0
파일: RtwMatrix.cs 프로젝트: Lannyland/IPPA
        //returns a minor of a matrix with respect to an element
        public RtwMatrix Minor(int row, int column)
        {
            if(this.Rows < 2 || this.Columns < 2)
                throw new RtwMatrixException("Minor not available");

            int i, j = 0;

            RtwMatrix minorMtx = new RtwMatrix(this.Rows - 1, this.Columns - 1);

            //find the minor with respect to the first element
            for(int k = 0; k < minorMtx.Rows; k++)
            {

                if(k >= row)
                    i = k + 1;
                else
                    i = k;

                for(int l = 0; l < minorMtx.Columns; l++)
                {
                    if(l >= column)
                        j = l + 1;
                    else
                        j = l;

                    minorMtx[k,l] = this[i,j];
                }

            }

            return minorMtx;
        }
예제 #18
0
파일: RtwMatrix.cs 프로젝트: Lannyland/IPPA
        //determinent
        public float Determinant()
        {
            float determinent = 0;

            if(this.Rows != this.Columns)
                throw new RtwMatrixException("Attempt to find the determinent of a non square matrix");
                //return 0;

            //get the determinent of a 2x2 matrix
            if(this.Rows == 2 && this.Columns == 2)
            {
                determinent = (this[0,0] * this[1,1]) - (this[0,1] * this[1,0]);
                return determinent;
            }

            RtwMatrix tempMtx = new RtwMatrix(this.Rows - 1, this.Columns - 1);

            //find the determinent with respect to the first row
            for(int j = 0; j < this.Columns; j++)
            {

                tempMtx = this.Minor(0, j);

                //recursively add the determinents
                determinent += (int)Math.Pow(-1, j) * this[0,j] * tempMtx.Determinant();

            }

            return determinent;
        }
예제 #19
0
파일: RtwMatrix.cs 프로젝트: Lannyland/IPPA
 //clone matrix
 public RtwMatrix Clone()
 {
     RtwMatrix new_matrix = new RtwMatrix(this.Rows, this.Columns);
     for (int i = 0; i < new_matrix.Rows; i++)
     {
         for (int j = 0; j < new_matrix.Columns; j++)
         {
             new_matrix[i, j] = this[i, j];
         }
     }
     return new_matrix;
 }
예제 #20
0
파일: RtwMatrix.cs 프로젝트: Lannyland/IPPA
        //adjoint matrix
        public RtwMatrix Adjoint()
        {
            if(this.Rows < 2 || this.Columns < 2)
                throw new RtwMatrixException("Adjoint matrix not available");

            RtwMatrix tempMtx = new RtwMatrix(this.Rows-1 , this.Columns-1);
            RtwMatrix adjMtx = new RtwMatrix (this.Columns , this.Rows);

            for(int i = 0; i < this.Rows; i++)
            {
                for(int j = 0; j < this.Columns;j++)
                {

                    tempMtx = this.Minor(i, j);

                    //put the determinent of the minor in the transposed position
                    adjMtx[j,i] = (int)Math.Pow(-1,i+j) * tempMtx.Determinant();
                }
            }

            return adjMtx;
        }
예제 #21
0
파일: RtwMatrix.cs 프로젝트: Lannyland/IPPA
        //transpose
        public static RtwMatrix operator ~(RtwMatrix mtx)
        {
            RtwMatrix result = new RtwMatrix(mtx.Columns,mtx.Rows);

            for(int i = 0; i < mtx.Rows; i++)
            {
                for(int j = 0; j < mtx.Columns; j++)
                {
                    result[j,i] = mtx[i,j];
                }
            }

            return result;
        }
예제 #22
0
파일: RtwMatrix.cs 프로젝트: Lannyland/IPPA
        //gradiant magnitude
        public static RtwMatrix operator ^(RtwMatrix lmtx, RtwMatrix rmtx)
        {
            if (lmtx.Columns != rmtx.Columns || lmtx.Rows != rmtx.Rows)
                throw new RtwMatrixException("Attempt to element multiply matrices with unmatching row and column indexes");
            //return null;

            RtwMatrix result = new RtwMatrix(lmtx.Rows, lmtx.Columns);

            for (int i = 0; i < lmtx.Rows; i++)
            {
                for (int j = 0; j < lmtx.Columns; j++)
                {
                    result[i, j] = (float)Math.Sqrt(lmtx[i, j] * lmtx[i,j] + rmtx[i,j] * rmtx[i, j]);
                }
            }

            return result;
        }
예제 #23
0
파일: RtwMatrix.cs 프로젝트: Lannyland/IPPA
        //devision by const
        public static RtwMatrix operator /(RtwMatrix mtx, float val)
        {
            if(val == 0)
                throw new RtwMatrixException("Attempt to devide the matrix by zero");
                //return null;

            RtwMatrix result = new RtwMatrix(mtx.Rows,mtx.Columns);

            for(int i = 0; i < mtx.Rows; i++)
            {
                for(int j = 0; j < mtx.Columns; j++)
                {
                    result[i,j] = mtx[i,j] / val;
                }
            }

            return result;
        }
예제 #24
0
파일: RtwMatrix.cs 프로젝트: Lannyland/IPPA
        //subtraction
        public static RtwMatrix operator -(RtwMatrix lmtx, RtwMatrix rmtx)
        {
            if(lmtx.Rows != rmtx.Rows || lmtx.Columns != rmtx.Columns)
                throw new RtwMatrixException("Attempt to subtract matrixes of different sizes");
                //return null;

            RtwMatrix result = new RtwMatrix(lmtx.Rows,lmtx.Columns);

            for(int i = 0; i < lmtx.Rows; i++)
            {
                for(int j = 0; j < lmtx.Columns; j++)
                {
                    result[i,j] = lmtx[i,j] - rmtx[i,j];
                }
            }

            return result;
        }
예제 #25
0
파일: RtwMatrix.cs 프로젝트: Lannyland/IPPA
        //addition with const
        public static RtwMatrix operator +(RtwMatrix lmtx, float val)
        {
            RtwMatrix result = new RtwMatrix(lmtx.Rows, lmtx.Columns);

            for (int i = 0; i < lmtx.Rows; i++)
            {
                for (int j = 0; j < lmtx.Columns; j++)
                {
                    result[i, j] = lmtx[i, j] + val;
                }
            }

            return result;
        }
예제 #26
0
        public void Run()
        {
            int BatchCount = 1;

            if (curRequest.BatchRun)
            {
                BatchCount = curRequest.RunTimes;
            }

            // First do reachable area (Dist and Diff)
            RtwMatrix mDistReachable;
            RtwMatrix mDiffReachable;

            if (curRequest.T < curRequest.DistMap.Rows + curRequest.DistMap.Columns)
            {
                mDistReachable = curRequest.DistMap.Clone();
                mDiffReachable = curRequest.DiffMap.Clone();
                if (!ComputeReachableArea(mDistReachable, mDiffReachable))
                {
                    // Cannot plan path.
                    return;
                }
            }
            else
            {
                mDistReachable = curRequest.DistMap.Clone();
                mDiffReachable = curRequest.DiffMap.Clone();
            }

            // Then do mode count (If Diff map is used, multiply first)
            CountDistModes myCount;
            if (curRequest.UseTaskDifficultyMap)
            {

                RtwMatrix mRealModes = new RtwMatrix(mDistReachable.Rows, mDistReachable.Columns);
                for (int i = 0; i < mRealModes.Rows; i++)
                {
                    for (int j = 0; j < mRealModes.Columns; j++)
                    {
                        mRealModes[i, j] = mDistReachable[i, j] *
                            (float)curRequest.DiffRates[Convert.ToInt32(mDiffReachable[i, j])];
                    }
                }
                myCount = new CountDistModes(mRealModes);
            }
            else
            {
                myCount = new CountDistModes(mDistReachable);
            }

            int ModeCount = myCount.GetCount();
            RtwMatrix mModes = myCount.GetModes();
            myCount = null;
            //Console.WriteLine("ModeCount = " + ModeCount);

            // Then do efficiency lower bound
            ComputeEfficiencyUB myELB = new ComputeEfficiencyUB(curRequest, mDistReachable, mDiffReachable);
            double Efficiency_UB = myELB.GetEfficiency_UB();
            myELB = null;

            // Set sample rate based on max value in mdistReachable.
            float max = mDistReachable.MinMaxValue()[1];
            ProjectConstants.DownSample_Rate = max / 10f;

            // Do the batch run of Path Planning
            List<double> AllRunTimes = new List<double>();
            List<double> AllEfficiencies = new List<double>();
            for (int i = 0; i < BatchCount; i++)
            {
                // Run them sequencially and don't use multiple threads.
                PathPlanningTask curTask = new PathPlanningTask(curRequest, ModeCount, mModes, mDistReachable, mDiffReachable, Efficiency_UB);
                curTask.Run();
                AllRunTimes.Add(curTask.GetRunTime());
                AvgRunTime += curTask.GetRunTime();
                AllEfficiencies.Add(curTask.GetEfficiency());
                AvgEfficiency += curTask.GetEfficiency();
                Path = curTask.GetPath();
                curTask = null;
            }
            AvgRunTime = AvgRunTime / BatchCount;
            StdRunTime = ComputeStDev(AllRunTimes, AvgRunTime);
            AvgEfficiency = AvgEfficiency / BatchCount;
            StdEfficiency = ComputeStDev(AllEfficiencies, AvgEfficiency);

            // Log path planning activities
            if (ProjectConstants.DebugMode)
            {
                curRequest.SetLog("----------------------------------------------\n");
                curRequest.SetLog("Average run time: " + AvgRunTime.ToString() + "\n");
                curRequest.SetLog("Standard deviation: " + StdRunTime.ToString() + "\n");
                curRequest.SetLog("Average efficiency: " + AvgEfficiency.ToString() + "\n");
                curRequest.SetLog("Standard deviation: " + StdEfficiency.ToString() + "\n");
                curRequest.SetLog("----------------------------------------------");
                curRequest.SetLog("----------------------------------------------\n");
            }
        }
예제 #27
0
        // Compute the reachable area and might as well compute distance to closest non-zero node
        private bool ComputeReachableArea(RtwMatrix mDistReachable, RtwMatrix mDiffReachable)
        {
            // Code is cleaner to just deal two cases seperately.
            if (!curRequest.UseEndPoint)
            {
                Point Start = new Point(curRequest.pStart.column, curRequest.pStart.row);
                int d = curRequest.T;
                for (int y = 0; y < mDistReachable.Rows; y++)
                {
                    for (int x = 0; x < mDistReachable.Columns; x++)
                    {
                        int dist = MISCLib.ManhattanDistance(x, y, Start.X, Start.Y);
                        if (dist >= curRequest.T)
                        {
                            // Wipe cell in both maps clean
                            mDistReachable[y, x] = 0;
                            mDiffReachable[y, x] = 0;
                        }
                        if (dist < d && mDistReachable[y, x] != 0)
                        {
                            d = dist;
                        }
                    }
                }
                curRequest.d = d;
            }
            else
            {
                Point Start = new Point(curRequest.pStart.column, curRequest.pStart.row);
                Point End = new Point(curRequest.pEnd.column, curRequest.pEnd.row);
                int d = curRequest.T;
                int dist = MISCLib.ManhattanDistance(Start.X, Start.Y, End.X, End.Y);

                if (dist > curRequest.T)
                {
                    // Impossible to get from A to B in allowed flight time
                    System.Windows.Forms.MessageBox.Show("Impossible! Extend flight time!");
                    return false;
                }

                if (curRequest.VehicleType == UAVType.FixWing && curRequest.T % 2 != dist % 2)
                {
                    // Impossible to get from A to B in the exact allowed flight time
                    System.Windows.Forms.MessageBox.Show("Impossible to reach end point at time T! Add 1 or minus 1!");
                    return false;
                }

                for (int y = 0; y < mDistReachable.Rows; y++)
                {
                    for (int x = 0; x < mDistReachable.Columns; x++)
                    {
                        int dist_AC = MISCLib.ManhattanDistance(x, y, Start.X, Start.Y);
                        int dist_BC = MISCLib.ManhattanDistance(x, y, End.X, End.Y);
                        if ((dist_AC + dist_BC) > curRequest.T)
                        {
                            // Wipe cell in both maps clean
                            mDistReachable[y, x] = 0;
                            mDiffReachable[y, x] = 0;
                        }
                        dist = MISCLib.ManhattanDistance(x, y, Start.X, Start.Y);
                        if (dist < d && mDistReachable[y, x] != 0)
                        {
                            d = dist;
                        }
                    }
                }
                curRequest.d = d;

            }
            return true;
        }
예제 #28
0
파일: RtwMatrix.cs 프로젝트: Lannyland/IPPA
        //multiplication by matrix
        public static RtwMatrix operator *(RtwMatrix lmtx, RtwMatrix rmtx)
        {
            if(lmtx.Columns != rmtx.Rows)
                throw new RtwMatrixException("Attempt to multiply matrices with unmatching row and column indexes");
                //return null;

            RtwMatrix result = new RtwMatrix(lmtx.Rows,rmtx.Columns);

            for(int i = 0; i < lmtx.Rows; i++)
            {
                for(int j = 0; j < rmtx.Columns; j++)
                {
                    for(int k = 0; k < rmtx.Rows; k++)
                    {
                        result[i,j] += lmtx[i,k] * rmtx[k,j];
                    }
                }
            }

            return result;
        }
예제 #29
0
파일: frmMap.cs 프로젝트: Lannyland/IPPA
        public void DrawReachableRegion(RtwMatrix mask)
        {
            // Apply mask
            int rows = mask.Rows;
            int columns = mask.Columns;
            for (int i = 0; i < rows; i++)
            {
                for (int j = 0; j < columns; j++)
                {
                    if (mask[i, j] != 1)
                    {
                        Color c = new Color();
                        c = Color.FromArgb(0, 0, 0);
                        DisplayMap.SetPixel(j, i, c);
                    }
                }
            }

            // Showing the image
            pbMap.Image = DisplayMap;
        }
예제 #30
0
파일: RtwMatrix.cs 프로젝트: Lannyland/IPPA
        //multiplication by const
        public static RtwMatrix operator *(RtwMatrix mtx, float val)
        {
            RtwMatrix result = new RtwMatrix(mtx.Rows,mtx.Columns);

            for(int i = 0; i < mtx.Rows; i++)
            {
                for(int j = 0; j < mtx.Columns; j++)
                {
                    result[i,j] = mtx[i,j] * val;
                }
            }

            return result;
        }