concepts.hpp

CGAL is a collaborative effort of several sites in Europe and Israel. The goal is to make the most i

        IndexedRandomAccess1DIteratorConcept<scalar_vector<double>::const_reverse_iterator>::constraints ();

        VectorConcept<const c_vector<double, 1> >::constraints ();
        MutableVectorConcept<c_vector<double, 1> >::constraints ();
        IndexedRandomAccess1DIteratorConcept<c_vector<double, 1>::const_iterator>::constraints ();
        MutableIndexedRandomAccess1DIteratorConcept<c_vector<double, 1>::iterator>::constraints ();
        IndexedRandomAccess1DIteratorConcept<c_vector<double, 1>::const_reverse_iterator>::constraints ();
        MutableIndexedRandomAccess1DIteratorConcept<c_vector<double, 1>::reverse_iterator>::constraints ();
#endif

        // Vector Proxies
#if defined (INTERNAL) || defined (INTERNAL_VECTOR_PROXY)
        VectorExpressionConcept<const vector_range<const vector<double> > >::constraints ();
        MutableVectorExpressionConcept<vector_range<vector<double> > >::constraints ();
        IndexedRandomAccess1DIteratorConcept<vector_range<vector<double> >::const_iterator>::constraints ();
        MutableIndexedRandomAccess1DIteratorConcept<vector_range<vector<double> >::iterator>::constraints ();
        IndexedRandomAccess1DIteratorConcept<vector_range<vector<double> >::const_reverse_iterator>::constraints ();
        MutableIndexedRandomAccess1DIteratorConcept<vector_range<vector<double> >::reverse_iterator>::constraints ();

        VectorExpressionConcept<const vector_slice<const vector<double> > >::constraints ();
        MutableVectorExpressionConcept<vector_slice<vector<double> > >::constraints ();
        IndexedRandomAccess1DIteratorConcept<vector_slice<vector<double> >::const_iterator>::constraints ();
        MutableIndexedRandomAccess1DIteratorConcept<vector_slice<vector<double> >::iterator>::constraints ();
        IndexedRandomAccess1DIteratorConcept<vector_slice<vector<double> >::const_reverse_iterator>::constraints ();
        MutableIndexedRandomAccess1DIteratorConcept<vector_slice<vector<double> >::reverse_iterator>::constraints ();

        VectorExpressionConcept<const vector_indirect<const vector<double> > >::constraints ();
        MutableVectorExpressionConcept<vector_indirect<vector<double> > >::constraints ();
        IndexedRandomAccess1DIteratorConcept<vector_indirect<vector<double> >::const_iterator>::constraints ();
        MutableIndexedRandomAccess1DIteratorConcept<vector_indirect<vector<double> >::iterator>::constraints ();
        IndexedRandomAccess1DIteratorConcept<vector_indirect<vector<double> >::const_reverse_iterator>::constraints ();
        MutableIndexedRandomAccess1DIteratorConcept<vector_indirect<vector<double> >::reverse_iterator>::constraints ();
#endif

        // Sparse Vector
#if defined (INTERNAL) || defined (INTERNAL_VECTOR_SPARSE)
        VectorConcept<const sparse_vector<double> >::constraints ();
        MutableVectorConcept<sparse_vector<double> >::constraints ();
        IndexedBidirectional1DIteratorConcept<sparse_vector<double>::const_iterator>::constraints ();
        MutableIndexedBidirectional1DIteratorConcept<sparse_vector<double>::iterator>::constraints ();
        IndexedBidirectional1DIteratorConcept<sparse_vector<double>::const_reverse_iterator>::constraints ();
        MutableIndexedBidirectional1DIteratorConcept<sparse_vector<double>::reverse_iterator>::constraints ();

        VectorConcept<const compressed_vector<double> >::constraints ();
        MutableVectorConcept<compressed_vector<double> >::constraints ();
        IndexedBidirectional1DIteratorConcept<compressed_vector<double>::const_iterator>::constraints ();
        MutableIndexedBidirectional1DIteratorConcept<compressed_vector<double>::iterator>::constraints ();
        IndexedBidirectional1DIteratorConcept<compressed_vector<double>::const_reverse_iterator>::constraints ();
        MutableIndexedBidirectional1DIteratorConcept<compressed_vector<double>::reverse_iterator>::constraints ();

        VectorConcept<const coordinate_vector<double> >::constraints ();
        MutableVectorConcept<coordinate_vector<double> >::constraints ();
        IndexedBidirectional1DIteratorConcept<coordinate_vector<double>::const_iterator>::constraints ();
        MutableIndexedBidirectional1DIteratorConcept<coordinate_vector<double>::iterator>::constraints ();
        IndexedBidirectional1DIteratorConcept<coordinate_vector<double>::const_reverse_iterator>::constraints ();
        MutableIndexedBidirectional1DIteratorConcept<coordinate_vector<double>::reverse_iterator>::constraints ();
