/// <summary>
        /// Gets a specific covector as a matrix object.
        /// </summary>
        /// <param name="columnIndex"></param>
        /// <returns></returns>
        public QsMatrix GetColumnVectorMatrix(int columnIndex)
        {
            QsMatrix mat = new QsMatrix();

            mat.AddColumnVector(GetColumnVector(columnIndex));
            return(mat);
        }
        /// <summary>
        /// Append the target matrix right to the matrix.
        /// </summary>
        /// <param name="matrix"></param>
        /// <returns></returns>
        public QsMatrix AppendRightMatrix(QsMatrix matrix)
        {
            QsMatrix m = CopyMatrix(this);

            foreach (var column in matrix.Columns)
            {
                m.AddColumnVector(column);
            }
            return(m);
        }
        /// <summary>
        /// Removes column at index
        /// </summary>
        /// <param name="columnIndex"></param>
        /// <returns></returns>
        public QsMatrix RemoveColumn(int columnIndex)
        {
            QsMatrix m = new QsMatrix();

            for (int ix = 0; ix < this.ColumnsCount; ix++)
            {
                if (ix != columnIndex)
                {
                    m.AddColumnVector(this.GetColumnVector(ix));
                }
            }
            return(m);
        }
        /// <summary>
        /// Create A matrix from a row values by aligning values to the left in
        /// </summary>
        /// <param name="values"></param>
        /// <returns></returns>
        public static QsValue MatrixRowFromValues(params QsValue[] values)
        {
            // what about [g g] and g is tensor
            // in this case return value should be tensor
            //   from the higher degree of above g
            if (values[0] is QsTensor)
            {
                if (values.Count() == 1)
                {
                    return(values[0]);
                }

                // in rare cases or event known cases by me Ahmed Sadek and because of parsing
                // sometimes I enclose tensor variable inside matrix  [g g <|4 3|> ]
                // so in this case i will the return as it is.

                QsTensor tensor = new QsTensor();
                foreach (var inTensor in values)
                {
                    if (inTensor.GetType() != typeof(QsTensor))
                    {
                        throw new QsException("Non Tensor in a matrix of tensors is not valid expression.");
                    }
                    else
                    {
                        tensor.AddInnerTensor((QsTensor)inTensor);
                    }
                }
                return(tensor);
            }



            QsMatrix m = new QsMatrix();

            foreach (var v in values)
            {
                if (v is QsScalar)
                {
                    if (m.RowsCount == 0)
                    {
                        m.AddVector((QsVector)VectorFromValues(v));
                    }
                    else
                    {
                        m.Rows[0].AddComponent((QsScalar)v);
                    }
                }

                if (v is QsVector)
                {
                    if (m.RowsCount == 0)
                    {
                        m.AddVector(((QsVector)v).Clone() as QsVector);
                    }
                    else if (m.RowsCount == 1)
                    {
                        m.Rows[0].AddComponents((QsVector)v);
                    }
                    else
                    {
                        throw new QsInvalidOperationException("Couldn't adding vector to multi row matrix");
                    }
                }

                if (v is QsMatrix)
                {
                    if (m.RowsCount == 0)
                    {
                        m = null;
                        m = QsMatrix.CopyMatrix((QsMatrix)v);
                    }
                    else if (m.RowsCount == ((QsMatrix)v).RowsCount)
                    {
                        foreach (var col in ((QsMatrix)v).Columns)
                        {
                            m.AddColumnVector(col);
                        }
                    }
                    else
                    {
                        throw new QsInvalidOperationException("Couldn't adding different row matrices");
                    }
                }
            }

            return(m);
        }