public override double MatrixNorm(Norm norm, int rows, int columns, double[] matrix)
        {
            if (matrix == null)
            {
                throw new ArgumentNullException("matrix");
            }

            if (rows <= 0)
            {
                throw new ArgumentException(Resources.ArgumentMustBePositive, "rows");
            }

            if (columns <= 0)
            {
                throw new ArgumentException(Resources.ArgumentMustBePositive, "columns");
            }

            if (matrix.Length < rows * columns)
            {
                throw new ArgumentException(string.Format(Resources.ArrayTooSmall, rows * columns), "matrix");
            }

            var work = new double[rows];
            return SafeNativeMethods.d_matrix_norm((byte)norm, rows, columns, matrix, work);
        }

        public override float MatrixNorm(Norm norm, int rows, int columns, float[] matrix)
        {
            if (matrix == null)
            {
                throw new ArgumentNullException("matrix");
            }

            if (rows <= 0)
            {
                throw new ArgumentException(Resources.ArgumentMustBePositive, "rows");
            }

            if (columns <= 0)
            {
                throw new ArgumentException(Resources.ArgumentMustBePositive, "columns");
            }

            if (matrix.Length < rows * columns)
            {
                throw new ArgumentException(string.Format(Resources.ArrayTooSmall, rows * columns), "matrix");
            }

            var work = new float[rows];
            return MatrixNorm(norm, rows, columns, matrix, work);
        }

 //
 // GET: /Games/Edit/5
 public ActionResult Edit(Norm.ObjectId id)
 {
     Game game = context.Games.GetAll().Single(x => x.Id == id);
     return View(game);
 }

 /// <summary>
 /// Computes the requested <see cref="Norm"/> of the matrix.
 /// </summary>
 /// <param name="norm">The type of norm to compute.</param>
 /// <param name="matrix">The matrix to compute the norm from.</param>
 /// <returns>
 /// The requested <see cref="Norm"/> of the matrix.
 /// </returns>
 public Complex MatrixNorm(Norm norm, Complex[] matrix)
 {
     throw new NotImplementedException();
 }

 /// <summary>
 /// Computes the requested <see cref="Norm"/> of the matrix.
 /// </summary>
 /// <param name="norm">The type of norm to compute.</param>
 /// <param name="rows">The number of rows.</param>
 /// <param name="columns">The number of columns.</param>
 /// <param name="matrix">The matrix to compute the norm from.</param>
 /// <param name="work">The work array. Not used in the managed provider.</param>
 /// <returns>
 /// The requested <see cref="Norm"/> of the matrix.
 /// </returns>
 public virtual double MatrixNorm(Norm norm, int rows, int columns, double[] matrix, double[] work)
 {
     return MatrixNorm(norm, rows, columns, matrix);
 }

 /// <summary>
 /// Computes the requested <see cref="Norm"/> of the matrix.
 /// </summary>
 /// <param name="norm">The type of norm to compute.</param>
 /// <param name="rows">The number of rows.</param>
 /// <param name="columns">The number of columns.</param>
 /// <param name="matrix">The matrix to compute the norm from.</param>
 /// <returns>
 /// The requested <see cref="Norm"/> of the matrix.
 /// </returns>
 public Complex32 MatrixNorm(Norm norm, int rows, int columns, Complex32[] matrix)
 {
     throw new NotImplementedException();
 }

 //
 // GET: /Users/Edit/5
 public ActionResult Edit(Norm.ObjectId id)
 {
     User user = context.Users.GetAll().Single(x => x.Id == id);
     return View(user);
 }

 //
 // GET: /Users/Details/5
 public ViewResult Details(Norm.ObjectId id)
 {
     User user = context.Users.GetAll().Single(x => x.Id == id);
     return View(user);
 }

 public ActionResult DeleteConfirmed(Norm.ObjectId id)
 {
     User user = context.Users.GetAll().Single(x => x.Id == id);
     context.Users.Delete(user);
     return RedirectToAction("Index");
 }

 public void CanComputeMatrixNorm(Norm norm, double[] matrix, double[] work)
 {
 }

 //
 // GET: /HashTags/Edit/5
 public ActionResult Edit(Norm.ObjectId id)
 {
     HashTag hashtag = _repository.Linq().Single(x => x.Id == id);
     return View(hashtag);
 }

 //
 // GET: /HashTags/Details/5
 public ViewResult Details(Norm.ObjectId id)
 {
     HashTag hashtag = _repository.Linq().Single(x => x.Id == id);
     return View(hashtag);
 }

 public ActionResult DeleteConfirmed(Norm.ObjectId id)
 {
     _repository.Remove(id);
     return RedirectToAction("Index");
 }

			// Load & cache full bytes array.  Returns bytes.
			public byte[] Bytes()
			{
				lock (this)
				{
					System.Diagnostics.Debug.Assert(refCount > 0 &&(origNorm == null || origNorm.refCount > 0));
					if (bytes == null)
					{
						// value not yet read
						System.Diagnostics.Debug.Assert(bytesRef == null);
						if (origNorm != null)
						{
							// Ask origNorm to load so that for a series of
							// reopened readers we share a single read-only
							// byte[]
							bytes = origNorm.Bytes();
							bytesRef = origNorm.bytesRef;
							bytesRef.IncRef();
							
							// Once we've loaded the bytes we no longer need
							// origNorm:
							origNorm.DecRef();
							origNorm = null;
						}
						else
						{
							// We are the origNorm, so load the bytes for real
							// ourself:
							int count = Enclosing_Instance.MaxDoc();
							bytes = new byte[count];
							
							// Since we are orig, in must not be null
							System.Diagnostics.Debug.Assert(in_Renamed != null);
							
							// Read from disk.
							lock (in_Renamed)
							{
								in_Renamed.Seek(normSeek);
								in_Renamed.ReadBytes(bytes, 0, count, false);
							}
							
							bytesRef = new Ref();
							CloseInput();
						}
					}
					
					return bytes;
				}
			}

        /// <summary>
        /// Computes the requested <see cref="Norm"/> of the matrix.
        /// </summary>
        /// <param name="norm">The type of norm to compute.</param>
        /// <param name="rows">The number of rows.</param>
        /// <param name="columns">The number of columns.</param>
        /// <param name="matrix">The matrix to compute the norm from.</param>
        /// <returns>
        /// The requested <see cref="Norm"/> of the matrix.
        /// </returns>
        public double MatrixNorm(Norm norm, int rows, int columns, double[] matrix)
        {
            var ret = 0.0;
            switch (norm)
            {
                case Norm.OneNorm:
                    break;
                case Norm.LargestAbsoluteValue:
                    break;
                case Norm.InfinityNorm:
                    break;
                case Norm.FrobeniusNorm:
                    break;
            }

            return ret;
        }

 public SimpleNormForTypesTests()
 {
     norm = new Norm(new SimpleAssert(message => new AssertException(message)));
 }

 public void CanComputeMatrixNorm(Norm norm, float[] matrix, float[] work)
 {
 }

 /// <summary>
 /// Computes the requested <see cref="Norm"/> of the matrix.
 /// </summary>
 /// <param name="norm">The type of norm to compute.</param>
 /// <param name="rows">The number of rows.</param>
 /// <param name="columns">The number of columns.</param>
 /// <param name="matrix">The matrix to compute the norm from.</param>
 /// <param name="work">The work array. Only used when <see cref="Norm.InfinityNorm"/>
 /// and needs to be have a length of at least M (number of rows of <paramref name="matrix"/>.</param>
 /// <returns>
 /// The requested <see cref="Norm"/> of the matrix.
 /// </returns>
 public virtual float MatrixNorm(Norm norm, int rows, int columns, float[] matrix, float[] work)
 {
     return MatrixNorm(norm, rows, columns, matrix);
 }

 /// <summary>
 /// Computes the requested <see cref="Norm"/> of the matrix.
 /// </summary>
 /// <param name="norm">The type of norm to compute.</param>
 /// <param name="rows">The number of rows.</param>
 /// <param name="columns">The number of columns.</param>
 /// <param name="matrix">The matrix to compute the norm from.</param>
 /// <returns>
 /// The requested <see cref="Norm"/> of the matrix.
 /// </returns>
 public virtual double MatrixNorm(Norm norm, int rows, int columns, float[] matrix)
 {
     switch (norm)
     {
         case Norm.OneNorm:
             var norm1 = 0d;
             for (var j = 0; j < columns; j++)
             {
                 var s = 0d;
                 for (var i = 0; i < rows; i++)
                 {
                     s += Math.Abs(matrix[(j*rows) + i]);
                 }
                 norm1 = Math.Max(norm1, s);
             }
             return norm1;
         case Norm.LargestAbsoluteValue:
             var normMax = 0d;
             for (var j = 0; j < columns; j++)
             {
                 for (var i = 0; i < rows; i++)
                 {
                     normMax = Math.Max(Math.Abs(matrix[(j * rows) + i]), normMax);
                 }
             }
             return normMax;
         case Norm.InfinityNorm:
             var r = new double[rows];
             for (var j = 0; j < columns; j++)
             {
                 for (var i = 0; i < rows; i++)
                 {
                     r[i] += Math.Abs(matrix[(j * rows) + i]);
                 }
             }
             // TODO: reuse
             var max = r[0];
             for (int i = 0; i < r.Length; i++)
             {
                 if (r[i] > max)
                 {
                     max = r[i];
                 }
             }
             return max;
         case Norm.FrobeniusNorm:
             var aat = new float[rows*rows];
             MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.Transpose, 1.0f, matrix, rows, columns, matrix, rows, columns, 0.0f, aat);
             var normF = 0d;
             for (var i = 0; i < rows; i++)
             {
                 normF += Math.Abs(aat[(i * rows) + i]);
             }
             return Math.Sqrt(normF);
         default:
             throw new NotSupportedException();
     }
 }

        /// <summary>
        /// Computes the requested <see cref="Norm"/> of the matrix.
        /// </summary>
        /// <param name="norm">The type of norm to compute.</param>
        /// <param name="rows">The number of rows.</param>
        /// <param name="columns">The number of columns.</param>
        /// <param name="matrix">The matrix to compute the norm from.</param>
        /// <returns>
        /// The requested <see cref="Norm"/> of the matrix.
        /// </returns>
        public virtual Complex32 MatrixNorm(Norm norm, int rows, int columns, Complex32[] matrix)
        {
            var ret = 0.0;
            switch (norm)
            {
                case Norm.OneNorm:
                    for (var j = 0; j < columns; j++)
                    {
                        var s = 0.0;
                        for (var i = 0; i < rows; i++)
                        {
                            s += matrix[(j * rows) + i].Magnitude;
                        }

                        ret = Math.Max(ret, s);
                    }

                    break;
                case Norm.LargestAbsoluteValue:

                    for (var i = 0; i < rows; i++)
                    {
                        for (var j = 0; j < columns; j++)
                        {
                            ret = Math.Max(matrix[(j * rows) + i].Magnitude, ret);
                        }
                    }

                    break;
                case Norm.InfinityNorm:
                    for (var i = 0; i < rows; i++)
                    {
                        var s = 0.0;
                        for (var j = 0; j < columns; j++)
                        {
                            s += matrix[(j * rows) + i].Magnitude;
                        }

                        ret = Math.Max(ret, s);
                    }

                    break;
                case Norm.FrobeniusNorm:
                    var aat = new Complex32[rows * rows];
                    MatrixMultiplyWithUpdate(Transpose.DontTranspose, Transpose.Transpose, 1.0f, matrix, rows, columns, matrix, rows, columns, 0.0f, aat);

                    for (var i = 0; i < rows; i++)
                    {
                        ret += aat[(i * rows) + i].Magnitude;
                    }

                    ret = Math.Sqrt(ret);
                    break;
            }

            return Convert.ToSingle(ret);
        }