#endif

        // Matrix
#if defined (INTERNAL) || defined (INTERNAL_MATRIX)
        MatrixConcept<const matrix<double> >::constraints ();
        MutableMatrixConcept<matrix<double> >::constraints ();
        IndexedRandomAccess2DIteratorConcept<matrix<double>::const_iterator1,
                                             matrix<double>::const_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<matrix<double>::iterator1,
                                                    matrix<double>::iterator2>::constraints ();
        IndexedRandomAccess2DIteratorConcept<matrix<double>::const_reverse_iterator1,
                                             matrix<double>::const_reverse_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<matrix<double>::reverse_iterator1,
                                                    matrix<double>::reverse_iterator2>::constraints ();

        MatrixConcept<const vector_of_vector<double> >::constraints ();
        MutableMatrixConcept<vector_of_vector<double> >::constraints ();
        IndexedRandomAccess2DIteratorConcept<vector_of_vector<double>::const_iterator1,
                                             vector_of_vector<double>::const_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<vector_of_vector<double>::iterator1,
                                                    vector_of_vector<double>::iterator2>::constraints ();
        IndexedRandomAccess2DIteratorConcept<vector_of_vector<double>::const_reverse_iterator1,
                                             vector_of_vector<double>::const_reverse_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<vector_of_vector<double>::reverse_iterator1,
                                                    vector_of_vector<double>::reverse_iterator2>::constraints ();

        MatrixConcept<identity_matrix<double> >::constraints ();
        IndexedRandomAccess2DIteratorConcept<identity_matrix<double>::const_iterator1,
                                             identity_matrix<double>::const_iterator2>::constraints ();
        IndexedRandomAccess2DIteratorConcept<identity_matrix<double>::const_reverse_iterator1,
                                             identity_matrix<double>::const_reverse_iterator2>::constraints ();

        MatrixConcept<zero_matrix<double> >::constraints ();
        IndexedBidirectional2DIteratorConcept<zero_matrix<double>::const_iterator1,
                                              zero_matrix<double>::const_iterator2>::constraints ();
        IndexedBidirectional2DIteratorConcept<zero_matrix<double>::const_reverse_iterator1,
                                              zero_matrix<double>::const_reverse_iterator2>::constraints ();

        MatrixConcept<scalar_matrix<double> >::constraints ();
        IndexedRandomAccess2DIteratorConcept<scalar_matrix<double>::const_iterator1,
                                             scalar_matrix<double>::const_iterator2>::constraints ();
        IndexedRandomAccess2DIteratorConcept<scalar_matrix<double>::const_reverse_iterator1,
                                             scalar_matrix<double>::const_reverse_iterator2>::constraints ();

        MatrixConcept<const c_matrix<double, 1, 1> >::constraints ();
        MutableMatrixConcept<c_matrix<double, 1, 1> >::constraints ();
        IndexedRandomAccess2DIteratorConcept<c_matrix<double, 1, 1>::const_iterator1,
                                             c_matrix<double, 1, 1>::const_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<c_matrix<double, 1, 1>::iterator1,
                                                    c_matrix<double, 1, 1>::iterator2>::constraints ();
        IndexedRandomAccess2DIteratorConcept<c_matrix<double, 1, 1>::const_reverse_iterator1,
                                             c_matrix<double, 1, 1>::const_reverse_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<c_matrix<double, 1, 1>::reverse_iterator1,
                                                    c_matrix<double, 1, 1>::reverse_iterator2>::constraints ();
#endif

        // Matrix Proxies
