Merge branch 'master' of https://github.com/sofa-framework/sofa

SperryBot · SperryBot · commit f89b6043d0f2 · 2026-02-08T12:00:07.000+01:00
diff --git a/Sofa/framework/Core/src/sofa/core/objectmodel/DataLink.h b/Sofa/framework/Core/src/sofa/core/objectmodel/DataLink.h
@@ -39,7 +39,7 @@ class SOFA_CORE_API DataLink final : public AbstractDataLink
 public:
 
     DataLink(T& owner) : m_owner{owner} { }
-    virtual ~DataLink() {}
+    ~DataLink() = default;
 
     T* getTarget() const
     {
diff --git a/Sofa/framework/LinearAlgebra/src/sofa/linearalgebra/CompressedRowSparseMatrixMechanical.h b/Sofa/framework/LinearAlgebra/src/sofa/linearalgebra/CompressedRowSparseMatrixMechanical.h
@@ -446,28 +446,28 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co
 /// @{
 
     /// @return type of elements stored in this matrix
-    virtual ElementType getElementType() const override { return traits::getElementType(); }
+    ElementType getElementType() const override { return traits::getElementType(); }
 
     /// @return size of elements stored in this matrix
-    virtual std::size_t getElementSize() const override { return sizeof(Real); }
+    std::size_t getElementSize() const override { return sizeof(Real); }
 
     /// @return the category of this matrix
-    virtual MatrixCategory getCategory() const override { return MATRIX_SPARSE; }
+    MatrixCategory getCategory() const override { return MATRIX_SPARSE; }
 
     /// @return the number of rows in each block, or 1 of there are no fixed block size
-    virtual Index getBlockRows() const override { return NL; }
+    Index getBlockRows() const override { return NL; }
 
     /// @return the number of columns in each block, or 1 of there are no fixed block size
-    virtual Index getBlockCols() const override { return NC; }
+    Index getBlockCols() const override { return NC; }
 
     /// @return the number of rows of blocks
-    virtual Index bRowSize() const override{ return this->rowBSize(); }
+    Index bRowSize() const override{ return this->rowBSize(); }
 
     /// @return the number of columns of blocks
-    virtual Index bColSize() const override { return this->colBSize(); }
+    Index bColSize() const override { return this->colBSize(); }
 
     /// @return the width of the band on each side of the diagonal (only for band matrices)
-    virtual Index getBandWidth() const override { return NC-1; }
+    Index getBandWidth() const override { return NC-1; }
 
 /// @}
 
@@ -641,23 +641,23 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co
 /// @{
 
 protected:
-    virtual void bAccessorDelete(const InternalBlockAccessor* /*b*/) const override {}
-    virtual void bAccessorCopy(InternalBlockAccessor* /*b*/) const override {}
-    virtual SReal bAccessorElement(const InternalBlockAccessor* b, Index i, Index j) const override
+    void bAccessorDelete(const InternalBlockAccessor* /*b*/) const override {}
+    void bAccessorCopy(InternalBlockAccessor* /*b*/) const override {}
+    SReal bAccessorElement(const InternalBlockAccessor* b, Index i, Index j) const override
     {
         //return element(b->row * getBlockRows() + i, b->col * getBlockCols() + j);
         Index index = b->data;
         const Block& data = (index >= 0) ? this->colsValue[index] : this->btemp[-index-1].value;
         return static_cast<SReal>(traits::v(data, i, j));
     }
-    virtual void bAccessorSet(InternalBlockAccessor* b, Index i, Index j, double v) override
+    void bAccessorSet(InternalBlockAccessor* b, Index i, Index j, double v) override
     {
         //set(b->row * getBlockRows() + i, b->col * getBlockCols() + j, v);
         Index index = b->data;
         Block& data = (index >= 0) ? this->colsValue[index] : this->btemp[-index-1].value;
         traits::vset(data, i, j, static_cast<Real>(v) );
     }
-    virtual void bAccessorAdd(InternalBlockAccessor* b, Index i, Index j, double v) override
+    void bAccessorAdd(InternalBlockAccessor* b, Index i, Index j, double v) override
     {
         //add(b->row * getBlockRows() + i, b->col * getBlockCols() + j, v);
         Index index = b->data;
@@ -675,15 +675,15 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co
                 buffer[l*NC+c] = static_cast<T>(traits::v(data, l, c));
         return buffer;
     }
-    virtual const float* bAccessorElements(const InternalBlockAccessor* b, float* buffer) const override
+    const float* bAccessorElements(const InternalBlockAccessor* b, float* buffer) const override
     {
         return bAccessorElementsCSRImpl<float>(b, buffer);
     }
-    virtual const double* bAccessorElements(const InternalBlockAccessor* b, double* buffer) const override
+    const double* bAccessorElements(const InternalBlockAccessor* b, double* buffer) const override
     {
         return bAccessorElementsCSRImpl<double>(b, buffer);
     }
-    virtual const int* bAccessorElements(const InternalBlockAccessor* b, int* buffer) const override
+    const int* bAccessorElements(const InternalBlockAccessor* b, int* buffer) const override
     {
         return bAccessorElementsCSRImpl<int>(b, buffer);
     }
@@ -697,15 +697,15 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co
             for (Index c=0; c < (Index)NC; ++c)
                 traits::vset(data, l, c, static_cast<Real>(buffer[l*NC+c]) );
     }