#if defined (INTERNAL) || defined (INTERNAL_MATRIX_PROXY)
        VectorExpressionConcept<const matrix_row<const matrix<double> > >::constraints ();
        MutableVectorExpressionConcept<matrix_row<matrix<double> > >::constraints ();
        IndexedRandomAccess1DIteratorConcept<matrix_row<matrix<double> >::const_iterator>::constraints ();
        MutableIndexedRandomAccess1DIteratorConcept<matrix_row<matrix<double> >::iterator>::constraints ();
        IndexedRandomAccess1DIteratorConcept<matrix_row<matrix<double> >::const_reverse_iterator>::constraints ();
        MutableIndexedRandomAccess1DIteratorConcept<matrix_row<matrix<double> >::reverse_iterator>::constraints ();

        VectorExpressionConcept<const matrix_column<const matrix<double> > >::constraints ();
        MutableVectorExpressionConcept<matrix_column<matrix<double> > >::constraints ();
        IndexedRandomAccess1DIteratorConcept<matrix_column<matrix<double> >::const_iterator>::constraints ();
        MutableIndexedRandomAccess1DIteratorConcept<matrix_column<matrix<double> >::iterator>::constraints ();
        IndexedRandomAccess1DIteratorConcept<matrix_column<matrix<double> >::const_reverse_iterator>::constraints ();
        MutableIndexedRandomAccess1DIteratorConcept<matrix_column<matrix<double> >::reverse_iterator>::constraints ();

        VectorExpressionConcept<const matrix_vector_range<const matrix<double> > >::constraints ();
        MutableVectorExpressionConcept<matrix_vector_range<matrix<double> > >::constraints ();
        IndexedRandomAccess1DIteratorConcept<matrix_vector_range<matrix<double> >::const_iterator>::constraints ();
        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_range<matrix<double> >::iterator>::constraints ();
        IndexedRandomAccess1DIteratorConcept<matrix_vector_range<matrix<double> >::const_reverse_iterator>::constraints ();
        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_range<matrix<double> >::reverse_iterator>::constraints ();

        VectorExpressionConcept<const matrix_vector_slice<const matrix<double> > >::constraints ();
        MutableVectorExpressionConcept<matrix_vector_slice<matrix<double> > >::constraints ();
        IndexedRandomAccess1DIteratorConcept<matrix_vector_slice<matrix<double> >::const_iterator>::constraints ();
        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_slice<matrix<double> >::iterator>::constraints ();
        IndexedRandomAccess1DIteratorConcept<matrix_vector_slice<matrix<double> >::const_reverse_iterator>::constraints ();
        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_slice<matrix<double> >::reverse_iterator>::constraints ();

        VectorExpressionConcept<const matrix_vector_indirect<const matrix<double>, vector<unsigned> > >::constraints ();
        MutableVectorExpressionConcept<matrix_vector_indirect<matrix<double>, vector<unsigned> > >::constraints ();
        IndexedRandomAccess1DIteratorConcept<matrix_vector_indirect<matrix<double>, vector<unsigned> >::const_iterator>::constraints ();
        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_indirect<matrix<double>, vector<unsigned> >::iterator>::constraints ();
        IndexedRandomAccess1DIteratorConcept<matrix_vector_indirect<matrix<double>, vector<unsigned> >::const_reverse_iterator>::constraints ();
        MutableIndexedRandomAccess1DIteratorConcept<matrix_vector_indirect<matrix<double>, vector<unsigned> >::reverse_iterator>::constraints ();

        MatrixExpressionConcept<const matrix_range<const matrix<double> > >::constraints ();
        MutableMatrixExpressionConcept<matrix_range<matrix<double> > >::constraints ();
        IndexedRandomAccess2DIteratorConcept<matrix_range<matrix<double> >::const_iterator1,
                                             matrix_range<matrix<double> >::const_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<matrix_range<matrix<double> >::iterator1,
                                                    matrix_range<matrix<double> >::iterator2>::constraints ();
        IndexedRandomAccess2DIteratorConcept<matrix_range<matrix<double> >::const_reverse_iterator1,
                                             matrix_range<matrix<double> >::const_reverse_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<matrix_range<matrix<double> >::reverse_iterator1,
                                                    matrix_range<matrix<double> >::reverse_iterator2>::constraints ();

        MatrixExpressionConcept<const matrix_slice<const matrix<double> > >::constraints ();
        MutableMatrixExpressionConcept<matrix_slice<matrix<double> > >::constraints ();
        IndexedRandomAccess2DIteratorConcept<matrix_slice<matrix<double> >::const_iterator1,
                                             matrix_slice<matrix<double> >::const_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<matrix_slice<matrix<double> >::iterator1,
                                                    matrix_slice<matrix<double> >::iterator2>::constraints ();
        IndexedRandomAccess2DIteratorConcept<matrix_slice<matrix<double> >::const_reverse_iterator1,
                                             matrix_slice<matrix<double> >::const_reverse_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<matrix_slice<matrix<double> >::reverse_iterator1,
                                                    matrix_slice<matrix<double> >::reverse_iterator2>::constraints ();

        MatrixExpressionConcept<const matrix_indirect<const matrix<double> > >::constraints ();
        MutableMatrixExpressionConcept<matrix_indirect<matrix<double> > >::constraints ();
        IndexedRandomAccess2DIteratorConcept<matrix_indirect<matrix<double> >::const_iterator1,
                                             matrix_indirect<matrix<double> >::const_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<matrix_indirect<matrix<double> >::iterator1,
                                                    matrix_indirect<matrix<double> >::iterator2>::constraints ();
        IndexedRandomAccess2DIteratorConcept<matrix_indirect<matrix<double> >::const_reverse_iterator1,
                                             matrix_indirect<matrix<double> >::const_reverse_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<matrix_indirect<matrix<double> >::reverse_iterator1,
                                                    matrix_indirect<matrix<double> >::reverse_iterator2>::constraints ();