-    virtual void bAccessorSet(InternalBlockAccessor* b, const float* buffer) override
+    void bAccessorSet(InternalBlockAccessor* b, const float* buffer) override
     {
         bAccessorSetCSRImpl<float>(b, buffer);
     }
-    virtual void bAccessorSet(InternalBlockAccessor* b, const double* buffer) override
+    void bAccessorSet(InternalBlockAccessor* b, const double* buffer) override
     {
         bAccessorSetCSRImpl<double>(b, buffer);
     }
-    virtual void bAccessorSet(InternalBlockAccessor* b, const int* buffer) override
+    void bAccessorSet(InternalBlockAccessor* b, const int* buffer) override
     {
         bAccessorSetCSRImpl<int>(b, buffer);
     }
@@ -719,23 +719,23 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co
             for (Index c=0; c < (Index)NC; ++c)
                 traits::vadd(data, l, c,static_cast<Real>(buffer[l*NC+c]) );
     }
-    virtual void bAccessorAdd(InternalBlockAccessor* b, const float* buffer) override
+    void bAccessorAdd(InternalBlockAccessor* b, const float* buffer) override
     {
         bAccessorAddCSRImpl<float>(b, buffer);
     }
-    virtual void bAccessorAdd(InternalBlockAccessor* b, const double* buffer) override
+    void bAccessorAdd(InternalBlockAccessor* b, const double* buffer) override
     {
         bAccessorAddCSRImpl<double>(b, buffer);
     }
-    virtual void bAccessorAdd(InternalBlockAccessor* b, const int* buffer) override
+    void bAccessorAdd(InternalBlockAccessor* b, const int* buffer) override
     {
         bAccessorAddCSRImpl<int>(b, buffer);
     }
 
 public:
 
     /// Get read access to a block
-    virtual BlockConstAccessor blockGet(Index i, Index j) const
+    BlockConstAccessor blockGet(Index i, Index j) const
     {
         if constexpr (Policy::AutoCompress) const_cast<Matrix*>(this)->compress(); /// \warning this violates the const-ness of the method !
 
@@ -753,7 +753,7 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co
     }
 
     /// Get write access to a block
-    virtual BlockAccessor blockGetW(Index i, Index j)
+    BlockAccessor blockGetW(Index i, Index j)
     {
         if constexpr (Policy::AutoCompress) compress();
 
@@ -771,7 +771,7 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co
     }
 
     /// Get write access to a block, possibly creating it
-    virtual BlockAccessor blockCreate(Index i, Index j)
+    BlockAccessor blockCreate(Index i, Index j)
     {
         Index rowId = Index(i * this->rowIndex.size() / this->nBlockRow);
         if (this->sortedFind(this->rowIndex, i, rowId))
@@ -792,35 +792,35 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co
     }
 
 protected:
-    virtual void itCopyColBlock(InternalColBlockIterator* /*it*/) const override {}
-    virtual void itDeleteColBlock(const InternalColBlockIterator* /*it*/) const override {}
-    virtual void itAccessColBlock(InternalColBlockIterator* it, BlockConstAccessor* b) const override
+    void itCopyColBlock(InternalColBlockIterator* /*it*/) const override {}
+    void itDeleteColBlock(const InternalColBlockIterator* /*it*/) const override {}
+    void itAccessColBlock(InternalColBlockIterator* it, BlockConstAccessor* b) const override
     {
         Index index = it->data;
         setMatrix(b);
         getInternal(b)->row = it->row;
         getInternal(b)->data = index;
         getInternal(b)->col = this->colsIndex[index];
     }
-    virtual void itIncColBlock(InternalColBlockIterator* it) const override
+    void itIncColBlock(InternalColBlockIterator* it) const override
     {
         Index index = it->data;
         ++index;
         it->data = index;
     }
-    virtual void itDecColBlock(InternalColBlockIterator* it) const override
+    void itDecColBlock(InternalColBlockIterator* it) const override
     {
         Index index = it->data;
         --index;
         it->data = index;
     }
-    virtual bool itEqColBlock(const InternalColBlockIterator* it, const InternalColBlockIterator* it2) const override
+    bool itEqColBlock(const InternalColBlockIterator* it, const InternalColBlockIterator* it2) const override
     {
         Index index = it->data;
         Index index2 = it2->data;
         return index == index2;
     }