#endif

        // Banded Matrix
#if defined (INTERNAL) || defined (INTERNAL_BANDED)
        MatrixConcept<const banded_matrix<double> >::constraints ();
        MutableMatrixConcept<banded_matrix<double> >::constraints ();
        IndexedRandomAccess2DIteratorConcept<banded_matrix<double>::const_iterator1,
                                             banded_matrix<double>::const_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<banded_matrix<double>::iterator1,
                                                    banded_matrix<double>::iterator2>::constraints ();
        IndexedRandomAccess2DIteratorConcept<banded_matrix<double>::const_reverse_iterator1,
                                             banded_matrix<double>::const_reverse_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<banded_matrix<double>::reverse_iterator1,
                                                    banded_matrix<double>::reverse_iterator2>::constraints ();

        MatrixExpressionConcept<const banded_adaptor<const matrix<double> > >::constraints ();
        MutableMatrixExpressionConcept<banded_adaptor<matrix<double> > >::constraints ();
        IndexedRandomAccess2DIteratorConcept<banded_adaptor<matrix<double> >::const_iterator1,
                                             banded_adaptor<matrix<double> >::const_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<banded_adaptor<matrix<double> >::iterator1,
                                                    banded_adaptor<matrix<double> >::iterator2>::constraints ();
        IndexedRandomAccess2DIteratorConcept<banded_adaptor<matrix<double> >::const_reverse_iterator1,
                                             banded_adaptor<matrix<double> >::const_reverse_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<banded_adaptor<matrix<double> >::reverse_iterator1,
                                                    banded_adaptor<matrix<double> >::reverse_iterator2>::constraints ();
#endif

        // Triangular Matrix
#if defined (INTERNAL) || defined (INTERNAL_TRIANGULAR)
        MatrixConcept<const triangular_matrix<double> >::constraints ();
        MutableMatrixConcept<triangular_matrix<double> >::constraints ();
        IndexedRandomAccess2DIteratorConcept<triangular_matrix<double>::const_iterator1,
                                             triangular_matrix<double>::const_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<triangular_matrix<double>::iterator1,
                                                    triangular_matrix<double>::iterator2>::constraints ();
        IndexedRandomAccess2DIteratorConcept<triangular_matrix<double>::const_reverse_iterator1,
                                             triangular_matrix<double>::const_reverse_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<triangular_matrix<double>::reverse_iterator1,
                                                    triangular_matrix<double>::reverse_iterator2>::constraints ();

        MatrixExpressionConcept<const triangular_adaptor<const matrix<double> > >::constraints ();
        MutableMatrixExpressionConcept<triangular_adaptor<matrix<double> > >::constraints ();
        IndexedRandomAccess2DIteratorConcept<triangular_adaptor<matrix<double> >::const_iterator1,
                                             triangular_adaptor<matrix<double> >::const_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<triangular_adaptor<matrix<double> >::iterator1,
                                                    triangular_adaptor<matrix<double> >::iterator2>::constraints ();
        IndexedRandomAccess2DIteratorConcept<triangular_adaptor<matrix<double> >::const_reverse_iterator1,
                                             triangular_adaptor<matrix<double> >::const_reverse_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<triangular_adaptor<matrix<double> >::reverse_iterator1,
                                                    triangular_adaptor<matrix<double> >::reverse_iterator2>::constraints ();