-    virtual bool itLessColBlock(const InternalColBlockIterator* it, const InternalColBlockIterator* it2) const override
+    bool itLessColBlock(const InternalColBlockIterator* it, const InternalColBlockIterator* it2) const override
     {
         Index index = it->data;
         Index index2 = it2->data;
@@ -829,7 +829,7 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co
 
 public:
     /// Get the iterator corresponding to the beginning of the given row of blocks
-    virtual ColBlockConstIterator bRowBegin(Index ib) const override
+    ColBlockConstIterator bRowBegin(Index ib) const override
     {
         if constexpr (Policy::AutoCompress) const_cast<Matrix*>(this)->compress(); /// \warning this violates the const-ness of the method !
         Index rowId = Index(ib * this->rowIndex.size() / this->nBlockRow);
@@ -842,7 +842,7 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co
     }
 
     /// Get the iterator corresponding to the end of the given row of blocks
-    virtual ColBlockConstIterator bRowEnd(Index ib) const override
+    ColBlockConstIterator bRowEnd(Index ib) const override
     {
         if constexpr (Policy::AutoCompress) const_cast<Matrix*>(this)->compress(); /// \warning this violates the const-ness of the method !
         Index rowId = Index(ib * this->rowIndex.size() / this->nBlockRow);
@@ -855,7 +855,7 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co
     }
 
     /// Get the iterators corresponding to the beginning and end of the given row of blocks
-    virtual std::pair<ColBlockConstIterator, ColBlockConstIterator> bRowRange(Index ib) const override
+    std::pair<ColBlockConstIterator, ColBlockConstIterator> bRowRange(Index ib) const override
     {
         if constexpr (Policy::AutoCompress) const_cast<Matrix*>(this)->compress(); /// \warning this violates the const-ness of the method !
         Index rowId = Index(ib * this->rowIndex.size() / this->nBlockRow);
@@ -871,28 +871,28 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co
 
 
 protected:
-    virtual void itCopyRowBlock(InternalRowBlockIterator* /*it*/) const override {}
-    virtual void itDeleteRowBlock(const InternalRowBlockIterator* /*it*/) const override {}
-    virtual Index itAccessRowBlock(InternalRowBlockIterator* it) const override
+    void itCopyRowBlock(InternalRowBlockIterator* /*it*/) const override {}
+    void itDeleteRowBlock(const InternalRowBlockIterator* /*it*/) const override {}
+    Index itAccessRowBlock(InternalRowBlockIterator* it) const override
     {
         Index rowId = it->data[0];
         return this->rowIndex[rowId];
     }
-    virtual ColBlockConstIterator itBeginRowBlock(InternalRowBlockIterator* it) const override
+    ColBlockConstIterator itBeginRowBlock(InternalRowBlockIterator* it) const override
     {
         Index rowId = it->data[0];
         Index row = this->rowIndex[rowId];
         Index index = this->rowBegin[rowId];
         return createColBlockConstIterator(row, index);
     }
-    virtual ColBlockConstIterator itEndRowBlock(InternalRowBlockIterator* it) const override
+    ColBlockConstIterator itEndRowBlock(InternalRowBlockIterator* it) const override
     {
         Index rowId = it->data[0];
         Index row = this->rowIndex[rowId];
         Index index2 = this->rowBegin[rowId+1];
         return createColBlockConstIterator(row, index2);
     }
-    virtual std::pair<ColBlockConstIterator, ColBlockConstIterator> itRangeRowBlock(InternalRowBlockIterator* it) const override
+    std::pair<ColBlockConstIterator, ColBlockConstIterator> itRangeRowBlock(InternalRowBlockIterator* it) const override
     {
         Index rowId = it->data[0];
         Index row = this->rowIndex[rowId];
@@ -902,25 +902,25 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co
                 createColBlockConstIterator(row, index2));
     }
 
-    virtual void itIncRowBlock(InternalRowBlockIterator* it) const override
+    void itIncRowBlock(InternalRowBlockIterator* it) const override
     {
         Index rowId = it->data[0];
         ++rowId;
         it->data[0] = rowId;
     }
-    virtual void itDecRowBlock(InternalRowBlockIterator* it) const override
+    void itDecRowBlock(InternalRowBlockIterator* it) const override
     {
         Index rowId = it->data[0];
         --rowId;
         it->data[0] = rowId;
     }
-    virtual bool itEqRowBlock(const InternalRowBlockIterator* it, const InternalRowBlockIterator* it2) const override
+    bool itEqRowBlock(const InternalRowBlockIterator* it, const InternalRowBlockIterator* it2) const override
     {
         Index rowId = it->data[0];
         Index rowId2 = it2->data[0];
         return rowId == rowId2;
     }
-    virtual bool itLessRowBlock(const InternalRowBlockIterator* it, const InternalRowBlockIterator* it2) const override
+    bool itLessRowBlock(const InternalRowBlockIterator* it, const InternalRowBlockIterator* it2) const override
     {
         Index rowId = it->data[0];
         Index rowId2 = it2->data[0];
@@ -929,21 +929,21 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co
 
 public:
     /// Get the iterator corresponding to the beginning of the rows of blocks
-    virtual RowBlockConstIterator bRowsBegin() const override
+    RowBlockConstIterator bRowsBegin() const override
     {
         if constexpr (Policy::AutoCompress) const_cast<Matrix*>(this)->compress(); /// \warning this violates the const-ness of the method !
         return createRowBlockConstIterator(0, 0);
     }
 
     /// Get the iterator corresponding to the end of the rows of blocks
-    virtual RowBlockConstIterator bRowsEnd() const override
+    RowBlockConstIterator bRowsEnd() const override
     {
         if constexpr (Policy::AutoCompress) const_cast<Matrix*>(this)->compress(); /// \warning this violates the const-ness of the method !
         return createRowBlockConstIterator(Index(this->rowIndex.size()), 0);
     }
 
     /// Get the iterators corresponding to the beginning and end of the given row of blocks
-    virtual std::pair<RowBlockConstIterator, RowBlockConstIterator> bRowsRange() const override
+    std::pair<RowBlockConstIterator, RowBlockConstIterator> bRowsRange() const override
     {
         if constexpr (Policy::AutoCompress) const_cast<Matrix*>(this)->compress(); /// \warning this violates the const-ness of the method !
         return std::make_pair(createRowBlockConstIterator(0, 0),
diff --git a/Sofa/framework/Type/src/sofa/type/Mat.h b/Sofa/framework/Type/src/sofa/type/Mat.h
@@ -528,17 +528,17 @@ class Mat
 
     bool isDiagonal() const noexcept
     {
-        for (Size i=0; i<L; i++)
+        for (Size i=0; i<L; ++i)
         {
-            for (Size j=0; j<i-1; j++)
-                if( rabs( (*this)(i,j) ) > EQUALITY_THRESHOLD ) return false;
-            for (Size j=i+1; j<C; j++)
+            for (Size j=0; j<C; ++j)
+            {
+                if (j == i) continue;
                 if( rabs( (*this)(i,j) ) > EQUALITY_THRESHOLD ) return false;
+            }
         }
         return true;
     }
 
-
     /// @}
 
     // LINEAR ALGEBRA
diff --git a/Sofa/framework/Type/test/MatTypes_test.cpp b/Sofa/framework/Type/test/MatTypes_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ class SOFA_CORE_API DataLink final : public AbstractDataLink`
`39`	`39`	`public:`
`40`	`40`
`41`	`41`	`DataLink(T& owner) : m_owner{owner} { }`
`42`		`- virtual ~DataLink() {}`
	`42`	`+ ~DataLink() = default;`
`43`	`43`
`44`	`44`	`T* getTarget() const`
`45`	`45`	`{`
Original file line number	Diff line number	Diff line change
`@@ -446,28 +446,28 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co`
`446`	`446`	`/// @{`
`447`	`447`
`448`	`448`	`/// @return type of elements stored in this matrix`
`449`		`- virtual ElementType getElementType() const override { return traits::getElementType(); }`
	`449`	`+ ElementType getElementType() const override { return traits::getElementType(); }`
`450`	`450`
`451`	`451`	`/// @return size of elements stored in this matrix`
`452`		`- virtual std::size_t getElementSize() const override { return sizeof(Real); }`
	`452`	`+ std::size_t getElementSize() const override { return sizeof(Real); }`
`453`	`453`
`454`	`454`	`/// @return the category of this matrix`
`455`		`- virtual MatrixCategory getCategory() const override { return MATRIX_SPARSE; }`
	`455`	`+ MatrixCategory getCategory() const override { return MATRIX_SPARSE; }`
`456`	`456`
`457`	`457`	`/// @return the number of rows in each block, or 1 of there are no fixed block size`
`458`		`- virtual Index getBlockRows() const override { return NL; }`
	`458`	`+ Index getBlockRows() const override { return NL; }`
`459`	`459`
`460`	`460`	`/// @return the number of columns in each block, or 1 of there are no fixed block size`
`461`		`- virtual Index getBlockCols() const override { return NC; }`
	`461`	`+ Index getBlockCols() const override { return NC; }`
`462`	`462`
`463`	`463`	`/// @return the number of rows of blocks`
`464`		`- virtual Index bRowSize() const override{ return this->rowBSize(); }`
	`464`	`+ Index bRowSize() const override{ return this->rowBSize(); }`
`465`	`465`
`466`	`466`	`/// @return the number of columns of blocks`
`467`		`- virtual Index bColSize() const override { return this->colBSize(); }`
	`467`	`+ Index bColSize() const override { return this->colBSize(); }`
`468`	`468`
`469`	`469`	`/// @return the width of the band on each side of the diagonal (only for band matrices)`
`470`		`- virtual Index getBandWidth() const override { return NC-1; }`
	`470`	`+ Index getBandWidth() const override { return NC-1; }`
`471`	`471`
`472`	`472`	`/// @}`
`473`	`473`
`@@ -641,23 +641,23 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co`
`641`	`641`	`/// @{`
`642`	`642`
`643`	`643`	`protected:`
`644`		`- virtual void bAccessorDelete(const InternalBlockAccessor* /b/) const override {}`
`645`		`- virtual void bAccessorCopy(InternalBlockAccessor* /b/) const override {}`
`646`		`- virtual SReal bAccessorElement(const InternalBlockAccessor* b, Index i, Index j) const override`
	`644`	`+ void bAccessorDelete(const InternalBlockAccessor* /b/) const override {}`
	`645`	`+ void bAccessorCopy(InternalBlockAccessor* /b/) const override {}`
	`646`	`+ SReal bAccessorElement(const InternalBlockAccessor* b, Index i, Index j) const override`
`647`	`647`	`{`
`648`	`648`	`//return element(b->row * getBlockRows() + i, b->col * getBlockCols() + j);`
`649`	`649`	`Index index = b->data;`
`650`	`650`	`const Block& data = (index >= 0) ? this->colsValue[index] : this->btemp[-index-1].value;`
`651`	`651`	`return static_cast<SReal>(traits::v(data, i, j));`
`652`	`652`	`}`
`653`		`- virtual void bAccessorSet(InternalBlockAccessor* b, Index i, Index j, double v) override`
	`653`	`+ void bAccessorSet(InternalBlockAccessor* b, Index i, Index j, double v) override`
`654`	`654`	`{`
`655`	`655`	`//set(b->row * getBlockRows() + i, b->col * getBlockCols() + j, v);`
`656`	`656`	`Index index = b->data;`
`657`	`657`	`Block& data = (index >= 0) ? this->colsValue[index] : this->btemp[-index-1].value;`
`658`	`658`	`traits::vset(data, i, j, static_cast<Real>(v) );`
`659`	`659`	`}`
`660`		`- virtual void bAccessorAdd(InternalBlockAccessor* b, Index i, Index j, double v) override`
	`660`	`+ void bAccessorAdd(InternalBlockAccessor* b, Index i, Index j, double v) override`
`661`	`661`	`{`
`662`	`662`	`//add(b->row * getBlockRows() + i, b->col * getBlockCols() + j, v);`
`663`	`663`	`Index index = b->data;`
`@@ -675,15 +675,15 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co`
`675`	`675`	`buffer[l*NC+c] = static_cast<T>(traits::v(data, l, c));`
`676`	`676`	`return buffer;`
`677`	`677`	`}`
`678`		`- virtual const float* bAccessorElements(const InternalBlockAccessor* b, float* buffer) const override`
	`678`	`+ const float* bAccessorElements(const InternalBlockAccessor* b, float* buffer) const override`
`679`	`679`	`{`
`680`	`680`	`return bAccessorElementsCSRImpl<float>(b, buffer);`
`681`	`681`	`}`
`682`		`- virtual const double* bAccessorElements(const InternalBlockAccessor* b, double* buffer) const override`
	`682`	`+ const double* bAccessorElements(const InternalBlockAccessor* b, double* buffer) const override`
`683`	`683`	`{`
`684`	`684`	`return bAccessorElementsCSRImpl<double>(b, buffer);`
`685`	`685`	`}`
`686`		`- virtual const int* bAccessorElements(const InternalBlockAccessor* b, int* buffer) const override`
	`686`	`+ const int* bAccessorElements(const InternalBlockAccessor* b, int* buffer) const override`
`687`	`687`	`{`
`688`	`688`	`return bAccessorElementsCSRImpl<int>(b, buffer);`
`689`	`689`	`}`
`@@ -697,15 +697,15 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co`
`697`	`697`	`for (Index c=0; c < (Index)NC; ++c)`
`698`	`698`	`traits::vset(data, l, c, static_cast<Real>(buffer[l*NC+c]) );`
`699`	`699`	`}`
`700`		`- virtual void bAccessorSet(InternalBlockAccessor* b, const float* buffer) override`
	`700`	`+ void bAccessorSet(InternalBlockAccessor* b, const float* buffer) override`
`701`	`701`	`{`
`702`	`702`	`bAccessorSetCSRImpl<float>(b, buffer);`
`703`	`703`	`}`
`704`		`- virtual void bAccessorSet(InternalBlockAccessor* b, const double* buffer) override`
	`704`	`+ void bAccessorSet(InternalBlockAccessor* b, const double* buffer) override`
`705`	`705`	`{`
`706`	`706`	`bAccessorSetCSRImpl<double>(b, buffer);`
`707`	`707`	`}`
`708`		`- virtual void bAccessorSet(InternalBlockAccessor* b, const int* buffer) override`
	`708`	`+ void bAccessorSet(InternalBlockAccessor* b, const int* buffer) override`
`709`	`709`	`{`
`710`	`710`	`bAccessorSetCSRImpl<int>(b, buffer);`
`711`	`711`	`}`
`@@ -719,23 +719,23 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co`
`719`	`719`	`for (Index c=0; c < (Index)NC; ++c)`
`720`	`720`	`traits::vadd(data, l, c,static_cast<Real>(buffer[l*NC+c]) );`
`721`	`721`	`}`
`722`		`- virtual void bAccessorAdd(InternalBlockAccessor* b, const float* buffer) override`
	`722`	`+ void bAccessorAdd(InternalBlockAccessor* b, const float* buffer) override`
`723`	`723`	`{`
`724`	`724`	`bAccessorAddCSRImpl<float>(b, buffer);`
`725`	`725`	`}`
`726`		`- virtual void bAccessorAdd(InternalBlockAccessor* b, const double* buffer) override`
	`726`	`+ void bAccessorAdd(InternalBlockAccessor* b, const double* buffer) override`
`727`	`727`	`{`
`728`	`728`	`bAccessorAddCSRImpl<double>(b, buffer);`
`729`	`729`	`}`
`730`		`- virtual void bAccessorAdd(InternalBlockAccessor* b, const int* buffer) override`
	`730`	`+ void bAccessorAdd(InternalBlockAccessor* b, const int* buffer) override`
`731`	`731`	`{`
`732`	`732`	`bAccessorAddCSRImpl<int>(b, buffer);`
`733`	`733`	`}`
`734`	`734`
`735`	`735`	`public:`
`736`	`736`
`737`	`737`	`/// Get read access to a block`
`738`		`- virtual BlockConstAccessor blockGet(Index i, Index j) const`
	`738`	`+ BlockConstAccessor blockGet(Index i, Index j) const`
`739`	`739`	`{`
`740`	`740`	`if constexpr (Policy::AutoCompress) const_cast<Matrix*>(this)->compress(); /// \warning this violates the const-ness of the method !`
`741`	`741`
`@@ -753,7 +753,7 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co`
`753`	`753`	`}`
`754`	`754`
`755`	`755`	`/// Get write access to a block`
`756`		`- virtual BlockAccessor blockGetW(Index i, Index j)`
	`756`	`+ BlockAccessor blockGetW(Index i, Index j)`
`757`	`757`	`{`
`758`	`758`	`if constexpr (Policy::AutoCompress) compress();`
`759`	`759`
`@@ -771,7 +771,7 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co`
`771`	`771`	`}`
`772`	`772`
`773`	`773`	`/// Get write access to a block, possibly creating it`
`774`		`- virtual BlockAccessor blockCreate(Index i, Index j)`
	`774`	`+ BlockAccessor blockCreate(Index i, Index j)`
`775`	`775`	`{`
`776`	`776`	`Index rowId = Index(i * this->rowIndex.size() / this->nBlockRow);`
`777`	`777`	`if (this->sortedFind(this->rowIndex, i, rowId))`
`@@ -792,35 +792,35 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co`
`792`	`792`	`}`
`793`	`793`
`794`	`794`	`protected:`
`795`		`- virtual void itCopyColBlock(InternalColBlockIterator* /it/) const override {}`
`796`		`- virtual void itDeleteColBlock(const InternalColBlockIterator* /it/) const override {}`
`797`		`- virtual void itAccessColBlock(InternalColBlockIterator* it, BlockConstAccessor* b) const override`
	`795`	`+ void itCopyColBlock(InternalColBlockIterator* /it/) const override {}`
	`796`	`+ void itDeleteColBlock(const InternalColBlockIterator* /it/) const override {}`
	`797`	`+ void itAccessColBlock(InternalColBlockIterator* it, BlockConstAccessor* b) const override`
`798`	`798`	`{`
`799`	`799`	`Index index = it->data;`
`800`	`800`	`setMatrix(b);`
`801`	`801`	`getInternal(b)->row = it->row;`
`802`	`802`	`getInternal(b)->data = index;`
`803`	`803`	`getInternal(b)->col = this->colsIndex[index];`
`804`	`804`	`}`
`805`		`- virtual void itIncColBlock(InternalColBlockIterator* it) const override`
	`805`	`+ void itIncColBlock(InternalColBlockIterator* it) const override`
`806`	`806`	`{`
`807`	`807`	`Index index = it->data;`
`808`	`808`	`++index;`
`809`	`809`	`it->data = index;`
`810`	`810`	`}`
`811`		`- virtual void itDecColBlock(InternalColBlockIterator* it) const override`
	`811`	`+ void itDecColBlock(InternalColBlockIterator* it) const override`
`812`	`812`	`{`
`813`	`813`	`Index index = it->data;`
`814`	`814`	`--index;`
`815`	`815`	`it->data = index;`
`816`	`816`	`}`
`817`		`- virtual bool itEqColBlock(const InternalColBlockIterator* it, const InternalColBlockIterator* it2) const override`
	`817`	`+ bool itEqColBlock(const InternalColBlockIterator* it, const InternalColBlockIterator* it2) const override`
`818`	`818`	`{`
`819`	`819`	`Index index = it->data;`
`820`	`820`	`Index index2 = it2->data;`
`821`	`821`	`return index == index2;`
`822`	`822`	`}`
`823`		`- virtual bool itLessColBlock(const InternalColBlockIterator* it, const InternalColBlockIterator* it2) const override`
	`823`	`+ bool itLessColBlock(const InternalColBlockIterator* it, const InternalColBlockIterator* it2) const override`
`824`	`824`	`{`
`825`	`825`	`Index index = it->data;`
`826`	`826`	`Index index2 = it2->data;`
`@@ -829,7 +829,7 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co`
`829`	`829`
`830`	`830`	`public:`
`831`	`831`	`/// Get the iterator corresponding to the beginning of the given row of blocks`
`832`		`- virtual ColBlockConstIterator bRowBegin(Index ib) const override`
	`832`	`+ ColBlockConstIterator bRowBegin(Index ib) const override`
`833`	`833`	`{`
`834`	`834`	`if constexpr (Policy::AutoCompress) const_cast<Matrix*>(this)->compress(); /// \warning this violates the const-ness of the method !`
`835`	`835`	`Index rowId = Index(ib * this->rowIndex.size() / this->nBlockRow);`
`@@ -842,7 +842,7 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co`
`842`	`842`	`}`
`843`	`843`
`844`	`844`	`/// Get the iterator corresponding to the end of the given row of blocks`
`845`		`- virtual ColBlockConstIterator bRowEnd(Index ib) const override`
	`845`	`+ ColBlockConstIterator bRowEnd(Index ib) const override`
`846`	`846`	`{`
`847`	`847`	`if constexpr (Policy::AutoCompress) const_cast<Matrix*>(this)->compress(); /// \warning this violates the const-ness of the method !`
`848`	`848`	`Index rowId = Index(ib * this->rowIndex.size() / this->nBlockRow);`
`@@ -855,7 +855,7 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co`
`855`	`855`	`}`
`856`	`856`
`857`	`857`	`/// Get the iterators corresponding to the beginning and end of the given row of blocks`
`858`		`- virtual std::pair<ColBlockConstIterator, ColBlockConstIterator> bRowRange(Index ib) const override`
	`858`	`+ std::pair<ColBlockConstIterator, ColBlockConstIterator> bRowRange(Index ib) const override`
`859`	`859`	`{`
`860`	`860`	`if constexpr (Policy::AutoCompress) const_cast<Matrix*>(this)->compress(); /// \warning this violates the const-ness of the method !`
`861`	`861`	`Index rowId = Index(ib * this->rowIndex.size() / this->nBlockRow);`
`@@ -871,28 +871,28 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co`
`871`	`871`
`872`	`872`
`873`	`873`	`protected:`
`874`		`- virtual void itCopyRowBlock(InternalRowBlockIterator* /it/) const override {}`
`875`		`- virtual void itDeleteRowBlock(const InternalRowBlockIterator* /it/) const override {}`
`876`		`- virtual Index itAccessRowBlock(InternalRowBlockIterator* it) const override`
	`874`	`+ void itCopyRowBlock(InternalRowBlockIterator* /it/) const override {}`
	`875`	`+ void itDeleteRowBlock(const InternalRowBlockIterator* /it/) const override {}`
	`876`	`+ Index itAccessRowBlock(InternalRowBlockIterator* it) const override`
`877`	`877`	`{`
`878`	`878`	`Index rowId = it->data[0];`
`879`	`879`	`return this->rowIndex[rowId];`
`880`	`880`	`}`
`881`		`- virtual ColBlockConstIterator itBeginRowBlock(InternalRowBlockIterator* it) const override`
	`881`	`+ ColBlockConstIterator itBeginRowBlock(InternalRowBlockIterator* it) const override`
`882`	`882`	`{`
`883`	`883`	`Index rowId = it->data[0];`
`884`	`884`	`Index row = this->rowIndex[rowId];`
`885`	`885`	`Index index = this->rowBegin[rowId];`
`886`	`886`	`return createColBlockConstIterator(row, index);`
`887`	`887`	`}`
`888`		`- virtual ColBlockConstIterator itEndRowBlock(InternalRowBlockIterator* it) const override`
	`888`	`+ ColBlockConstIterator itEndRowBlock(InternalRowBlockIterator* it) const override`
`889`	`889`	`{`
`890`	`890`	`Index rowId = it->data[0];`
`891`	`891`	`Index row = this->rowIndex[rowId];`
`892`	`892`	`Index index2 = this->rowBegin[rowId+1];`
`893`	`893`	`return createColBlockConstIterator(row, index2);`
`894`	`894`	`}`
`895`		`- virtual std::pair<ColBlockConstIterator, ColBlockConstIterator> itRangeRowBlock(InternalRowBlockIterator* it) const override`
	`895`	`+ std::pair<ColBlockConstIterator, ColBlockConstIterator> itRangeRowBlock(InternalRowBlockIterator* it) const override`
`896`	`896`	`{`
`897`	`897`	`Index rowId = it->data[0];`
`898`	`898`	`Index row = this->rowIndex[rowId];`
`@@ -902,25 +902,25 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co`
`902`	`902`	`createColBlockConstIterator(row, index2));`
`903`	`903`	`}`
`904`	`904`
`905`		`- virtual void itIncRowBlock(InternalRowBlockIterator* it) const override`
	`905`	`+ void itIncRowBlock(InternalRowBlockIterator* it) const override`
`906`	`906`	`{`
`907`	`907`	`Index rowId = it->data[0];`
`908`	`908`	`++rowId;`
`909`	`909`	`it->data[0] = rowId;`
`910`	`910`	`}`
`911`		`- virtual void itDecRowBlock(InternalRowBlockIterator* it) const override`
	`911`	`+ void itDecRowBlock(InternalRowBlockIterator* it) const override`
`912`	`912`	`{`
`913`	`913`	`Index rowId = it->data[0];`
`914`	`914`	`--rowId;`
`915`	`915`	`it->data[0] = rowId;`
`916`	`916`	`}`
`917`		`- virtual bool itEqRowBlock(const InternalRowBlockIterator* it, const InternalRowBlockIterator* it2) const override`
	`917`	`+ bool itEqRowBlock(const InternalRowBlockIterator* it, const InternalRowBlockIterator* it2) const override`
`918`	`918`	`{`
`919`	`919`	`Index rowId = it->data[0];`
`920`	`920`	`Index rowId2 = it2->data[0];`
`921`	`921`	`return rowId == rowId2;`
`922`	`922`	`}`
`923`		`- virtual bool itLessRowBlock(const InternalRowBlockIterator* it, const InternalRowBlockIterator* it2) const override`
	`923`	`+ bool itLessRowBlock(const InternalRowBlockIterator* it, const InternalRowBlockIterator* it2) const override`
`924`	`924`	`{`
`925`	`925`	`Index rowId = it->data[0];`
`926`	`926`	`Index rowId2 = it2->data[0];`
`@@ -929,21 +929,21 @@ class CompressedRowSparseMatrixMechanical final // final is used to allow the co`
`929`	`929`
`930`	`930`	`public:`
`931`	`931`	`/// Get the iterator corresponding to the beginning of the rows of blocks`
`932`		`- virtual RowBlockConstIterator bRowsBegin() const override`
	`932`	`+ RowBlockConstIterator bRowsBegin() const override`
`933`	`933`	`{`
`934`	`934`	`if constexpr (Policy::AutoCompress) const_cast<Matrix*>(this)->compress(); /// \warning this violates the const-ness of the method !`
`935`	`935`	`return createRowBlockConstIterator(0, 0);`
`936`	`936`	`}`
`937`	`937`
`938`	`938`	`/// Get the iterator corresponding to the end of the rows of blocks`
`939`		`- virtual RowBlockConstIterator bRowsEnd() const override`
	`939`	`+ RowBlockConstIterator bRowsEnd() const override`
`940`	`940`	`{`
`941`	`941`	`if constexpr (Policy::AutoCompress) const_cast<Matrix*>(this)->compress(); /// \warning this violates the const-ness of the method !`
`942`	`942`	`return createRowBlockConstIterator(Index(this->rowIndex.size()), 0);`
`943`	`943`	`}`
`944`	`944`
`945`	`945`	`/// Get the iterators corresponding to the beginning and end of the given row of blocks`
`946`		`- virtual std::pair<RowBlockConstIterator, RowBlockConstIterator> bRowsRange() const override`
	`946`	`+ std::pair<RowBlockConstIterator, RowBlockConstIterator> bRowsRange() const override`
`947`	`947`	`{`
`948`	`948`	`if constexpr (Policy::AutoCompress) const_cast<Matrix*>(this)->compress(); /// \warning this violates the const-ness of the method !`
`949`	`949`	`return std::make_pair(createRowBlockConstIterator(0, 0),`
Original file line number	Diff line number	Diff line change
`@@ -528,17 +528,17 @@ class Mat`
`528`	`528`
`529`	`529`	`bool isDiagonal() const noexcept`
`530`	`530`	`{`
`531`		`- for (Size i=0; i<L; i++)`
	`531`	`+ for (Size i=0; i<L; ++i)`
`532`	`532`	`{`
`533`		`- for (Size j=0; j<i-1; j++)`
`534`		`- if( rabs( (*this)(i,j) ) > EQUALITY_THRESHOLD ) return false;`
`535`		`- for (Size j=i+1; j<C; j++)`
	`533`	`+ for (Size j=0; j<C; ++j)`
	`534`	`+ {`
	`535`	`+ if (j == i) continue;`
`536`	`536`	`if( rabs( (*this)(i,j) ) > EQUALITY_THRESHOLD ) return false;`
	`537`	`+ }`
`537`	`538`	`}`
`538`	`539`	`return true;`
`539`	`540`	`}`
`540`	`541`
`541`		`-`
`542`	`542`	`/// @}`
`543`	`543`
`544`	`544`	`// LINEAR ALGEBRA`