#endif

        // Symmetric Matrix
#if defined (INTERNAL) || defined (INTERNAL_SYMMETRIC)
        MatrixConcept<const symmetric_matrix<double> >::constraints ();
        MutableMatrixConcept<symmetric_matrix<double> >::constraints ();
        IndexedRandomAccess2DIteratorConcept<symmetric_matrix<double>::const_iterator1,
                                             symmetric_matrix<double>::const_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<symmetric_matrix<double>::iterator1,
                                                    symmetric_matrix<double>::iterator2>::constraints ();
        IndexedRandomAccess2DIteratorConcept<symmetric_matrix<double>::const_reverse_iterator1,
                                             symmetric_matrix<double>::const_reverse_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<symmetric_matrix<double>::reverse_iterator1,
                                                    symmetric_matrix<double>::reverse_iterator2>::constraints ();

        MatrixExpressionConcept<const symmetric_adaptor<const matrix<double> > >::constraints ();
#ifndef SKIP_BAD
        // const_iterator (iterator) constructor is bad
        MutableMatrixExpressionConcept<symmetric_adaptor<matrix<double> > >::constraints ();
#endif
        IndexedRandomAccess2DIteratorConcept<symmetric_adaptor<matrix<double> >::const_iterator1,
                                             symmetric_adaptor<matrix<double> >::const_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<symmetric_adaptor<matrix<double> >::iterator1,
                                                    symmetric_adaptor<matrix<double> >::iterator2>::constraints ();
        IndexedRandomAccess2DIteratorConcept<symmetric_adaptor<matrix<double> >::const_reverse_iterator1,
                                             symmetric_adaptor<matrix<double> >::const_reverse_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<symmetric_adaptor<matrix<double> >::reverse_iterator1,
                                                    symmetric_adaptor<matrix<double> >::reverse_iterator2>::constraints ();
#endif

        // Hermitian Matrix
#if defined (INTERNAL) || defined (INTERNAL_HERMITIAN)
        MatrixConcept<const hermitian_matrix<double> >::constraints ();
        MutableMatrixConcept<hermitian_matrix<double> >::constraints ();
        IndexedRandomAccess2DIteratorConcept<hermitian_matrix<double>::const_iterator1,
                                             hermitian_matrix<double>::const_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<hermitian_matrix<double>::iterator1,
                                                    hermitian_matrix<double>::iterator2>::constraints ();
        IndexedRandomAccess2DIteratorConcept<hermitian_matrix<double>::const_reverse_iterator1,
                                             hermitian_matrix<double>::const_reverse_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<hermitian_matrix<double>::reverse_iterator1,
                                                    hermitian_matrix<double>::reverse_iterator2>::constraints ();

        MatrixExpressionConcept<const hermitian_adaptor<const matrix<double> > >::constraints ();
#ifndef SKIP_BAD
        // const_iterator (iterator) constructor is bad
        MutableMatrixExpressionConcept<hermitian_adaptor<matrix<double> > >::constraints ();
#endif
        IndexedRandomAccess2DIteratorConcept<hermitian_adaptor<matrix<double> >::const_iterator1,
                                             hermitian_adaptor<matrix<double> >::const_iterator2>::constraints ();
        MutableIndexedRandomAccess2DIteratorConcept<hermitian_adaptor<matrix<double> >::iterator1,
                                                    hermitian_adaptor<matrix<double> >::iterator2>::constraints ();
        IndexedRandomAccess2DIteratorConcept<hermitian_adaptor<matrix<double> >::const_reverse_iterator1,
                                             hermit